/usr/include/dlib/server/server_kernel.h is in libdlib-dev 18.18-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 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 | // Copyright (C) 2003 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_SERVER_KERNEL_1_
#define DLIB_SERVER_KERNEL_1_
#include "server_kernel_abstract.h"
#include "../threads.h"
#include "../sockets.h"
#include <string>
#include "../algs.h"
#include "../set.h"
#include "../logger.h"
#include "../smart_pointers.h"
namespace dlib
{
// These forward declarations are here so we can use them in the typedefs in the server
// class. The reason for this is for backwards compatibility with previous versions of
// dlib.
class server_http;
class server_iostream;
class server
{
/*!
INITIAL VALUE
listening_port == 0
listening_ip == ""
running == false
shutting_down == false
cons.size() == 0
listening_port_mutex == a mutex
listening_ip_mutex == a mutex
running_mutex == a mutex
running_signaler == a signaler associated with running_mutex
shutting_down_mutex == a mutex
cons_mutex == a mutex
thread_count == 0
thread_count_mutex == a mutex
thread_count_signaler == a signaler associated with thread_count_mutex
thread_count_zero == a signaler associated with thread_count_mutex
max_connections == 1000
max_connections_mutex == a mutex for max_connections and graceful_close_timeout
graceful_close_timeout == 500
CONVENTION
listening_port == get_listening_port()
listening_ip == get_listening_ip()
running == is_running()
shutting_down == true while clear() is running. this
bool is used to tell the thread blocked on
accept that it should terminate
cons == a set containing all open connections
listening_port_mutex == a mutex for listening_port
listening_ip_mutex == a mutex for listening_ip
running_mutex == a mutex for running
running_signaler == a signaler for running and
is associated with running_mutex. it is
used to signal when running is false
shutting_down_mutex == a mutex for shutting_down
cons_mutex == a mutex for cons
thread_count == the number of threads currently running
thread_count_mutex == a mutex for thread_count
thread_count_signaler == a signaler for thread_count and
is associated with thread_count_mutex. it
is used to signal when thread_count is
decremented
thread_count_zero == a signaler for thread_count and
is associated with thread_count_mutex. it
is used to signal when thread_count becomes
zero
max_connections == get_max_connections()
max_connections_mutex == a mutex for max_connections
!*/
typedef set<connection*>::kernel_1a set_of_connections;
// this structure is used to pass parameters to new threads
struct param
{
param (
server& server_,
connection& new_connection_,
unsigned long graceful_close_timeout_
) :
the_server(server_),
new_connection(new_connection_),
graceful_close_timeout(graceful_close_timeout_)
{}
server& the_server;
connection& new_connection;
unsigned long graceful_close_timeout;
};
public:
// These typedefs are here for backward compatibility with previous versions of dlib
typedef server kernel_1a;
typedef server kernel_1a_c;
typedef server_iostream iostream_1a;
typedef server_iostream iostream_1a_c;
typedef server_http http_1a;
typedef server_http http_1a_c;
server(
);
virtual ~server(
);
void clear(
);
void start (
);
bool is_running (
) const;
const std::string get_listening_ip (
) const;
int get_listening_port (
) const;
void set_listening_port (
int port
);
void set_listening_ip (
const std::string& ip
);
void set_max_connections (
int max
);
int get_max_connections (
) const;
void start_async (
);
void set_graceful_close_timeout (
unsigned long timeout
);
unsigned long get_graceful_close_timeout (
) const;
private:
void start_async_helper (
);
void start_accepting_connections (
);
void open_listening_socket (
);
virtual void on_connect (
connection& new_connection
)=0;
virtual void on_listening_port_assigned (
) {}
const static logger sdlog;
static void service_connection(
void* item
);
/*!
requires
item is a pointer to a param struct
ensures
services the new connection
will take care of closing the connection and
adding the connection to cons when it first starts and
remove the connection from cons and signal that it has
done so when it ends
!*/
// data members
int listening_port;
std::string listening_ip;
bool running;
bool shutting_down;
set_of_connections cons;
mutex listening_port_mutex;
mutex listening_ip_mutex;
rmutex running_mutex;
rsignaler running_signaler;
mutex shutting_down_mutex;
mutex cons_mutex;
int thread_count;
mutex thread_count_mutex;
signaler thread_count_signaler;
int max_connections;
mutex max_connections_mutex;
signaler thread_count_zero;
scoped_ptr<thread_function> async_start_thread;
scoped_ptr<listener> sock;
unsigned long graceful_close_timeout;
// restricted functions
server(server&);
server& operator= (
server&
);
};
// ----------------------------------------------------------------------------------------
}
#ifdef NO_MAKEFILE
#include "server_kernel.cpp"
#endif
#endif // DLIB_SERVER_KERNEL_1_
|