Server::Server()
: m_socket(socket(PF_INET, SOCK_STREAM, 0)) {
if (m_socket < 0) {
ERR("Failed to open socket");
throw ServerException();
}
int port = PORT_NUMBER;
// prepare address structure
sockaddr_in address_structure;
memset(&address_structure, 0, sizeof(sockaddr_in));
address_structure.sin_family = AF_INET;
address_structure.sin_addr.s_addr = htonl(INADDR_ANY);
address_structure.sin_port = htons(port);
// bind socket with address structure
if (bind(m_socket, reinterpret_cast<sockaddr*>(&address_structure), sizeof(address_structure)) < 0) {
ERR("Failed to bind socket to the address");
throw ServerException();
}
// when the socket of a type that promises reliable delivery still has untransmitted messages when it is closed
linger linger_opt = { 1, 0 }; // timeout 0 seconds - close socket immediately
setsockopt(m_socket, SOL_SOCKET, SO_LINGER, &linger_opt, sizeof(linger_opt));
// listen for incoming connections
listen(m_socket, 20);
}
void Socket::WaitForConnection()
{
cout << "port " << port << endl;
WSAData v;
WSAStartup(MAKEWORD(2,2),&v);
wp->listenSocket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(wp->listenSocket==INVALID_SOCKET) {
cout << "socket creation failed: " << WSAGetLastError() << endl;
throw ServerException("Socket creation error");
}
wp->listenAddr.sin_family=AF_INET;
wp->listenAddr.sin_addr.s_addr=inet_addr("127.0.0.1");
wp->listenAddr.sin_port=htons(port);
int res = bind(wp->listenSocket, (struct sockaddr*)&wp->listenAddr, sizeof(wp->listenAddr));
if (res == SOCKET_ERROR) {
std::cout << "Error - when binding " << WSAGetLastError() << std::endl;
closesocket(wp->listenSocket);
WSACleanup();
throw ServerException("Socket Binding Error");
}
res = listen(wp->listenSocket, 2);
if (res == SOCKET_ERROR) {
fprintf(stderr, "Listen failed: %d\n", WSAGetLastError());
WSACleanup();
throw ServerException("Socket Listening Error");
}
cout << "Socket Init done\n";
cout << "Socket Waiting for connection\n";
wp->writeSockaddrLen = sizeof(wp->writeAddr);
wp->writeSocket = accept(wp->listenSocket, (struct sockaddr*)&wp->writeAddr, &wp->writeSockaddrLen);
if (wp->writeSocket == INVALID_SOCKET) {
fprintf(stderr, "Accept failed: %d\n", WSAGetLastError());
closesocket(wp->listenSocket);
WSACleanup();
throw ServerException("Socket Accepting Error");
}
if (wp->writeAddr.sin_addr.S_un.S_un_b.s_b1 == 127 &&
wp->writeAddr.sin_addr.S_un.S_un_b.s_b2 == 0 &&
wp->writeAddr.sin_addr.S_un.S_un_b.s_b3 == 0 &&
wp->writeAddr.sin_addr.S_un.S_un_b.s_b4 == 1) {
cout << "Socket Connected to " << inet_ntoa(wp->writeAddr.sin_addr) << ":" << ntohs(wp->writeAddr.sin_port) << endl;
} else {
cout << "denied" << inet_ntoa(wp->writeAddr.sin_addr) << ":" << ntohs(wp->writeAddr.sin_port) << endl;
}
}
// ----------------------------------------------
Server::Server()
: m_socket(socket(PF_INET, SOCK_STREAM, 0)) { // create an endpoint for communication
if (m_socket < 0) {
ERR("Failed to open socket");
throw ServerException();
}
memset(&m_address_structure, 0, sizeof(sockaddr_in));
m_address_structure.sin_family = AF_INET;
m_address_structure.sin_addr.s_addr = htonl(INADDR_ANY);
m_address_structure.sin_port = htons(PORT_NUMBER);
if (bind(m_socket, reinterpret_cast<sockaddr*>(&m_address_structure), sizeof(m_address_structure)) < 0) {
ERR("Failed to bind socket to the address");
throw ServerException();
}
}
void Server::registerSignalHandlers() {
serverInstance = this;
if (signal(SIGINT, handleSignal) == SIG_ERR) {
const std::string msg = "Inable to set SIGINT signal handler";
LOGE(msg);
throw ServerException(msg);
}
}
ServerFactoryPtr ServerFactoryRegistry::getFactory(const std::string &name) {
Lock lock(m_lock);
auto it = m_factories.find(name);
if (it == m_factories.end()) {
throw ServerException("no factory for server type \"%s\"", name.c_str());
}
return it->second;
}
void ServerFactoryRegistry::registerFactory(const std::string &name,
const ServerFactoryPtr &factory) {
Lock lock(m_lock);
auto ret = m_factories.insert(std::make_pair(name, factory));
if (!ret.second) {
throw ServerException("a factory already exists for server type \"%s\"",
name.c_str());
}
}
Server::Server(Handler& handler, unsigned short port)
: pool(handler)
, port(port)
{
registerSignalHandlers();
if (::pipe(pipe) == -1) {
throw ServerException("Failed to create server's pipe.");
}
socket = Socket::createINET("0.0.0.0", std::to_string(port));
this->port = socket.getPort();
}
PeerServer::PeerServer()
: m_socket(socket(PF_INET, SOCK_STREAM, 0)) {
if (m_socket < 0) {
ERR("Failed to open socket");
throw ServerException();
}
int port = 9000;
sockaddr_in address_structure;
memset(&address_structure, 0, sizeof(sockaddr_in));
address_structure.sin_family = AF_INET;
address_structure.sin_addr.s_addr = htonl(INADDR_ANY);
address_structure.sin_port = htons(port);
if (bind(m_socket, reinterpret_cast<sockaddr*>(&address_structure), sizeof(address_structure)) < 0) {
ERR("Failed to bind socket to the address");
throw ServerException();
}
}
string Socket::ReceiveMessage()
{
string message = "";
int transferred = BUFFLEN;
while (transferred == BUFFLEN) {
transferred = recv(wp->writeSocket,buffer,BUFFLEN, 0);
if (transferred == SOCKET_ERROR) {
cout << "Socket Error " << WSAGetLastError() << endl;
throw ServerException("Socket Error");
} else if (transferred == 0) {
// socket closed
return "SOCKET_CLOSED";
} else {
message.append(buffer, transferred);
}
cout << transferred << endl;
}
cout << message << endl;
return message;
}
bool Server::loadConfig(const char* filename) {
FILE* fp;
char line[256], buffer[256];
char* begin;
int linecount;
bool success;
if ((fp = fopen(filename, "r")) == NULL) {
throw ServerException("Missing configuration file!");
}
linecount = 0;
success = true;
while (fgets(line, sizeof(line), fp) != NULL) {
linecount++;
if (strlen(line) < 3 || line[0] == '#' || (line[0] == '/' && line[1] == '/')) continue; // Skip comments
if (strlen(line) == (sizeof(line) - 1) && line[sizeof(line) - 2] != '\n') {
int c;
while ((c = fgetc(fp)) != EOF) {
if (c == '\n') break;
}
} // If a line is longer than the max line length, the rest of it is skipped
begin = line;
while (*begin != '\0' && isspace(*begin)) begin++; // Skip leading whitespace
if (strlen(begin) >= strlen("nameserver") && !strncmp(begin, "nameserver", strlen("nameserver"))) {
begin += strlen("nameserver");
while (*begin != '\0' && isspace(*begin)) begin++;
if (!strncmp(begin, "default", strlen("default"))) {
loadConfig("/etc/resolv.conf"); // recursion
continue;
}
int i;
for (i = 0; i < (sizeof(buffer) - 1) && *begin != '\0' && !isspace(*begin); buffer[i++] = *begin++);
buffer[i] = '\0';
struct in_addr addr;
if (inet_pton(AF_INET, buffer, &addr) == 1) {
dns_servers_.push_back(addr);
} else {
syslog(LOG_WARNING, "Invalid ip address at line %d\n", linecount);
}
} else if (strlen(begin) >= strlen("selection-mode") && !strncmp(begin, "selection-mode", strlen("selection-mode"))) {
begin += strlen("selection-mode");
while (*begin != '\0' && isspace(*begin)) begin++;
if (!strncmp(begin, "random", strlen("random"))) {
sel_mode_ = selectionMode::RANDOM;
} else if (!strncmp(begin, "round-robin", strlen("round-robin"))) {
sel_mode_ = selectionMode::ROUND_ROBIN;
} else {
syslog(LOG_WARNING, "Invalid selection-mode at line %d, defaulting to \"random\"\n", linecount);
sel_mode_ = selectionMode::RANDOM;
}
} else if (strlen(begin) >= strlen("dns64-prefix") && !strncmp(begin, "dns64-prefix", strlen("dns64-prefix"))) {
begin += strlen("dns64-prefix");
while (*begin != '\0' && isspace(*begin)) begin++;
int i;
for (i = 0; i < (sizeof(buffer) - 1) && *begin != '\0' && *begin != '/'; buffer[i++] = *begin++);
buffer[i] = '\0';
if (*begin != '/' || sscanf(begin+1, "%hhu", &ipv6_prefix_) != 1) {
syslog(LOG_WARNING, "Invalid dns64-prefix at line %d: missing or bad prefix\n", linecount);
success = false;
break;
}
if (ipv6_prefix_ != 32 && ipv6_prefix_ != 40 && ipv6_prefix_ != 48 && ipv6_prefix_ != 56 && ipv6_prefix_ != 64 && ipv6_prefix_ != 96) {
syslog(LOG_WARNING, "Invalid dns64-prefix at line %d. Usable NDS64 prefix length values are: 32,40,48,56,64,96\n", linecount);
success = false;
break;
}
if (inet_pton(AF_INET6, buffer, &ipv6_) != 1) {
syslog(LOG_WARNING, "Invalid dns64-prefix at line %d: bad address\n", linecount);
success = false;
break;
}
} else if (strlen(begin) >= strlen("debugging") && !strncmp(begin, "debugging", strlen("debugging"))) {
begin += strlen("debugging");
while (*begin != '\0' && isspace(*begin)) begin++;
if (!strncmp(begin, "yes", strlen("yes"))) {
debug_ = true;
} else {
debug_ = false;
}
} else if (strlen(begin) >= strlen("timeout-time") && !strncmp(begin, "timeout-time", strlen("timeout-time"))) {
long int sec, usec;
begin += strlen("timeout-time");
while (*begin != '\0' && isspace(*begin)) begin++;
if (sscanf(begin, "%ld.%ld", &sec, &usec) != 2 || sec < 0 || sec > 32767 || usec < 0 || usec > 999999) {
timeout_.tv_sec = 1;
timeout_.tv_usec = 0;
syslog(LOG_WARNING, "Invalid timeout-time at line %d. Defaulting to 1.0 sec\n", linecount);
continue;
} else {
timeout_.tv_sec = sec;
timeout_.tv_usec = usec;
}
} else if (strlen(begin) >= strlen("resend-attempts") && !strncmp(begin, "resend-attempts", strlen("resend-attempts"))) {
begin += strlen("resend-attempts");
while (*begin != '\0' && isspace(*begin)) begin++;
if (sscanf(begin, "%hd", &resend_attempts_) != 1 || resend_attempts_ < 0) {
resend_attempts_ = 2;
syslog(LOG_WARNING, "Invalid resend-attempts at line %d. Defaulting to 2\n", linecount);
continue;
}
} else if (strlen(begin) >= strlen("num-threads") && !strncmp(begin, "num-threads", strlen("num-threads"))) {
begin += strlen("num-threads");
while (*begin != '\0' && isspace(*begin)) begin++;
if (sscanf(begin, "%hd", &num_threads_) != 1 || num_threads_ < 0) {
num_threads_ = 10;
syslog(LOG_WARNING, "Invalid num-threads at line %d. Defaulting to 10\n", linecount);
continue;
}
} else if (strlen(begin) >= strlen("response-maxlength") && !strncmp(begin, "response-maxlength", strlen("response-maxlength"))) {
begin += strlen("response-maxlength");
while (*begin != '\0' && isspace(*begin)) begin++;
if (sscanf(begin, "%hd", &response_maxlength_) != 1 || response_maxlength_ < 0) {
response_maxlength_ = 512;
syslog(LOG_WARNING, "Invalid response-maxlength at line %d. Defaulting to 512\n", linecount);
continue;
}
} else if (strlen(begin) >= strlen("port") && !strncmp(begin, "port", strlen("port"))) {
begin += strlen("port");
while (*begin != '\0' && isspace(*begin)) begin++;
if (sscanf(begin, "%hu", &port_) != 1) {
port_ = 53;
syslog(LOG_WARNING, "Invalid port at line %d. Defaulting to 53\n", linecount);
continue;
}
}
}
if (dns_servers_.size() == 0) {
success = false;
}
fclose(fp);
return success;
}
