From f084bbbf357b83f9fc10b088a4750497016bdd9e Mon Sep 17 00:00:00 2001 From: Max Kellermann Date: Wed, 22 Jul 2015 10:52:43 +0200 Subject: [PATCH] net/AllocatedSocketAddress: new sockaddr wrapper class --- Makefile.am | 1 + src/net/AllocatedSocketAddress.cxx | 85 ++++++++++++++++ src/net/AllocatedSocketAddress.hxx | 151 +++++++++++++++++++++++++++++ 3 files changed, 237 insertions(+) create mode 100644 src/net/AllocatedSocketAddress.cxx create mode 100644 src/net/AllocatedSocketAddress.hxx diff --git a/Makefile.am b/Makefile.am index 2f7641c2d..842ed1efa 100644 --- a/Makefile.am +++ b/Makefile.am @@ -427,6 +427,7 @@ libnet_a_SOURCES = \ src/net/ToString.cxx src/net/ToString.hxx \ src/net/Resolver.cxx src/net/Resolver.hxx \ src/net/StaticSocketAddress.cxx src/net/StaticSocketAddress.hxx \ + src/net/AllocatedSocketAddress.cxx src/net/AllocatedSocketAddress.hxx \ src/net/SocketAddress.cxx src/net/SocketAddress.hxx \ src/net/SocketUtil.cxx src/net/SocketUtil.hxx \ src/net/SocketError.cxx src/net/SocketError.hxx diff --git a/src/net/AllocatedSocketAddress.cxx b/src/net/AllocatedSocketAddress.cxx new file mode 100644 index 000000000..61615a72b --- /dev/null +++ b/src/net/AllocatedSocketAddress.cxx @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2012-2015 Max Kellermann + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "AllocatedSocketAddress.hxx" + +#include +#include + +#ifdef HAVE_UN +#include +#endif + +AllocatedSocketAddress & +AllocatedSocketAddress::operator=(SocketAddress src) +{ + if (src.IsNull()) { + Clear(); + } else { + SetSize(src.GetSize()); + memcpy(address, src.GetAddress(), size); + } + + return *this; +} + +void +AllocatedSocketAddress::SetSize(size_type new_size) +{ + if (size == new_size) + return; + + free(address); + size = new_size; + address = (struct sockaddr *)malloc(size); +} + +#ifdef HAVE_UN + +void +AllocatedSocketAddress::SetLocal(const char *path) +{ + const bool is_abstract = *path == '@'; + + /* sun_path must be null-terminated unless it's an abstract + socket */ + const size_t path_length = strlen(path) + !is_abstract; + + struct sockaddr_un *sun; + SetSize(sizeof(*sun) - sizeof(sun->sun_path) + path_length); + sun = (struct sockaddr_un *)address; + sun->sun_family = AF_UNIX; + memcpy(sun->sun_path, path, path_length); + + if (is_abstract) + sun->sun_path[0] = 0; +} + +#endif diff --git a/src/net/AllocatedSocketAddress.hxx b/src/net/AllocatedSocketAddress.hxx new file mode 100644 index 000000000..db02488df --- /dev/null +++ b/src/net/AllocatedSocketAddress.hxx @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2012-2015 Max Kellermann + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ALLOCATED_SOCKET_ADDRESS_HPP +#define ALLOCATED_SOCKET_ADDRESS_HPP + +#include "SocketAddress.hxx" +#include "Features.hxx" +#include "Compiler.h" + +#include + +#include + +struct sockaddr; +class Error; + +class AllocatedSocketAddress { +public: + typedef SocketAddress::size_type size_type; + +private: + struct sockaddr *address; + size_type size; + + AllocatedSocketAddress(struct sockaddr *_address, + size_type _size) + :address(_address), size(_size) {} + +public: + AllocatedSocketAddress():address(nullptr), size(0) {} + + explicit AllocatedSocketAddress(SocketAddress src) + :address(nullptr), size(0) { + *this = src; + } + + AllocatedSocketAddress(const AllocatedSocketAddress &) = delete; + + AllocatedSocketAddress(AllocatedSocketAddress &&src) + :address(src.address), size(src.size) { + src.address = nullptr; + src.size = 0; + } + + ~AllocatedSocketAddress() { + free(address); + } + + AllocatedSocketAddress &operator=(SocketAddress src); + + AllocatedSocketAddress &operator=(const AllocatedSocketAddress &) = delete; + + AllocatedSocketAddress &operator=(AllocatedSocketAddress &&src) { + std::swap(address, src.address); + std::swap(size, src.size); + return *this; + } + + gcc_pure + bool operator==(SocketAddress other) const { + return (SocketAddress)*this == other; + } + + bool operator!=(SocketAddress &other) const { + return !(*this == other); + } + + gcc_const + static AllocatedSocketAddress Null() { + return AllocatedSocketAddress(nullptr, 0); + } + + bool IsNull() const { + return address == nullptr; + } + + size_type GetSize() const { + return size; + } + + const struct sockaddr *GetAddress() const { + return address; + } + + operator SocketAddress() const { + return SocketAddress(address, size); + } + + operator const struct sockaddr *() const { + return address; + } + + int GetFamily() const { + return address->sa_family; + } + + /** + * Does the object have a well-defined address? Check !IsNull() + * before calling this method. + */ + bool IsDefined() const { + return GetFamily() != AF_UNSPEC; + } + + void Clear() { + free(address); + address = nullptr; + size = 0; + } + +#ifdef HAVE_UN + /** + * Make this a "local" address (UNIX domain socket). If the path + * begins with a '@', then the rest specifies an "abstract" local + * address. + */ + void SetLocal(const char *path); +#endif + +private: + void SetSize(size_type new_size); +}; + +#endif