1 //
2 // socket_acceptor_service.hpp
3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
4 //
5 // Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6 //
7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9 //
10 
11 #ifndef ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
12 #define ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
13 
14 
15 #include "asio/detail/config.hpp"
16 #include "asio/basic_socket.hpp"
17 #include "asio/detail/type_traits.hpp"
18 #include "asio/error.hpp"
19 #include "asio/io_service.hpp"
20 
21 # include "asio/detail/reactive_socket_service.hpp"
22 
23 #include "asio/detail/push_options.hpp"
24 
25 namespace asio {
26 
27 /// Default service implementation for a socket acceptor.
28 template <typename Protocol>
29 class socket_acceptor_service
30   : public asio::detail::service_base<socket_acceptor_service<Protocol> >
31 {
32 public:
33 
34   /// The protocol type.
35   typedef Protocol protocol_type;
36 
37   /// The endpoint type.
38   typedef typename protocol_type::endpoint endpoint_type;
39 
40 private:
41   // The type of the platform-specific implementation.
42   typedef detail::reactive_socket_service<Protocol> service_impl_type;
43 
44 public:
45   /// The native type of the socket acceptor.
46   typedef typename service_impl_type::implementation_type implementation_type;
47 
48   /// (Deprecated: Use native_handle_type.) The native acceptor type.
49   typedef typename service_impl_type::native_handle_type native_type;
50 
51   /// The native acceptor type.
52   typedef typename service_impl_type::native_handle_type native_handle_type;
53 
54   /// Construct a new socket acceptor service for the specified io_service.
55   explicit socket_acceptor_service(asio::io_service& io_service)
56     : asio::detail::service_base<
57         socket_acceptor_service<Protocol> >(io_service),
58       service_impl_(io_service)
59   {
60   }
61 
62   /// Construct a new socket acceptor implementation.
63   void construct(implementation_type& impl)
64   {
65     service_impl_.construct(impl);
66   }
67 
68   /// Move-construct a new socket acceptor implementation.
69   void move_construct(implementation_type& impl,
70       implementation_type& other_impl)
71   {
72     service_impl_.move_construct(impl, other_impl);
73   }
74 
75   /// Move-assign from another socket acceptor implementation.
76   void move_assign(implementation_type& impl,
77       socket_acceptor_service& other_service,
78       implementation_type& other_impl)
79   {
80     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
81   }
82 
83   /// Move-construct a new socket acceptor implementation from another protocol
84   /// type.
85   template <typename Protocol1>
86   void converting_move_construct(implementation_type& impl,
87       typename socket_acceptor_service<
88         Protocol1>::implementation_type& other_impl,
89       typename enable_if<is_convertible<
90         Protocol1, Protocol>::value>::type* = 0)
91   {
92     service_impl_.template converting_move_construct<Protocol1>(
93         impl, other_impl);
94   }
95 
96   /// Destroy a socket acceptor implementation.
97   void destroy(implementation_type& impl)
98   {
99     service_impl_.destroy(impl);
100   }
101 
102   /// Open a new socket acceptor implementation.
103   asio::error_code open(implementation_type& impl,
104       const protocol_type& protocol, asio::error_code& ec)
105   {
106     return service_impl_.open(impl, protocol, ec);
107   }
108 
109   /// Assign an existing native acceptor to a socket acceptor.
110   asio::error_code assign(implementation_type& impl,
111       const protocol_type& protocol, const native_handle_type& native_acceptor,
112       asio::error_code& ec)
113   {
114     return service_impl_.assign(impl, protocol, native_acceptor, ec);
115   }
116 
117   /// Determine whether the acceptor is open.
118   bool is_open(const implementation_type& impl) const
119   {
120     return service_impl_.is_open(impl);
121   }
122 
123   /// Cancel all asynchronous operations associated with the acceptor.
124   asio::error_code cancel(implementation_type& impl,
125       asio::error_code& ec)
126   {
127     return service_impl_.cancel(impl, ec);
128   }
129 
130   /// Bind the socket acceptor to the specified local endpoint.
131   asio::error_code bind(implementation_type& impl,
132       const endpoint_type& endpoint, asio::error_code& ec)
133   {
134     return service_impl_.bind(impl, endpoint, ec);
135   }
136 
137   /// Place the socket acceptor into the state where it will listen for new
138   /// connections.
139   asio::error_code listen(implementation_type& impl, int backlog,
140       asio::error_code& ec)
141   {
142     return service_impl_.listen(impl, backlog, ec);
143   }
144 
145   /// Close a socket acceptor implementation.
146   asio::error_code close(implementation_type& impl,
147       asio::error_code& ec)
148   {
149     return service_impl_.close(impl, ec);
150   }
151 
152   /// (Deprecated: Use native_handle().) Get the native acceptor implementation.
153   native_type native(implementation_type& impl)
154   {
155     return service_impl_.native_handle(impl);
156   }
157 
158   /// Get the native acceptor implementation.
159   native_handle_type native_handle(implementation_type& impl)
160   {
161     return service_impl_.native_handle(impl);
162   }
163 
164   /// Set a socket option.
165   template <typename SettableSocketOption>
166   asio::error_code set_option(implementation_type& impl,
167       const SettableSocketOption& option, asio::error_code& ec)
168   {
169     return service_impl_.set_option(impl, option, ec);
170   }
171 
172   /// Get a socket option.
173   template <typename GettableSocketOption>
174   asio::error_code get_option(const implementation_type& impl,
175       GettableSocketOption& option, asio::error_code& ec) const
176   {
177     return service_impl_.get_option(impl, option, ec);
178   }
179 
180   /// Perform an IO control command on the socket.
181   template <typename IoControlCommand>
182   asio::error_code io_control(implementation_type& impl,
183       IoControlCommand& command, asio::error_code& ec)
184   {
185     return service_impl_.io_control(impl, command, ec);
186   }
187 
188   /// Gets the non-blocking mode of the acceptor.
189   bool non_blocking(const implementation_type& impl) const
190   {
191     return service_impl_.non_blocking(impl);
192   }
193 
194   /// Sets the non-blocking mode of the acceptor.
195   asio::error_code non_blocking(implementation_type& impl,
196       bool mode, asio::error_code& ec)
197   {
198     return service_impl_.non_blocking(impl, mode, ec);
199   }
200 
201   /// Gets the non-blocking mode of the native acceptor implementation.
202   bool native_non_blocking(const implementation_type& impl) const
203   {
204     return service_impl_.native_non_blocking(impl);
205   }
206 
207   /// Sets the non-blocking mode of the native acceptor implementation.
208   asio::error_code native_non_blocking(implementation_type& impl,
209       bool mode, asio::error_code& ec)
210   {
211     return service_impl_.native_non_blocking(impl, mode, ec);
212   }
213 
214   /// Get the local endpoint.
215   endpoint_type local_endpoint(const implementation_type& impl,
216       asio::error_code& ec) const
217   {
218     return service_impl_.local_endpoint(impl, ec);
219   }
220 
221   /// Accept a new connection.
222   template <typename Protocol1, typename SocketService>
223   asio::error_code accept(implementation_type& impl,
224       basic_socket<Protocol1, SocketService>& peer,
225       endpoint_type* peer_endpoint, asio::error_code& ec,
226       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
227   {
228     return service_impl_.accept(impl, peer, peer_endpoint, ec);
229   }
230 
231   /// Start an asynchronous accept.
232   template <typename Protocol1, typename SocketService, typename AcceptHandler>
233   ASIO_INITFN_RESULT_TYPE(AcceptHandler,
234       void (asio::error_code))
235   async_accept(implementation_type& impl,
236       basic_socket<Protocol1, SocketService>& peer,
237       endpoint_type* peer_endpoint,
238       ASIO_MOVE_ARG(AcceptHandler) handler,
239       typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
240   {
241     detail::async_result_init<
242       AcceptHandler, void (asio::error_code)> init(
243         ASIO_MOVE_CAST(AcceptHandler)(handler));
244 
245     service_impl_.async_accept(impl, peer, peer_endpoint, init.handler);
246 
247     return init.result.get();
248   }
249 
250 private:
251   // Destroy all user-defined handler objects owned by the service.
252   void shutdown_service()
253   {
254     service_impl_.shutdown_service();
255   }
256 
257   // The platform-specific implementation.
258   service_impl_type service_impl_;
259 };
260 
261 } // namespace asio
262 
263 #include "asio/detail/pop_options.hpp"
264 
265 #endif // ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
266