{
errorStr = "Cannot create thread.";
printfd(__FILE__, "Cannot create recv thread\n");
+ logger("Cannot create recv thread.");
return -1;
}
}
{
errorStr = "Cannot create thread.";
printfd(__FILE__, "Cannot create timeouter thread\n");
+ logger("Cannot create timeouter thread.");
return -1;
}
}
if (listenSocket < 0)
{
errorStr = "Cannot create socket.";
+ logger("Cannot create a socket: %s", strerror(errno));
return -1;
}
if (bind(listenSocket, (struct sockaddr*)&listenAddr, sizeof(listenAddr)) < 0)
{
errorStr = "AUTH_IA: Bind failed.";
+ logger("Cannot bind the socket: %s", strerror(errno));
return -1;
}
if (errno != EINTR)
{
printfd(__FILE__, "recvfrom res=%d, error: '%s'\n", dataLen, strerror(errno));
+ logger("recvfrom error: %s", strerror(errno));
return -1;
}
return 0;
if (user->GetProperty().disabled.Get())
{
+ logger("Cannont authorize '%s', user is disabled.", login);
SendError(sip, sport, protoVer, "õÞÅÔÎÁÑ ÚÁÐÉÓØ ÚÁÂÌÏËÉÒÏ×ÁÎÁ");
return 0;
}
if (user->GetProperty().passive.Get())
{
+ logger("Cannont authorize '%s', user is passive.", login);
SendError(sip, sport, protoVer, "õÞÅÔÎÁÑ ÚÁÐÉÓØ ÚÁÍÏÒÏÖÅÎÁ");
return 0;
}
userPtr->GetLogin().c_str(),
inet_ntostring(sip).c_str(),
login.c_str());
- logger("IP address already in use by user '%s'. IP %s, login: '%s'",
+ logger("IP address is already in use by user '%s'. IP %s, login: '%s'",
userPtr->GetLogin().c_str(),
inet_ntostring(sip).c_str(),
login.c_str());
it->second.user->GetLogin().c_str(),
inet_ntostring(sip).c_str(),
user->GetLogin().c_str());
- logger("IP address already in use by user '%s'. IP %s, login: '%s'",
+ logger("IP address is already in use by user '%s'. IP %s, login: '%s'",
it->second.user->GetLogin().c_str(),
inet_ntostring(sip).c_str(),
user->GetLogin().c_str());
printfd(__FILE__, "Login %s already in use from ip %s. IP %s\n",
login.c_str(), inet_ntostring(user->GetCurrIP()).c_str(),
inet_ntostring(sip).c_str());
- logger("Login %s already in use from ip %s. IP %s",
+ logger("Login '%s' is already in use from ip %s. IP %s",
login.c_str(),
inet_ntostring(user->GetCurrIP()).c_str(),
inet_ntostring(sip).c_str());
runningUDP = false;
CloseUDP();
errorStr = "Cannot create UDP thread";
+ logger("Cannot create UDP thread.");
printfd(__FILE__, "Error: Cannot create UDP thread\n");
return -1;
}
{
runningTCP = false;
CloseTCP();
+ logger("Cannot create TCP thread.");
errorStr = "Cannot create TCP thread";
printfd(__FILE__, "Error: Cannot create TCP thread\n");
return -1;
if (pthread_kill(tidUDP, SIGUSR1))
{
errorStr = "Error sending signal to UDP thread";
+ logger("Error sending sugnal to UDP thread.");
printfd(__FILE__, "Error: Error sending signal to UDP thread\n");
return -1;
}
printfd(__FILE__, "UDP thread NOT stopped\n");
+ logger("Cannot stop UDP thread.");
}
}
if (portT && !stoppedTCP)
if (pthread_kill(tidTCP, SIGUSR1))
{
errorStr = "Error sending signal to TCP thread";
+ logger("Error sending signal to TCP thread.");
printfd(__FILE__, "Error: Error sending signal to TCP thread\n");
return -1;
}
printfd(__FILE__, "TCP thread NOT stopped\n");
+ logger("Cannot stop TCP thread.");
}
}
return 0;
if (sockUDP <= 0)
{
errorStr = "Error opening UDP socket";
+ logger("Cannot create UDP socket: %s", strerror(errno));
printfd(__FILE__, "Error: Error opening UDP socket\n");
return true;
}
if (bind(sockUDP, (struct sockaddr *)&sin, sizeof(sin)))
{
errorStr = "Error binding UDP socket";
+ logger("Cannot bind UDP socket: %s", strerror(errno));
printfd(__FILE__, "Error: Error binding UDP socket\n");
return true;
}
if (sockTCP <= 0)
{
errorStr = "Error opening TCP socket";
+ logger("Cannot create TCP socket: %s", strerror(errno));
printfd(__FILE__, "Error: Error opening TCP socket\n");
return true;
}
if (bind(sockTCP, (struct sockaddr *)&sin, sizeof(sin)))
{
errorStr = "Error binding TCP socket";
+ logger("Cannot bind TCP socket: %s", strerror(errno));
printfd(__FILE__, "Error: Error binding TCP socket\n");
return true;
}
if (listen(sockTCP, 1))
{
errorStr = "Error listening on TCP socket";
+ logger("Cannot listen on TCP socket: %s", strerror(errno));
printfd(__FILE__, "Error: Error listening TCP socket\n");
return true;
}
if (!cap->runningUDP)
break;
+ if (res < 0)
+ {
+ cap->logger("recvfrom error: %s", strerror(errno));
+ continue;
+ }
+
if (res == 0) // EOF
{
continue;
if (sd <= 0)
{
- if (errno != EINTR)
- {
- cap->errorStr = "Error accepting connection";
- printfd(__FILE__, "Error: Error accepting connection\n");
- }
+ if (sd < 0)
+ cap->logger("accept error: %s", strerror(errno));
continue;
}
}
res = recv(sd, buf, BUF_SIZE, MSG_WAITALL);
+
+ if (res < 0)
+ cap->logger("recv error: %s", strerror(errno));
+
close(sd);
if (!cap->runningTCP)
// Need to check actual data length and wait all data to receive
if (res < 24)
{
- if (errno != EINTR)
- {
- cap->errorStr = "Invalid data received";
- printfd(__FILE__, "Error: Invalid data received through TCP\n");
- }
continue;
}
nonstop = true;
-if (pthread_create(&thread, NULL, Run, this) == 0)
+if (pthread_create(&thread, NULL, Run, this))
{
- return 0;
+ errorStr = "Cannot create thread.";
+ logger("Cannot create thread.");
+ printfd(__FILE__, "Cannot create thread\n");
+ return -1;
}
-errorStr = "Cannot create thread.";
-printfd(__FILE__, "Cannot create thread\n");
-return -1;
+return 0;
}
//-----------------------------------------------------------------------------
int DIVERT_CAP::Stop()
if (pthread_kill(thread, SIGINT))
{
errorStr = "Cannot kill thread.";
+ logger("Cannot send signal to thread.");
printfd(__FILE__, "Cannot kill thread\n");
return -1;
}
if (cddiv.sock < 0)
{
errorStr = "Create divert socket error.";
+ logger("Cannot create a socket: %s", strerror(errno));
printfd(__FILE__, "Cannot create divert socket\n");
return -1;
}
if (ret < 0)
{
errorStr = "Bind divert socket error.";
+ logger("Cannot bind the scoket: %s", strerror(errno));
printfd(__FILE__, "Cannot bind divert socket\n");
return -1;
}
*iface = cddiv.iface;
if (!disableForwarding)
- sendto(cddiv.sock, buf, bytes, 0, (struct sockaddr*)&divertaddr, divertaddrSize);
+ {
+ if (sendto(cddiv.sock, buf, bytes, 0, (struct sockaddr*)&divertaddr, divertaddrSize) < 0)
+ logger("sendto error: %s", strerror(errno));
+ }
+ }
+else
+ {
+ if (bytes < 0)
+ logger("recvfrom error: %s", strerror(errno));
}
return 0;
nonstop = true;
-if (pthread_create(&thread, NULL, Run, this) == 0)
+if (pthread_create(&thread, NULL, Run, this))
{
- return 0;
+ errorStr = "Cannot create thread.";
+ logger("Cannot create thread.");
+ printfd(__FILE__, "Cannot create thread\n");
+ return -1;
}
-errorStr = "Cannot create thread.";
-printfd(__FILE__, "Cannot create thread\n");
-return -1;
+return 0;
}
//-----------------------------------------------------------------------------
int BPF_CAP::Stop()
if (pthread_kill(thread, SIGINT))
{
errorStr = "Cannot kill thread.";
+ logger("Cannot send signal to thread.");
printfd(__FILE__, "Cannot kill thread\n");
return -1;
}
if (bd->fd < 0)
{
errorStr = "Can't capture packets. Open bpf device for " + bd->iface + " error.";
+ logger("Cannot open device for interface '%s': %s", bd->iface, strerror(errno));
printfd(__FILE__, "Cannot open BPF device\n");
return -1;
}
if (ioctl(bd->fd, BIOCSBLEN, (caddr_t)&l) < 0)
{
errorStr = bd->iface + " BIOCSBLEN " + std::string(strerror(errno));
+ logger("ioctl (BIOCSBLEN) error for interface '%s': %s", db->iface, strerror(errno));
printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
return -1;
}
if (ioctl(bd->fd, BIOCSETIF, (caddr_t)&ifr) < 0)
{
errorStr = bd->iface + " BIOCSETIF " + std::string(strerror(errno));
+ logger("ioctl (BIOCSETIF) error for interface '%s': %s", db->iface, strerror(errno));
printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
return -1;
}
if (ioctl(bd->fd, BIOCIMMEDIATE, &im) < 0)
{
errorStr = bd->iface + " BIOCIMMEDIATE " + std::string(strerror(errno));
+ logger("ioctl (BIOCIMMEDIATE) error for interface '%s': %s", db->iface, strerror(errno));
printfd(__FILE__, "ioctl failed: '%s'\n", errorStr.c_str());
return -1;
}
bd->r = read(bd->fd, bd->buffer, BUFF_LEN);
if (bd->r < 0)
{
+ logger("read error: %s", strerror(errno));
struct timespec ts = {0, 20000000};
nanosleep(&ts, NULL);
return -1;
if (pthread_create(&thread, NULL, Run, this) == 0)
{
- return 0;
+ errorStr = "Cannot create thread.";
+ logger("Cannot create thread.");
+ printfd(__FILE__, "Cannot create thread\n");
+ return -1;
}
-errorStr = "Cannot create thread.";
-printfd(__FILE__, "Cannot create thread\n");
-return -1;
+return 0;
}
//-----------------------------------------------------------------------------
int ETHER_CAP::Stop()
if (pthread_kill(thread, SIGUSR1))
{
errorStr = "Cannot kill thread.";
+ logger("Cannot send signal to thread.");
return -1;
}
for (int i = 0; i < 25 && isRunning; ++i)
if (isRunning)
{
errorStr = "ETHER_CAP not stopped.";
+ logger("Cannot stop thread.");
printfd(__FILE__, "Cannot stop thread\n");
return -1;
}
int ETHER_CAP::EthCapOpen()
{
capSock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
+if (capSock < 0)
+ logger("Cannot create socket: %s", strerror(errno));
return capSock;
}
//-----------------------------------------------------------------------------
res = recvfrom(capSock, ((char*)buffer) + 2, blen, 0, (struct sockaddr *)&addr, (socklen_t*)&addrLen);
-if (-1 == res)
+if (res < 0)
{
- if (errno != EINTR)
- {
- printfd(__FILE__, "Error on recvfrom: '%s'\n", strerror(errno));
- }
+ logger("recvfrom error: %s", strerror(errno));
return ENODATA;
}
if (ipq_h == NULL)
{
ipq_destroy_handle(ipq_h);
+ logger("Cannot create IPQ handle.");
errorStr = "Cannot create ipq handle!";
return -1;
}
if (status < 0)
{
ipq_destroy_handle(ipq_h);
+ logger("Cannot set IPQ_COPY_PACKET mode.");
errorStr = "Cannot set IPQ_COPY_PACKET mode!";
return -1;
}
if (fd < 0)
{
errorStr = "Failed to create socket";
+ logger("Cannot create a socket: %s", strerror(errno));
printfd(__FILE__, "Failed to create listening socket: %s\n", strerror(errno));
return -1;
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag)))
{
errorStr = "Setsockopt failed.";
+ logger("setsockopt error: %s", strerror(errno));
printfd(__FILE__, "Setsockopt failed: %s\n", strerror(errno));
return -1;
}
if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)))
{
+ logger("Cannot bind the socket: %s", strerror(errno));
errorStr = "Failed to bind socket";
printfd(__FILE__, "Failed to bind listening socket: %s\n", strerror(errno));
return -1;
if (listen(fd, 10))
{
+ logger("Cannot listen the socket: %s", strerror(errno));
errorStr = "Failed to listen socket";
printfd(__FILE__, "Failed to listen listening socket: %s\n", strerror(errno));
return -1;
if (pthread_create(&tid, NULL, Run, this))
{
errorStr = "Failed to create RPC thread";
+ logger("Cannot create RPC thread.");
printfd(__FILE__, "Failed to crate RPC thread\n");
return -1;
}
if (!stopped)
{
running = true;
+ logger("Cannot stop RPC thread.");
printfd(__FILE__, "Failed to stop RPC thread\n");
errorStr = "Failed to stop RPC thread";
return -1;
if (!admins->Correct(login, password, &admin))
{
+ logger("Attempt to connect with invalid credentials. Login: %s", login.c_str());
return true;
}
if (listenSocket < 0)
{
errorStr = "Create NET_CONFIGURATOR socket failed.";
+ logger("Cannot create a socket: %s", strerror(errno));
return -1;
}
if (0 != setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, &lng, 4))
{
errorStr = "Setsockopt failed. " + string(strerror(errno));
+ logger("setsockopt error: %s", strerror(errno));
return -1;
}
if (res == -1)
{
errorStr = "Bind admin socket failed";
+ logger("Cannot bind the socket: %s", strerror(errno));
return -1;
}
if (res == -1)
{
errorStr = "Listen admin socket failed";
+ logger("Cannot listen the socket: %s", strerror(errno));
return -1;
}
break;
}
- if (outerSocket == -1)
+ if (outerSocket < 0)
{
+ logger("accept error: %s", strerror(errno));
printfd(__FILE__, "accept failed\n");
continue;
}
adminIP = *(unsigned int*)&(outerAddr.sin_addr);
- printfd(__FILE__, "Connection accepted from %s\n", inet_ntostring(outerAddr.sin_addr.s_addr).c_str());
-
if (state == confHdr)
{
if (RecvHdr(outerSocket) < 0)
{
WriteLogAccessFailed(adminIP);
}
+ printfd(__FILE__, "Successfull connection from %s\n", inet_ntostring(outerAddr.sin_addr.s_addr).c_str());
close(outerSocket);
}
}
int ret = recv(sock, &buf[pos], stgHdrLen - pos, 0);
if (ret <= 0)
{
+ if (ret < 0)
+ logger("recv error: %s", strerror(errno));
state = confHdr;
return -1;
}
{
if (send(sock, ERR_HEADER, sizeof(ERR_HEADER) - 1, 0) < 0)
{
- logger("send ERR_HEADER error in SendHdrAnswer.");
+ logger("send error: %s", strerror(errno));
return -1;
}
}
{
if (send(sock, OK_HEADER, sizeof(OK_HEADER) - 1, 0) < 0)
{
- logger("send OK_HEADER error in SendHdrAnswer.");
+ logger("send error: %s", strerror(errno));
return -1;
}
}
if (ret <= 0)
{
// Error in network
+ logger("recv error: %s", strerror(errno));
state = confHdr;
return ENODATA;
}
{
// Network error
printfd(__FILE__, "recv error: '%s'\n", strerror(errno));
+ logger("recv error: %s", strerror(errno));
state = confHdr;
return ENODATA;
}
{
if (send(sock, ERR_LOGINS, sizeof(ERR_LOGINS) - 1, 0) < 0)
{
- logger("send ERR_LOGIN error in SendLoginAnswer.");
+ logger("send error: %s", strerror(errno));
return -1;
}
}
{
if (send(sock, OK_LOGINS, sizeof(OK_LOGINS) - 1, 0) < 0)
{
- logger("send OK_LOGINS error in SendLoginSAnswer.");
+ logger("send error: %s", strerror(errno));
return -1;
}
}
if (ret < 0)
{
// Network error
+ logger("recv error: %s", strerror(errno));
printfd(__FILE__, "recv error: '%s'\n", strerror(errno));
return -1;
}
//-----------------------------------------------------------------------------
void CONFIGPROTO::WriteLogAccessFailed(uint32_t ip)
{
-logger("Admin's connect failed. IP %s", inet_ntostring(ip).c_str());
+logger("Admin's connection failed. IP %s", inet_ntostring(ip).c_str());
}
//-----------------------------------------------------------------------------
{
errorStr = "Cannot create thread.";
printfd(__FILE__, "Cannot create thread\n");
+ logger("Cannot create thread.");
return -1;
}
errorStr = "";
if (pthread_create(&thread, NULL, Run, this))
{
errorStr = "Cannot start thread.";
+ logger("Cannot create thread.");
printfd(__FILE__, "Cannot start thread\n");
return -1;
}
if (sock < 0)
{
errorStr = "Cannot create socket.";
+ logger("Cannot create a socket: %s", strerror(errno));
printfd(__FILE__, "Cannot create socket\n");
return -1;
}
if (bind(sock, (struct sockaddr*)&inAddr, sizeof(inAddr)) < 0)
{
errorStr = "RADIUS: Bind failed.";
+ logger("Cannot bind the socket: %s", strerror(errno));
printfd(__FILE__, "Cannot bind socket\n");
return -1;
}
if (pthread_create(&thread, NULL, Run, this))
{
errorStr = "Cannot create thread.";
+ logger("Cannot create thread.");
printfd(__FILE__, "Cannot create thread\n");
return -1;
}
int8_t buf[RAD_MAX_PACKET_LEN];
socklen_t outerAddrLen = sizeof(struct sockaddr_in);
int dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast<struct sockaddr *>(outerAddr), &outerAddrLen);
- if (dataLen > 0) {
- Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
- }
+ if (dataLen < 0)
+ {
+ logger("recvfrom error: %s", strerror(errno));
+ return -1;
+ }
+ if (dataLen == 0)
+ return -1;
+
+ Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
+
if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN))
{
printfd(__FILE__, "RADIUS::RecvData Error magic. Wanted: '%s', got: '%s'\n", RAD_ID, packet->magic);
return -1;
}
+
return 0;
}
//-----------------------------------------------------------------------------
char buf[1032];
Encrypt(&ctx, buf, (char *)&packet, len / 8);
-return sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
+int res = sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
+if (res < 0)
+ logger("sendto error: %s", strerror(errno));
+return res;
}
//-----------------------------------------------------------------------------
int RADIUS::ProcessData(RAD_PACKET * packet)
#include <csignal>
#include <cassert>
#include <cstdlib>
+#include <cerrno>
+#include <cstring>
#include <algorithm>
#include "stg/common.h"
if (pthread_create(&thread, NULL, Run, this))
{
errorStr = "Cannot create thread.";
+ logger("Cannot create thread.");
printfd(__FILE__, "Cannot create thread\n");
return -1;
}
users->DelNotifierUserAdd(&onAddUserNotifier);
if (isRunning)
+ {
+ logger("Cannot stop thread.");
return -1;
+ }
return 0;
}
if (nrMapParser.ReadFile(rsSettings.GetMapFileName()))
{
errorStr = nrMapParser.GetErrorStr();
+ logger("Map file reading error: %s", errorStr.c_str());
return -1;
}
if (sock < 0)
{
errorStr = "Cannot create socket.";
+ logger("Canot create a socket: %s", strerror(errno));
printfd(__FILE__, "Cannot create socket\n");
return true;
}
int res = sendto(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&sendAddr, sizeof(sendAddr));
+if (res < 0)
+ logger("sendto error: %s", strerror(errno));
+
return (res != sizeof(buffer));
}
//-----------------------------------------------------------------------------
USER_PTR u;
int h = users->OpenSearch();
-if (!h)
- {
- errorStr = "users->OpenSearch() error.";
- printfd(__FILE__, "OpenSearch() error\n");
- return true;
- }
+assert(h && "USERS::OpenSearch is always correct");
while (!users->SearchNext(h, &u))
{
if (pthread_create(&thread, NULL, Runner, this))
{
errorStr = "Cannot create thread.";
+ logger("Cannot create thread.");
printfd(__FILE__, "Cannot create thread\n");
return -1;
}
if (sock < 0)
{
errorStr = "Cannot create socket.";
+ logger("Cannot create a socket: %s", strerror(errno));
printfd(__FILE__, "Cannot create socket\n");
return true;
}
if (connect(sock, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)))
{
errorStr = "Cannot connect.";
+ logger("Cannot connect the socket: %s", strerror(errno));
printfd(__FILE__, "Cannot connect. Message: '%s'\n", strerror(errno));
return true;
}
public:
~STG_LOGGER();
void SetLogFileName(const std::string & fn);
- void operator()(const char * fmt, ...);
+ void operator()(const char * fmt, ...) const;
private:
STG_LOGGER();
STG_LOGGER(const STG_LOGGER & rvalue);
STG_LOGGER & operator=(const STG_LOGGER & rvalue);
- const char * LogDate(time_t t);
+ const char * LogDate(time_t t) const;
std::string fileName;
- pthread_mutex_t mutex;
+ mutable pthread_mutex_t mutex;
};
//-----------------------------------------------------------------------------
class PLUGIN_LOGGER : private STG_LOGGER
public:
PLUGIN_LOGGER(const PLUGIN_LOGGER & rhs);
- void operator()(const char * fmt, ...);
+ void operator()(const char * fmt, ...) const;
private:
PLUGIN_LOGGER(const STG_LOGGER & logger, const std::string & pn);
fileName = fn;
}
//-----------------------------------------------------------------------------
-void STG_LOGGER::operator()(const char * fmt, ...)
+void STG_LOGGER::operator()(const char * fmt, ...) const
{
STG_LOGGER_LOCKER lock(&mutex);
}
}
//-----------------------------------------------------------------------------
-const char * STG_LOGGER::LogDate(time_t t)
+const char * STG_LOGGER::LogDate(time_t t) const
{
static char s[32];
if (t == 0)
SetLogFileName(fileName);
}
//-----------------------------------------------------------------------------
-void PLUGIN_LOGGER::operator()(const char * fmt, ...)
+void PLUGIN_LOGGER::operator()(const char * fmt, ...) const
{
char buff[2029];
git.stg.codes / stg.git / commitdiff