sockaddr.h

Go to the documentation of this file.

/*
    socklibpp library
    Copyright (C) 2005  Daniel K. O. <danielosmari at users.sf.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/



#ifndef SOCK_ADDR_H
#define SOCK_ADDR_H


#include <stdexcept>
#include <iosfwd>
#include <string>
#include <inttypes.h>


#include "sockcommon.h"

namespace socklibpp {

class addr {

        struct sockaddr *_M_data;

protected:
        int _M_size;

        addr(struct sockaddr * _d, int _s) throw() :
                _M_data(_d),
                _M_size(_s)
        { }
        
        virtual
        ~addr() {}

        virtual void reset() throw() = 0;

        friend class sock;

        struct sockaddr *
        data() { return _M_data; }

        const struct sockaddr *
        data() const { return _M_data; }

        int
        size() const { return _M_size; }
        
        void
        size(int _size) { _M_size = _size; }
        
public:

        enum family {
                af_unspec       = AF_UNSPEC,    
                af_unix         = AF_UNIX,      
                af_inet         = AF_INET,      
                af_inet6        = AF_INET6,     
                af_max          = AF_MAX        
        };
};



class addr_in : public addr {

        struct sockaddr_in _M_addr;     // for IPv4

protected:
        virtual void reset() throw();

public:
        enum address {
                addr_any        = INADDR_ANY,           
                addr_loopback   = INADDR_LOOPBACK,      
                addr_broadcast  = INADDR_BROADCAST,     
                addr_none       = INADDR_NONE           
        };


        addr_in() throw();

        addr_in(address _addr, uint16_t _port) throw();

        addr_in(uint32_t _addr, uint16_t _port) throw();

        addr_in(const std::string&, uint16_t) throw (std::invalid_argument);

        addr_in(const std::string&) throw (std::invalid_argument);
        
        static bool validate_addr(const std::string&) throw();
        
        static bool validate_addr_port(const std::string&) throw();
        
        
        bool
        resolve(const std::string&) throw();

        bool
        resolve_port(const std::string&) throw();
        
        bool
        resolve_port(const std::string&, uint16_t) throw();

        bool
        resolve_port(const std::string&, const std::string&) throw();

        uint16_t        port() const throw ();

        void port(uint16_t _port) throw ();
        
        bool port(const std::string&, const std::string&) throw();

        bool port(const std::string&) throw();

        uint32_t ip() const throw();
        
        void ip(uint32_t _host) throw();

        bool
        ip(const std::string&) throw();


        bool
        ip_port(const std::string&, uint16_t) throw();

        bool
        ip_port(const std::string&) throw();

        bool
        ip_port(const std::string&, const std::string&) throw();


        std::string ip_str() const;
        
        
        
        

        friend
        std::ostream& operator<<(std::ostream&, const addr_in&);
        
        friend
        std::istream& operator>>(std::istream&, addr_in&);
};

std::ostream& operator<<(std::ostream&, const addr_in&);

std::istream& operator>>(std::istream&, addr_in&);

}


#endif

---