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