/usr/include/net6/socket.hpp is in libnet6-1.3-dev 1:1.3.14-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 | /* net6 - Library providing IPv4/IPv6 network access
* Copyright (C) 2005 Armin Burgmeier / 0x539 dev group
*
* 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef _NET6_SOCKET_HPP_
#define _NET6_SOCKET_HPP_
#include <memory>
#include <sigc++/signal.h>
#include "error.hpp"
#include "enum_ops.hpp"
#include "non_copyable.hpp"
#include "address.hpp"
namespace net6
{
enum io_condition
{
IO_NONE = 0x00,
IO_INCOMING = 0x01,
IO_OUTGOING = 0x02,
IO_ERROR = 0x04,
IO_TIMEOUT = 0x08
};
NET6_DEFINE_ENUM_OPS(io_condition)
/** Abstract socket class.
*/
class socket: private non_copyable
{
public:
typedef sigc::signal<void, io_condition> signal_io_type;
#ifdef WIN32
typedef SOCKET socket_type;
#else
typedef int socket_type;
#endif
typedef size_t size_type;
/** @brief Closes the socket.
*/
~socket();
/** Signal which will be emitted if somehting occures with the socket.
*/
signal_io_type io_event() const { return signal_io; }
/** Provides access to the underlaying C socket object.
*/
socket_type cobj() { return sock; }
const socket_type cobj() const { return sock; }
/** Invalidates the current socket object, which causes all calls
* to fail.
*/
void invalidate();
protected:
socket(int domain, int type, int protocol);
socket(socket_type c_object);
private:
socket_type sock;
signal_io_type signal_io;
};
/** Abstract TCP socket class.
*/
class tcp_socket: public socket
{
protected:
tcp_socket(const address& addr);
tcp_socket(socket_type c_object);
};
/** TCP connection socket.
*/
class tcp_client_socket: public tcp_socket
{
public:
/** Creates a new tcp socket and connects to the address addr.
*/
tcp_client_socket(const address& addr);
/** Wraps a C socket object. Note that the tcp_client_socket owns
* the C object.
*/
tcp_client_socket(socket_type c_object);
virtual ~tcp_client_socket();
/** Sends an amount of data through the socket. Note that the call
* may block if you did not select on a socket::OUT event.
* @return The amount of data sent.
*/
virtual size_type send(const void* buf, size_type len) const;
/** Receives an amount of data from the socket. Note that the call
* may block if no data is available.
* @return The amount of data read.
*/
virtual size_type recv(void* buf, size_type len) const;
};
/** TCP server socket
*/
class tcp_server_socket: public tcp_socket
{
public:
/** Opens a new TCP server socket bound to <em>bind_addr</em>.
*/
tcp_server_socket(const address& bind_addr);
/** Wraps a C socket object. Note that the tcp_server_socket owns the
* C object.
*/
tcp_server_socket(socket_type c_object);
/** Accepts a connection from this server socket. Note that the call
* blocks until a connection comes available. Selecting on socket::IN
* indicates a connection waiting for acception.
* @return A tcp_client_socket to communicate with the remote host.
*/
std::auto_ptr<tcp_client_socket> accept() const;
/** Accepts a new connection and stores the address of the remote host
* in <em>from</em>.
*/
std::auto_ptr<tcp_client_socket> accept(address& from) const;
};
/** UDP socket.
*/
class udp_socket: public socket
{
public:
/** Creates a new UDP socket bound to <em>bind_addr</em>.
*/
udp_socket(const address& bind_addr);
/** Wraps a C UDP socket object.
*/
udp_socket(socket_type c_object);
/** Sets the target of this UDP socket. This target is the address to
* which datagrams are sent by default and the only address from which
* datagrams are received.
*/
void set_target(const address& addr);
/** Resets the target of the UDP socket.
*/
void reset_target();
/** Sends an amount of data to the target of the UDP socket.
* @return The amount of data actually sent.
*/
size_type send(const void* buf,
size_type len) const;
/** Sends an amount of data to a specified address.
* @return The amount of data actually sent.
*/
size_type send(const void* bud,
size_type len,
const address& to) const;
/** Receives some data from the socket. Note that the call may block
* until data becomes available.
* @return The amount of data actually read.
*/
size_type recv(void* buf,
size_type len) const;
/** Receives some data from the socket and stores the source
* address into <em>from</em>. Note that the call may block until
* data becomes available for reading.
* @return The amount of data actually read.
*/
size_type recv(void* buf,
size_type len,
address& from) const;
};
} // namespace net6
#endif // _NET6_SOCKET_HPP_
|