Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replaced unweildy GAddress functions with wxSockAddressImpl class, similarly to GSocket -> wxSocketImpl transition; share more code between IPv4 and IPv6 branches

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@57635 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2008-12-29 14:35:48 +00:00
parent f045c7f52d
commit c9bccf239c
7 changed files with 1220 additions and 2018 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
include/wx/private/sckaddr.h Normal file
View File

@@ -0,0 +1,294 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/sockaddr.h
// Purpose: wxSockAddressImpl
// Author: Vadim Zeitlin
// Created: 2008-12-28
// RCS-ID: $Id$
// Copyright: (c) 2008 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_SOCKADDR_H_
#define _WX_PRIVATE_SOCKADDR_H_
#ifdef __WXMSW__
#include "wx/msw/wrapwin.h"
#elif defined(__VMS__)
#include <socket.h>
struct sockaddr_un
{
u_char sun_len; /* sockaddr len including null */
u_char sun_family; /* AF_UNIX */
char sun_path[108]; /* path name (gag) */
};
#else // generic Unix
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#endif // platform
#include <stdlib.h> // for calloc()
// this is a wrapper for sockaddr_storage if it's available or just sockaddr
// otherwise
union wxSockAddressStorage
{
#if wxUSE_IPV6
sockaddr_storage addr_storage;
#endif
sockaddr addr;
};
// ----------------------------------------------------------------------------
// helpers for wxSockAddressImpl
// ----------------------------------------------------------------------------
// helper class mapping sockaddr_xxx types to corresponding AF_XXX values
//
// FIXME-VC6: we could leave the template undefined if not for VC6 which
// absolutely does need to have a generic version defining the
// template "interface" to compile the code below
template <class T> struct AddressFamily { enum { value = AF_UNSPEC }; };
template <> struct AddressFamily<sockaddr_in> { enum { value = AF_INET }; };
#if wxUSE_IPV6
template <> struct AddressFamily<sockaddr_in6> { enum { value = AF_INET6 }; };
#endif // wxUSE_IPV6
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
template <> struct AddressFamily<sockaddr_un> { enum { value = AF_UNIX }; };
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
// ----------------------------------------------------------------------------
// wxSockAddressImpl
// ----------------------------------------------------------------------------
// Represents a socket endpoint, e.g. an (address, port) pair for PF_INET
// sockets. It can be initialized from an existing sockaddr struct and also
// provides access to sockaddr stored internally so that it can be easily used
// with e.g. connect(2).
//
// This class also performs (synchronous, hence potentially long) name lookups
// if necessary, i.e. if the host name strings don't contain addresses in
// numerical form (quad dotted for IPv4 or standard hexadecimal for IPv6).
// Notice that internally the potentially Unicode host names are encoded as
// UTF-8 before being passed to the lookup function but the host names should
// really be ASCII anyhow.
class wxSockAddressImpl
{
public:
// as this is passed to socket() it should be a PF_XXX and not AF_XXX (even
// though they're the same in practice)
enum Family
{
FAMILY_INET = PF_INET,
#if wxUSE_IPV6
FAMILY_INET6 = PF_INET6,
#endif
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
FAMILY_UNIX = PF_UNIX,
#endif
FAMILY_UNSPEC = PF_UNSPEC
};
// default ctor creates uninitialized object, use one of CreateXXX() below
wxSockAddressImpl()
{
InitUnspec();
}
// ctor from an existing sockaddr
wxSockAddressImpl(const sockaddr& addr, int len)
{
switch ( addr.sa_family )
{
case PF_INET:
#if wxUSE_IPV6
case PF_INET6:
#endif
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
case PF_UNIX:
#endif
m_family = static_cast<Family>(addr.sa_family);
break;
default:
wxFAIL_MSG( "unsupported socket address family" );
InitUnspec();
return;
}
InitFromSockaddr(addr, len);
}
// copy ctor and assignment operators
wxSockAddressImpl(const wxSockAddressImpl& other)
{
InitFromOther(other);
}
wxSockAddressImpl& operator=(const wxSockAddressImpl& other)
{
free(m_addr);
InitFromOther(other);
return *this;
}
// dtor frees the memory used by m_addr
~wxSockAddressImpl()
{
free(m_addr);
}
// reset the address to the initial uninitialized state
void Clear()
{
free(m_addr);
InitUnspec();
}
// initialize the address to be of specific address family, it must be
// currently uninitialized (you may call Clear() to achieve this)
void CreateINET();
void CreateINET6();
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
void CreateUnix();
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
// simple accessors
Family GetFamily() const { return m_family; }
bool Is(Family family) const { return m_family == family; }
bool IsOk() const { return m_family != FAMILY_UNSPEC; }
const sockaddr *GetAddr() const { return m_addr; }
sockaddr *GetWritableAddr() { return m_addr; }
int GetLen() const { return m_len; }
// accessors for INET or INET6 address families
#if wxUSE_IPV6
#define CALL_IPV4_OR_6(func, args) \
Is(FAMILY_INET6) ? func##6(args) : func##4(args)
#define CALL_IPV4_OR_6_VOID(func) \
Is(FAMILY_INET6) ? func##6() : func##4()
#else
#define CALL_IPV4_OR_6(func, args) func##4(args)
#define CALL_IPV4_OR_6_VOID(func) func##4()
#endif // IPv6 support on/off
wxString GetHostName() const;
bool SetHostName(const wxString& name)
{
return CALL_IPV4_OR_6(SetHostName, (name));
}
wxUint16 GetPort() const { return CALL_IPV4_OR_6_VOID(GetPort); }
bool SetPort(wxUint16 port) { return CALL_IPV4_OR_6(SetPort, (port)); }
bool SetPortName(const wxString& name, const char *protocol);
bool SetToAnyAddress() { return CALL_IPV4_OR_6_VOID(SetToAnyAddress); }
#undef CALL_IPV4_OR_6
// accessors for INET addresses only
bool GetHostAddress(wxUint32 *address) const;
bool SetHostAddress(wxUint32 address);
bool SetToBroadcastAddress() { return SetHostAddress(INADDR_BROADCAST); }
// accessors for INET6 addresses only
#if wxUSE_IPV6
bool GetHostAddress(in6_addr *address) const;
bool SetHostAddress(const in6_addr& address);
#endif // wxUSE_IPV6
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
// methods valid for Unix address family addresses only
bool SetPath(const wxString& path);
wxString GetPath() const;
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
private:
void DoAlloc(int len)
{
m_addr = static_cast<sockaddr *>(calloc(1, len));
m_len = len;
}
// FIXME-VC6: VC6 doesn't grok Foo<T>() call syntax so we need the extra
// dummy parameter of type T, use the macros in sckaddr.cpp to
// hide it
template <class T>
T *Alloc(T *)
{
DoAlloc(sizeof(T));
return reinterpret_cast<T *>(m_addr);
}
template <class T>
T *Get(T *) const
{
wxCHECK_MSG( static_cast<int>(m_family) == AddressFamily<T>::value,
NULL,
"socket address family mismatch" );
return reinterpret_cast<T *>(m_addr);
}
void InitUnspec()
{
m_family = FAMILY_UNSPEC;
m_addr = NULL;
m_len = 0;
}
void InitFromSockaddr(const sockaddr& addr, int len)
{
DoAlloc(len);
memcpy(m_addr, &addr, len);
}
void InitFromOther(const wxSockAddressImpl& other)
{
m_family = other.m_family;
if ( other.m_addr )
{
InitFromSockaddr(*other.m_addr, other.m_len);
}
else // no address to copy
{
m_addr = NULL;
m_len = 0;
}
}
// IPv4/6 implementations of public functions
bool SetHostName4(const wxString& name);
bool SetPort4(wxUint16 port);
wxUint16 GetPort4() const;
bool SetToAnyAddress4() { return SetHostAddress(INADDR_ANY); }
#if wxUSE_IPV6
bool SetHostName6(const wxString& name);
bool SetPort6(wxUint16 port);
wxUint16 GetPort6() const;
bool SetToAnyAddress6();
#endif // wxUSE_IPV6
Family m_family;
sockaddr *m_addr;
int m_len;
};
#endif // _WX_PRIVATE_SOCKADDR_H_