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 we aren't shutting down the socket.
 720    * NB: Enable_Events needs to be called whether the socket is blocking or
 721    * non-blocking, it just shouldn't be called prior to knowing there is a
 722    * connection _if_ blocking sockets are being used.
 723    * If connect above returns 0, we are already connected and need to make the
 724    * call to Enable_Events now.
 725
 726   if (m_non_blocking || ret == 0)
 727   {
 728     gs_gui_functions->Enable_Events(this);
 729   }
 730
 731   if (ret == -1)
 732   {
 733     err = errno;
 734
 735     /* If connect failed with EINPROGRESS and the GSocket object
 736      * is in blocking mode, we select() for the specified timeout
 737      * checking for writability to see if the connection request
 738      * completes.
 739      */
 740     if ((err == EINPROGRESS) && (!m_non_blocking))
 741     {
 742       if (Output_Timeout() == GSOCK_TIMEDOUT)
 743       {
 744         Close();
 745         /* m_error is set in _GSocket_Output_Timeout */
 746         return GSOCK_TIMEDOUT;
 747       }
 748       else
 749       {
 750         int error;
 751         SOCKOPTLEN_T len = sizeof(error);
 752
 753         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
 754
 755         gs_gui_functions->Enable_Events(this);
 756
 757         if (!error)
 758           return GSOCK_NOERROR;
 759       }
 760     }
 761
 762     /* If connect failed with EINPROGRESS and the GSocket object
 763      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 764      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 765      * this way if the connection completes, a GSOCK_CONNECTION
 766      * event will be generated, if enabled.
 767      */
 768     if ((err == EINPROGRESS) && (m_non_blocking))
 769     {
 770       m_establishing = true;
 771       m_error = GSOCK_WOULDBLOCK;
 772       return GSOCK_WOULDBLOCK;
 773     }
 774
 775     /* If connect failed with an error other than EINPROGRESS,
 776      * then the call to GSocket_Connect has failed.
 777      */
 778     Close();
 779     m_error = GSOCK_IOERR;
 780     return GSOCK_IOERR;
 781   }
 782
 783   return GSOCK_NOERROR;
 784 }
 785
 786 /* Datagram sockets */
 787
 788 /* GSocket_SetNonOriented:
 789  *  Sets up this socket as a non-connection oriented (datagram) socket.
 790  *  Before using this function, the local address must have been set
 791  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 792  *  on success, or one of the following otherwise.
 793  *
 794  *  Error codes:
 795  *    GSOCK_INVSOCK - the socket is in use.
 796  *    GSOCK_INVADDR - the local address has not been set.
 797  *    GSOCK_IOERR   - low-level error.
 798  */
 799 GSocketError GSocket::SetNonOriented()
 800 {
 801   int arg = 1;
 802
 803   assert(this);
 804
 805   if (m_fd != INVALID_SOCKET)
 806   {
 807     m_error = GSOCK_INVSOCK;
 808     return GSOCK_INVSOCK;
 809   }
 810
 811   if (!m_local)
 812   {
 813     m_error = GSOCK_INVADDR;
 814     return GSOCK_INVADDR;
 815   }
 816
 817   /* Initialize all fields */
 818   m_stream   = false;
 819   m_server   = false;
 820
 821   /* Create the socket */
 822   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 823
 824   if (m_fd == INVALID_SOCKET)
 825   {
 826     m_error = GSOCK_IOERR;
 827     return GSOCK_IOERR;
 828   }
 829 #if defined(__EMX__) || defined(__VISAGECPP__)
 830   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 831 #else
 832   ioctl(m_fd, FIONBIO, &arg);
 833 #endif
 834   gs_gui_functions->Enable_Events(this);
 835
 836   /* Bind to the local address,
 837    * and retrieve the actual address bound.
 838    */
 839   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 840       (getsockname(m_fd,
 841                    m_local->m_addr,
 842                    (WX_SOCKLEN_T *) &m_local->m_len) != 0))
 843   {
 844     Close();
 845     m_error = GSOCK_IOERR;
 846     return GSOCK_IOERR;
 847   }
 848
 849   return GSOCK_NOERROR;
 850 }
 851
 852 /* Generic IO */
 853
 854 /* Like recv(), send(), ... */
 855 int GSocket::Read(char *buffer, int size)
 856 {
 857   int ret;
 858
 859   assert(this);
 860
 861   if (m_fd == INVALID_SOCKET || m_server)
 862   {
 863     m_error = GSOCK_INVSOCK;
 864     return -1;
 865   }
 866
 867   /* Disable events during query of socket status */
 868   Disable(GSOCK_INPUT);
 869
 870   /* If the socket is blocking, wait for data (with a timeout) */
 871   if (Input_Timeout() == GSOCK_TIMEDOUT)
 872     /* We no longer return here immediately, otherwise socket events would not be re-enabled! */
 873     ret = -1;
 874   else {
 875     /* Read the data */
 876     if (m_stream)
 877       ret = Recv_Stream(buffer, size);
 878     else
 879       ret = Recv_Dgram(buffer, size);
 880   }
 881
 882   if (ret == -1)
 883   {
 884     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
 885       m_error = GSOCK_WOULDBLOCK;
 886     else
 887       m_error = GSOCK_IOERR;
 888   }
 889
 890   /* Enable events again now that we are done processing */
 891   Enable(GSOCK_INPUT);
 892
 893   return ret;
 894 }
 895
 896 int GSocket::Write(const char *buffer, int size)
 897 {
 898   int ret;
 899
 900   assert(this);
 901
 902   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
 903
 904   if (m_fd == INVALID_SOCKET || m_server)
 905   {
 906     m_error = GSOCK_INVSOCK;
 907     return -1;
 908   }
 909
 910   GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
 911
 912   /* If the socket is blocking, wait for writability (with a timeout) */
 913   if (Output_Timeout() == GSOCK_TIMEDOUT)
 914     return -1;
 915
 916   GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
 917
 918   /* Write the data */
 919   if (m_stream)
 920     ret = Send_Stream(buffer, size);
 921   else
 922     ret = Send_Dgram(buffer, size);
 923
 924   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
 925
 926   if (ret == -1)
 927   {
 928     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
 929     {
 930       m_error = GSOCK_WOULDBLOCK;
 931       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
 932     }
 933     else
 934     {
 935       m_error = GSOCK_IOERR;
 936       GSocket_Debug(( "GSocket_Write error IOERR\n" ));
 937     }
 938
 939     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 940      * in MSW). Once the first OUTPUT event is received, users can assume
 941      * that the socket is writable until a read operation fails. Only then
 942      * will further OUTPUT events be posted.
 943      */
 944     Enable(GSOCK_OUTPUT);
 945     return -1;
 946   }
 947
 948   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
 949
 950   return ret;
 951 }
 952
 953 /* GSocket_Select:
 954  *  Polls the socket to determine its status. This function will
 955  *  check for the events specified in the 'flags' parameter, and
 956  *  it will return a mask indicating which operations can be
 957  *  performed. This function won't block, regardless of the
 958  *  mode (blocking | nonblocking) of the socket.
 959  */
 960 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 961 {
 962   if (!gs_gui_functions->CanUseEventLoop())
 963   {
 964
 965     GSocketEventFlags result = 0;
 966     fd_set readfds;
 967     fd_set writefds;
 968     fd_set exceptfds;
 969     struct timeval tv;
 970
 971     assert(this);
 972
 973     if (m_fd == -1)
 974         return (GSOCK_LOST_FLAG & flags);
 975
 976     /* Do not use a static struct, Linux can garble it */
 977     tv.tv_sec = m_timeout / 1000;
 978     tv.tv_usec = (m_timeout % 1000) * 1000;
 979
 980     FD_ZERO(&readfds);
 981     FD_ZERO(&writefds);
 982     FD_ZERO(&exceptfds);
 983     FD_SET(m_fd, &readfds);
 984     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
 985       FD_SET(m_fd, &writefds);
 986     FD_SET(m_fd, &exceptfds);
 987
 988     /* Check 'sticky' CONNECTION flag first */
 989     result |= (GSOCK_CONNECTION_FLAG & m_detected);
 990
 991     /* If we have already detected a LOST event, then don't try
 992      * to do any further processing.
 993      */
 994     if ((m_detected & GSOCK_LOST_FLAG) != 0)
 995     {
 996       m_establishing = false;
 997
 998       return (GSOCK_LOST_FLAG & flags);
 999     }
1000
1001     /* Try select now */
1002     if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
1003     {
1004       /* What to do here? */
1005       return (result & flags);
1006     }
1007
1008     /* Check for readability */
1009     if (FD_ISSET(m_fd, &readfds))
1010     {
1011       char c;
1012
1013       int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1014
1015       if (num > 0)
1016       {
1017         result |= GSOCK_INPUT_FLAG;
1018       }
1019       else
1020       {
1021         if (m_server && m_stream)
1022         {
1023           result |= GSOCK_CONNECTION_FLAG;
1024           m_detected |= GSOCK_CONNECTION_FLAG;
1025         }
1026         else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR))
1027         {
1028           m_detected = GSOCK_LOST_FLAG;
1029           m_establishing = false;
1030
1031           /* LOST event: Abort any further processing */
1032           return (GSOCK_LOST_FLAG & flags);
1033         }
1034       }
1035     }
1036
1037     /* Check for writability */
1038     if (FD_ISSET(m_fd, &writefds))
1039     {
1040       if (m_establishing && !m_server)
1041       {
1042         int error;
1043         SOCKOPTLEN_T len = sizeof(error);
1044
1045         m_establishing = false;
1046
1047         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1048
1049         if (error)
1050         {
1051           m_detected = GSOCK_LOST_FLAG;
1052
1053           /* LOST event: Abort any further processing */
1054           return (GSOCK_LOST_FLAG & flags);
1055         }
1056         else
1057         {
1058           result |= GSOCK_CONNECTION_FLAG;
1059           m_detected |= GSOCK_CONNECTION_FLAG;
1060         }
1061       }
1062       else
1063       {
1064         result |= GSOCK_OUTPUT_FLAG;
1065       }
1066     }
1067
1068     /* Check for exceptions and errors (is this useful in Unices?) */
1069     if (FD_ISSET(m_fd, &exceptfds))
1070     {
1071       m_establishing = false;
1072       m_detected = GSOCK_LOST_FLAG;
1073
1074       /* LOST event: Abort any further processing */
1075       return (GSOCK_LOST_FLAG & flags);
1076     }
1077
1078     return (result & flags);
1079
1080   }
1081   else
1082   {
1083
1084     assert(this);
1085     return flags & m_detected;
1086
1087   }
1088 }
1089
1090 /* Flags */
1091
1092 /* GSocket_SetNonBlocking:
1093  *  Sets the socket to non-blocking mode. All IO calls will return
1094  *  immediately.
1095  */
1096 void GSocket::SetNonBlocking(bool non_block)
1097 {
1098   assert(this);
1099
1100   GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1101
1102   m_non_blocking = non_block;
1103 }
1104
1105 /* GSocket_SetTimeout:
1106  *  Sets the timeout for blocking calls. Time is expressed in
1107  *  milliseconds.
1108  */
1109 void GSocket::SetTimeout(unsigned long millisec)
1110 {
1111   assert(this);
1112
1113   m_timeout = millisec;
1114 }
1115
1116 /* GSocket_GetError:
1117  *  Returns the last error occurred for this socket. Note that successful
1118  *  operations do not clear this back to GSOCK_NOERROR, so use it only
1119  *  after an error.
1120  */
1121 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
1122 {
1123   assert(this);
1124
1125   return m_error;
1126 }
1127
1128 /* Callbacks */
1129
1130 /* GSOCK_INPUT:
1131  *   There is data to be read in the input buffer. If, after a read
1132  *   operation, there is still data available, the callback function will
1133  *   be called again.
1134  * GSOCK_OUTPUT:
1135  *   The socket is available for writing. That is, the next write call
1136  *   won't block. This event is generated only once, when the connection is
1137  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1138  *   when the output buffer empties again. This means that the app should
1139  *   assume that it can write since the first OUTPUT event, and no more
1140  *   OUTPUT events will be generated unless an error occurs.
1141  * GSOCK_CONNECTION:
1142  *   Connection successfully established, for client sockets, or incoming
1143  *   client connection, for server sockets. Wait for this event (also watch
1144  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1145  * GSOCK_LOST:
1146  *   The connection is lost (or a connection request failed); this could
1147  *   be due to a failure, or due to the peer closing it gracefully.
1148  */
1149
1150 /* GSocket_SetCallback:
1151  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1152  *  may be a combination of flags OR'ed toghether, so the same
1153  *  callback function can be made to accept different events.
1154  *  The callback function must have the following prototype:
1155  *
1156  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1157  */
1158 void GSocket::SetCallback(GSocketEventFlags flags,
1159                          GSocketCallback callback, char *cdata)
1160 {
1161   int count;
1162
1163   assert(this);
1164
1165   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1166   {
1167     if ((flags & (1 << count)) != 0)
1168     {
1169       m_cbacks[count] = callback;
1170       m_data[count] = cdata;
1171     }
1172   }
1173 }
1174
1175 /* GSocket_UnsetCallback:
1176  *  Disables all callbacks specified by 'flags', which may be a
1177  *  combination of flags OR'ed toghether.
1178  */
1179 void GSocket::UnsetCallback(GSocketEventFlags flags)
1180 {
1181   int count;
1182
1183   assert(this);
1184
1185   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1186   {
1187     if ((flags & (1 << count)) != 0)
1188     {
1189       m_cbacks[count] = NULL;
1190       m_data[count] = NULL;
1191     }
1192   }
1193 }
1194
1195 GSocketError GSocket::GetSockOpt(int level, int optname,
1196                                 void *optval, int *optlen)
1197 {
1198     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
1199     {
1200         return GSOCK_NOERROR;
1201     }
1202     return GSOCK_OPTERR;
1203 }
1204
1205 GSocketError GSocket::SetSockOpt(int level, int optname,
1206                                 const void *optval, int optlen)
1207 {
1208     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
1209     {
1210         return GSOCK_NOERROR;
1211     }
1212     return GSOCK_OPTERR;
1213 }
1214
1215 #define CALL_CALLBACK(socket, event) {                                  \
1216   socket->Disable(event);                                               \
1217   if (socket->m_cbacks[event])                                          \
1218     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
1219 }
1220
1221
1222 void GSocket::Enable(GSocketEvent event)
1223 {
1224   m_detected &= ~(1 << event);
1225   gs_gui_functions->Install_Callback(this, event);
1226 }
1227
1228 void GSocket::Disable(GSocketEvent event)
1229 {
1230   m_detected |= (1 << event);
1231   gs_gui_functions->Uninstall_Callback(this, event);
1232 }
1233
1234 /* _GSocket_Input_Timeout:
1235  *  For blocking sockets, wait until data is available or
1236  *  until timeout ellapses.
1237  */
1238 GSocketError GSocket::Input_Timeout()
1239 {
1240   struct timeval tv;
1241   fd_set readfds;
1242   int ret;
1243
1244   /* Linux select() will overwrite the struct on return */
1245   tv.tv_sec  = (m_timeout / 1000);
1246   tv.tv_usec = (m_timeout % 1000) * 1000;
1247
1248   if (!m_non_blocking)
1249   {
1250     FD_ZERO(&readfds);
1251     FD_SET(m_fd, &readfds);
1252     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1253     if (ret == 0)
1254     {
1255       GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1256       m_error = GSOCK_TIMEDOUT;
1257       return GSOCK_TIMEDOUT;
1258     }
1259     if (ret == -1)
1260     {
1261       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1262       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1263       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1264       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1265       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1266       m_error = GSOCK_TIMEDOUT;
1267       return GSOCK_TIMEDOUT;
1268     }
1269   }
1270   return GSOCK_NOERROR;
1271 }
1272
1273 /* _GSocket_Output_Timeout:
1274  *  For blocking sockets, wait until data can be sent without
1275  *  blocking or until timeout ellapses.
1276  */
1277 GSocketError GSocket::Output_Timeout()
1278 {
1279   struct timeval tv;
1280   fd_set writefds;
1281   int ret;
1282
1283   /* Linux select() will overwrite the struct on return */
1284   tv.tv_sec  = (m_timeout / 1000);
1285   tv.tv_usec = (m_timeout % 1000) * 1000;
1286
1287   GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1288
1289   if (!m_non_blocking)
1290   {
1291     FD_ZERO(&writefds);
1292     FD_SET(m_fd, &writefds);
1293     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1294     if (ret == 0)
1295     {
1296       GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1297       m_error = GSOCK_TIMEDOUT;
1298       return GSOCK_TIMEDOUT;
1299     }
1300     if (ret == -1)
1301     {
1302       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1303       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1304       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1305       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1306       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1307       m_error = GSOCK_TIMEDOUT;
1308       return GSOCK_TIMEDOUT;
1309     }
1310     if ( ! FD_ISSET(m_fd, &writefds) ) {
1311         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1312     }
1313     else {
1314         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1315     }
1316   }
1317   else
1318   {
1319     GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1320   }
1321
1322   return GSOCK_NOERROR;
1323 }
1324
1325 int GSocket::Recv_Stream(char *buffer, int size)
1326 {
1327   int ret;
1328   do
1329   {
1330     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
1331   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1332   return ret;
1333 }
1334
1335 int GSocket::Recv_Dgram(char *buffer, int size)
1336 {
1337   struct sockaddr from;
1338   WX_SOCKLEN_T fromlen = sizeof(from);
1339   int ret;
1340   GSocketError err;
1341
1342   fromlen = sizeof(from);
1343
1344   do
1345   {
1346     ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);
1347   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1348
1349   if (ret == -1)
1350     return -1;
1351
1352   /* Translate a system address into a GSocket address */
1353   if (!m_peer)
1354   {
1355     m_peer = GAddress_new();
1356     if (!m_peer)
1357     {
1358       m_error = GSOCK_MEMERR;
1359       return -1;
1360     }
1361   }
1362   err = _GAddress_translate_from(m_peer, &from, fromlen);
1363   if (err != GSOCK_NOERROR)
1364   {
1365     GAddress_destroy(m_peer);
1366     m_peer  = NULL;
1367     m_error = err;
1368     return -1;
1369   }
1370
1371   return ret;
1372 }
1373
1374 int GSocket::Send_Stream(const char *buffer, int size)
1375 {
1376   int ret;
1377
1378   MASK_SIGNAL();
1379
1380   do
1381   {
1382     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
1383   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1384
1385   UNMASK_SIGNAL();
1386
1387   return ret;
1388 }
1389
1390 int GSocket::Send_Dgram(const char *buffer, int size)
1391 {
1392   struct sockaddr *addr;
1393   int len, ret;
1394   GSocketError err;
1395
1396   if (!m_peer)
1397   {
1398     m_error = GSOCK_INVADDR;
1399     return -1;
1400   }
1401
1402   err = _GAddress_translate_to(m_peer, &addr, &len);
1403   if (err != GSOCK_NOERROR)
1404   {
1405     m_error = err;
1406     return -1;
1407   }
1408
1409   MASK_SIGNAL();
1410
1411   do
1412   {
1413     ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1414   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1415
1416   UNMASK_SIGNAL();
1417
1418   /* Frees memory allocated from _GAddress_translate_to */
1419   free(addr);
1420
1421   return ret;
1422 }
1423
1424 void GSocket::Detected_Read()
1425 {
1426   char c;
1427
1428   /* Safeguard against straggling call to Detected_Read */
1429   if (m_fd == INVALID_SOCKET)
1430   {
1431     return;
1432   }
1433
1434   /* If we have already detected a LOST event, then don't try
1435    * to do any further processing.
1436    */
1437   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1438   {
1439     m_establishing = false;
1440
1441     CALL_CALLBACK(this, GSOCK_LOST);
1442     Shutdown();
1443     return;
1444   }
1445
1446   int num =  recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1447
1448   if (num > 0)
1449   {
1450     CALL_CALLBACK(this, GSOCK_INPUT);
1451   }
1452   else
1453   {
1454     if (m_server && m_stream)
1455     {
1456       CALL_CALLBACK(this, GSOCK_CONNECTION);
1457     }
1458     else
1459     {
1460       /* Do not throw a lost event in cases where the socket isn't really lost */
1461       if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
1462       {
1463         CALL_CALLBACK(this, GSOCK_INPUT);
1464       }
1465       else
1466       {
1467         CALL_CALLBACK(this, GSOCK_LOST);
1468         Shutdown();
1469       }
1470     }
1471   }
1472 }
1473
1474 void GSocket::Detected_Write()
1475 {
1476   /* If we have already detected a LOST event, then don't try
1477    * to do any further processing.
1478    */
1479   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1480   {
1481     m_establishing = false;
1482
1483     CALL_CALLBACK(this, GSOCK_LOST);
1484     Shutdown();
1485     return;
1486   }
1487
1488   if (m_establishing && !m_server)
1489   {
1490     int error;
1491     SOCKOPTLEN_T len = sizeof(error);
1492
1493     m_establishing = false;
1494
1495     getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1496
1497     if (error)
1498     {
1499       CALL_CALLBACK(this, GSOCK_LOST);
1500       Shutdown();
1501     }
1502     else
1503     {
1504       CALL_CALLBACK(this, GSOCK_CONNECTION);
1505       /* We have to fire this event by hand because CONNECTION (for clients)
1506        * and OUTPUT are internally the same and we just disabled CONNECTION
1507        * events with the above macro.
1508        */
1509       CALL_CALLBACK(this, GSOCK_OUTPUT);
1510     }
1511   }
1512   else
1513   {
1514     CALL_CALLBACK(this, GSOCK_OUTPUT);
1515   }
1516 }
1517
1518 /* Compatibility functions for GSocket */
1519 GSocket *GSocket_new(void)
1520 {
1521     GSocket *newsocket = new GSocket();
1522     if(newsocket->IsOk())
1523         return newsocket;
1524     delete newsocket;
1525     return NULL;
1526 }
1527
1528 /*
1529  * -------------------------------------------------------------------------
1530  * GAddress
1531  * -------------------------------------------------------------------------
1532  */
1533
1534 /* CHECK_ADDRESS verifies that the current address family is either
1535  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1536  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1537  * an appropiate error code.
1538  *
1539  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1540  */
1541 #define CHECK_ADDRESS(address, family)                              \
1542 {                                                                   \
1543   if (address->m_family == GSOCK_NOFAMILY)                          \
1544     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1545       return address->m_error;                                      \
1546   if (address->m_family != GSOCK_##family)                          \
1547   {                                                                 \
1548     address->m_error = GSOCK_INVADDR;                               \
1549     return GSOCK_INVADDR;                                           \
1550   }                                                                 \
1551 }
1552
1553 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1554 {                                                                   \
1555   if (address->m_family == GSOCK_NOFAMILY)                          \
1556     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1557       return retval;                                                \
1558   if (address->m_family != GSOCK_##family)                          \
1559   {                                                                 \
1560     address->m_error = GSOCK_INVADDR;                               \
1561     return retval;                                                  \
1562   }                                                                 \
1563 }
1564
1565
1566 GAddress *GAddress_new(void)
1567 {
1568   GAddress *address;
1569
1570   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1571     return NULL;
1572
1573   address->m_family  = GSOCK_NOFAMILY;
1574   address->m_addr    = NULL;
1575   address->m_len     = 0;
1576
1577   return address;
1578 }
1579
1580 GAddress *GAddress_copy(GAddress *address)
1581 {
1582   GAddress *addr2;
1583
1584   assert(address != NULL);
1585
1586   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1587     return NULL;
1588
1589   memcpy(addr2, address, sizeof(GAddress));
1590
1591   if (address->m_addr && address->m_len > 0)
1592   {
1593     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1594     if (addr2->m_addr == NULL)
1595     {
1596       free(addr2);
1597       return NULL;
1598     }
1599     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1600   }
1601
1602   return addr2;
1603 }
1604
1605 void GAddress_destroy(GAddress *address)
1606 {
1607   assert(address != NULL);
1608
1609   if (address->m_addr)
1610     free(address->m_addr);
1611
1612   free(address);
1613 }
1614
1615 void GAddress_SetFamily(GAddress *address, GAddressType type)
1616 {
1617   assert(address != NULL);
1618
1619   address->m_family = type;
1620 }
1621
1622 GAddressType GAddress_GetFamily(GAddress *address)
1623 {
1624   assert(address != NULL);
1625
1626   return address->m_family;
1627 }
1628
1629 GSocketError _GAddress_translate_from(GAddress *address,
1630                                       struct sockaddr *addr, int len)
1631 {
1632   address->m_realfamily = addr->sa_family;
1633   switch (addr->sa_family)
1634   {
1635     case AF_INET:
1636       address->m_family = GSOCK_INET;
1637       break;
1638     case AF_UNIX:
1639       address->m_family = GSOCK_UNIX;
1640       break;
1641 #ifdef AF_INET6
1642     case AF_INET6:
1643       address->m_family = GSOCK_INET6;
1644       break;
1645 #endif
1646     default:
1647     {
1648       address->m_error = GSOCK_INVOP;
1649       return GSOCK_INVOP;
1650     }
1651   }
1652
1653   if (address->m_addr)
1654     free(address->m_addr);
1655
1656   address->m_len  = len;
1657   address->m_addr = (struct sockaddr *)malloc(len);
1658
1659   if (address->m_addr == NULL)
1660   {
1661     address->m_error = GSOCK_MEMERR;
1662     return GSOCK_MEMERR;
1663   }
1664   memcpy(address->m_addr, addr, len);
1665
1666   return GSOCK_NOERROR;
1667 }
1668
1669 GSocketError _GAddress_translate_to(GAddress *address,
1670                                     struct sockaddr **addr, int *len)
1671 {
1672   if (!address->m_addr)
1673   {
1674     address->m_error = GSOCK_INVADDR;
1675     return GSOCK_INVADDR;
1676   }
1677
1678   *len = address->m_len;
1679   *addr = (struct sockaddr *)malloc(address->m_len);
1680   if (*addr == NULL)
1681   {
1682     address->m_error = GSOCK_MEMERR;
1683     return GSOCK_MEMERR;
1684   }
1685
1686   memcpy(*addr, address->m_addr, address->m_len);
1687   return GSOCK_NOERROR;
1688 }
1689
1690 /*
1691  * -------------------------------------------------------------------------
1692  * Internet address family
1693  * -------------------------------------------------------------------------
1694  */
1695
1696 GSocketError _GAddress_Init_INET(GAddress *address)
1697 {
1698   address->m_len  = sizeof(struct sockaddr_in);
1699   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1700   if (address->m_addr == NULL)
1701   {
1702     address->m_error = GSOCK_MEMERR;
1703     return GSOCK_MEMERR;
1704   }
1705
1706   address->m_family = GSOCK_INET;
1707   address->m_realfamily = PF_INET;
1708   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1709   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1710
1711   return GSOCK_NOERROR;
1712 }
1713
1714 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1715 {
1716   struct hostent *he;
1717   struct in_addr *addr;
1718
1719   assert(address != NULL);
1720
1721   CHECK_ADDRESS(address, INET);
1722
1723   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1724
1725   /* If it is a numeric host name, convert it now */
1726 #if defined(HAVE_INET_ATON)
1727   if (inet_aton(hostname, addr) == 0)
1728   {
1729 #elif defined(HAVE_INET_ADDR)
1730   if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
1731   {
1732 #else
1733   /* Use gethostbyname by default */
1734 #ifndef __WXMAC__
1735   int val = 1;  /* VA doesn't like constants in conditional expressions */
1736   if (val)
1737 #endif
1738   {
1739 #endif
1740     struct in_addr *array_addr;
1741
1742     /* It is a real name, we solve it */
1743     if ((he = gethostbyname(hostname)) == NULL)
1744     {
1745       /* Reset to invalid address */
1746       addr->s_addr = INADDR_NONE;
1747       address->m_error = GSOCK_NOHOST;
1748       return GSOCK_NOHOST;
1749     }
1750     array_addr = (struct in_addr *) *(he->h_addr_list);
1751     addr->s_addr = array_addr[0].s_addr;
1752   }
1753   return GSOCK_NOERROR;
1754 }
1755
1756 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1757 {
1758   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1759 }
1760
1761 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1762                                           unsigned long hostaddr)
1763 {
1764   struct in_addr *addr;
1765
1766   assert(address != NULL);
1767
1768   CHECK_ADDRESS(address, INET);
1769
1770   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1771   addr->s_addr = htonl(hostaddr);
1772
1773   return GSOCK_NOERROR;
1774 }
1775
1776 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1777                                        const char *protocol)
1778 {
1779   struct servent *se;
1780   struct sockaddr_in *addr;
1781
1782   assert(address != NULL);
1783   CHECK_ADDRESS(address, INET);
1784
1785   if (!port)
1786   {
1787     address->m_error = GSOCK_INVPORT;
1788     return GSOCK_INVPORT;
1789   }
1790
1791 #if defined(__WXPM__) && defined(__EMX__)
1792   se = getservbyname(port, (char*)protocol);
1793 #else
1794   se = getservbyname(port, protocol);
1795 #endif
1796   if (!se)
1797   {
1798     /* the cast to int suppresses compiler warnings about subscript having the
1799        type char */
1800     if (isdigit((int)port[0]))
1801     {
1802       int port_int;
1803
1804       port_int = atoi(port);
1805       addr = (struct sockaddr_in *)address->m_addr;
1806       addr->sin_port = htons(port_int);
1807       return GSOCK_NOERROR;
1808     }
1809
1810     address->m_error = GSOCK_INVPORT;
1811     return GSOCK_INVPORT;
1812   }
1813
1814   addr = (struct sockaddr_in *)address->m_addr;
1815   addr->sin_port = se->s_port;
1816
1817   return GSOCK_NOERROR;
1818 }
1819
1820 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1821 {
1822   struct sockaddr_in *addr;
1823
1824   assert(address != NULL);
1825   CHECK_ADDRESS(address, INET);
1826
1827   addr = (struct sockaddr_in *)address->m_addr;
1828   addr->sin_port = htons(port);
1829
1830   return GSOCK_NOERROR;
1831 }
1832
1833 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1834 {
1835   struct hostent *he;
1836   char *addr_buf;
1837   struct sockaddr_in *addr;
1838
1839   assert(address != NULL);
1840   CHECK_ADDRESS(address, INET);
1841
1842   addr = (struct sockaddr_in *)address->m_addr;
1843   addr_buf = (char *)&(addr->sin_addr);
1844
1845   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1846   if (he == NULL)
1847   {
1848     address->m_error = GSOCK_NOHOST;
1849     return GSOCK_NOHOST;
1850   }
1851
1852   strncpy(hostname, he->h_name, sbuf);
1853
1854   return GSOCK_NOERROR;
1855 }
1856
1857 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1858 {
1859   struct sockaddr_in *addr;
1860
1861   assert(address != NULL);
1862   CHECK_ADDRESS_RETVAL(address, INET, 0);
1863
1864   addr = (struct sockaddr_in *)address->m_addr;
1865
1866   return ntohl(addr->sin_addr.s_addr);
1867 }
1868
1869 unsigned short GAddress_INET_GetPort(GAddress *address)
1870 {
1871   struct sockaddr_in *addr;
1872
1873   assert(address != NULL);
1874   CHECK_ADDRESS_RETVAL(address, INET, 0);
1875
1876   addr = (struct sockaddr_in *)address->m_addr;
1877   return ntohs(addr->sin_port);
1878 }
1879
1880 /*
1881  * -------------------------------------------------------------------------
1882  * Unix address family
1883  * -------------------------------------------------------------------------
1884  */
1885
1886 #ifndef __VISAGECPP__
1887 GSocketError _GAddress_Init_UNIX(GAddress *address)
1888 {
1889   address->m_len  = sizeof(struct sockaddr_un);
1890   address->m_addr = (struct sockaddr *)malloc(address->m_len);
1891   if (address->m_addr == NULL)
1892   {
1893     address->m_error = GSOCK_MEMERR;
1894     return GSOCK_MEMERR;
1895   }
1896
1897   address->m_family = GSOCK_UNIX;
1898   address->m_realfamily = PF_UNIX;
1899   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
1900   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
1901
1902   return GSOCK_NOERROR;
1903 }
1904
1905 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
1906
1907 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1908 {
1909   struct sockaddr_un *addr;
1910
1911   assert(address != NULL);
1912
1913   CHECK_ADDRESS(address, UNIX);
1914
1915   addr = ((struct sockaddr_un *)address->m_addr);
1916   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
1917   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
1918
1919   return GSOCK_NOERROR;
1920 }
1921
1922 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1923 {
1924   struct sockaddr_un *addr;
1925
1926   assert(address != NULL);
1927   CHECK_ADDRESS(address, UNIX);
1928
1929   addr = (struct sockaddr_un *)address->m_addr;
1930
1931   strncpy(path, addr->sun_path, sbuf);
1932
1933   return GSOCK_NOERROR;
1934 }
1935 #endif  /* !defined(__VISAGECPP__) */
1936 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */