src/unix/gsocket.cpp

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