From: Kyungwook Tak Date: Tue, 15 Mar 2016 11:16:43 +0000 (+0900) Subject: Coding style check/fixed with cpplint_tizen.py X-Git-Tag: submit/tizen/20160323.090454~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F28%2F62328%2F1;p=platform%2Fcore%2Fsecurity%2Fauth-fw.git Coding style check/fixed with cpplint_tizen.py Checker/Guide in http://10.113.136.204/confluence/pages/viewpage.action?pageId=44567756 Member function definitions in headers are checked as brace-breaking or not in some cases They are checked by ID [M10][SPC_M_SEP] 'Space' category. Anyway this patch follows cpplint_tizen.py checker and 0 item defected. Change-Id: I19fbddbaf5792f8949db3232497354540bfd73a4 Signed-off-by: Kyungwook Tak --- diff --git a/src/client/client-common.cpp b/src/client/client-common.cpp index beb2467..44e8675 100644 --- a/src/client/client-common.cpp +++ b/src/client/client-common.cpp @@ -46,28 +46,31 @@ namespace { const int POLL_TIMEOUT = 300000; -void authPasswdClientEnableLogSystem(void) { - AuthPasswd::Singleton::Instance().SetTag("AUTH_PASSWD_CLIENT"); +void authPasswdClientEnableLogSystem(void) +{ + AuthPasswd::Singleton::Instance().SetTag("AUTH_PASSWD_CLIENT"); } -int waitForSocket(int sock, int event, int timeout) { - int retval; - pollfd desc[1]; - desc[0].fd = sock; - desc[0].events = event; - - while((-1 == (retval = poll(desc, 1, timeout))) && (errno == EINTR)) { - timeout >>= 1; - errno = 0; - } - - if (0 == retval) { - LogDebug("Poll timeout"); - } else if (-1 == retval) { - int err = errno; - LogError("Error in poll: " << AuthPasswd::errnoToString(err)); - } - return retval; +int waitForSocket(int sock, int event, int timeout) +{ + int retval; + pollfd desc[1]; + desc[0].fd = sock; + desc[0].events = event; + + while ((-1 == (retval = poll(desc, 1, timeout))) && (errno == EINTR)) { + timeout >>= 1; + errno = 0; + } + + if (0 == retval) + LogDebug("Poll timeout"); + else if (-1 == retval) { + int err = errno; + LogError("Error in poll: " << AuthPasswd::errnoToString(err)); + } + + return retval; } } // namespace anonymous @@ -75,206 +78,223 @@ int waitForSocket(int sock, int event, int timeout) { namespace AuthPasswd { -int SockRAII::Connect(char const * const interface) { - sockaddr_un clientAddr; - int flags; - - if (m_sock != -1) // guard - close(m_sock); - - m_sock = socket(AF_UNIX, SOCK_STREAM, 0); - if (m_sock < 0) { - int err = errno; - LogError("Error creating socket: " << AuthPasswd::errnoToString(err)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - if ((flags = fcntl(m_sock, F_GETFL, 0)) < 0 || - fcntl(m_sock, F_SETFL, flags | O_NONBLOCK) < 0) - { - int err = errno; - LogError("Error in fcntl: " << AuthPasswd::errnoToString(err)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - memset(&clientAddr, 0, sizeof(clientAddr)); - - clientAddr.sun_family = AF_UNIX; - - if (strlen(interface) >= sizeof(clientAddr.sun_path)) { - LogError("Error: interface name " << interface << "is too long. Max len is:" << sizeof(clientAddr.sun_path)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - strncpy(clientAddr.sun_path, interface, sizeof(clientAddr.sun_path) - 1); - - LogDebug("ClientAddr.sun_path = " << interface); - - int retval = TEMP_FAILURE_RETRY(connect(m_sock, (struct sockaddr*)&clientAddr, SUN_LEN(&clientAddr))); - if ((retval == -1) && (errno == EINPROGRESS)) { - if (0 >= waitForSocket(m_sock, POLLOUT, POLL_TIMEOUT)) { - LogError("Error in waitForSocket."); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - int error = 0; - socklen_t len = sizeof(error); - retval = getsockopt(m_sock, SOL_SOCKET, SO_ERROR, &error, &len); - - if (-1 == retval) { - int err = errno; - LogError("Error in getsockopt: " << AuthPasswd::errnoToString(err)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - if (error == EACCES) { - LogError("Access denied"); - return AUTH_PASSWD_API_ERROR_ACCESS_DENIED; - } - - if (error != 0) { - LogError("Error in connect: " << AuthPasswd::errnoToString(error)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - return AUTH_PASSWD_API_SUCCESS; - } - - if (-1 == retval) { - int err = errno; - LogError("Error connecting socket: " << AuthPasswd::errnoToString(err)); - if (err == EACCES) - return AUTH_PASSWD_API_ERROR_ACCESS_DENIED; - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - return AUTH_PASSWD_API_SUCCESS; +int SockRAII::Connect(char const *const interface) +{ + sockaddr_un clientAddr; + int flags; + + if (m_sock != -1) // guard + close(m_sock); + + m_sock = socket(AF_UNIX, SOCK_STREAM, 0); + + if (m_sock < 0) { + int err = errno; + LogError("Error creating socket: " << AuthPasswd::errnoToString(err)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + if ((flags = fcntl(m_sock, F_GETFL, 0)) < 0 || + fcntl(m_sock, F_SETFL, flags | O_NONBLOCK) < 0) { + int err = errno; + LogError("Error in fcntl: " << AuthPasswd::errnoToString(err)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + memset(&clientAddr, 0, sizeof(clientAddr)); + clientAddr.sun_family = AF_UNIX; + + if (strlen(interface) >= sizeof(clientAddr.sun_path)) { + LogError("Error: interface name " << interface << "is too long. Max len is:" << sizeof( + clientAddr.sun_path)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + strncpy(clientAddr.sun_path, interface, sizeof(clientAddr.sun_path) - 1); + LogDebug("ClientAddr.sun_path = " << interface); + int retval = TEMP_FAILURE_RETRY(connect(m_sock, (struct sockaddr *)&clientAddr, + SUN_LEN(&clientAddr))); + + if ((retval == -1) && (errno == EINPROGRESS)) { + if (0 >= waitForSocket(m_sock, POLLOUT, POLL_TIMEOUT)) { + LogError("Error in waitForSocket."); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + int error = 0; + socklen_t len = sizeof(error); + retval = getsockopt(m_sock, SOL_SOCKET, SO_ERROR, &error, &len); + + if (-1 == retval) { + int err = errno; + LogError("Error in getsockopt: " << AuthPasswd::errnoToString(err)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + if (error == EACCES) { + LogError("Access denied"); + return AUTH_PASSWD_API_ERROR_ACCESS_DENIED; + } + + if (error != 0) { + LogError("Error in connect: " << AuthPasswd::errnoToString(error)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + return AUTH_PASSWD_API_SUCCESS; + } + + if (-1 == retval) { + int err = errno; + LogError("Error connecting socket: " << AuthPasswd::errnoToString(err)); + + if (err == EACCES) + return AUTH_PASSWD_API_ERROR_ACCESS_DENIED; + + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + return AUTH_PASSWD_API_SUCCESS; } -int sendToServerWithFd(int fd, const RawBuffer &send, MessageBuffer &recv) { - ssize_t done = 0; - char buffer[2048]; - while ((send.size() - done) > 0) { - if (0 >= waitForSocket(fd, POLLOUT, POLL_TIMEOUT)) { - LogError("Error in poll(POLLOUT)"); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - ssize_t temp = TEMP_FAILURE_RETRY(::send(fd, &send[done], send.size() - done, MSG_NOSIGNAL)); - if (-1 == temp) { - int err = errno; - LogError("Error in send: " << errnoToString(err)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - done += temp; - } - - do { - if (0 >= waitForSocket(fd, POLLIN, POLL_TIMEOUT)) { - LogError("Error in poll(POLLIN)"); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - ssize_t temp = TEMP_FAILURE_RETRY(::recv(fd, buffer, 2048, 0)); - if (-1 == temp) { - int err = errno; - LogError("Error in recv: " << errnoToString(err)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - if (0 == temp) { - LogError("Read return 0/Connection closed by server(?)"); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - RawBuffer raw(buffer, buffer+temp); - recv.Push(raw); - } while(!recv.Ready()); - return AUTH_PASSWD_API_SUCCESS; +int sendToServerWithFd(int fd, const RawBuffer &send, MessageBuffer &recv) +{ + ssize_t done = 0; + char buffer[2048]; + + while ((send.size() - done) > 0) { + if (0 >= waitForSocket(fd, POLLOUT, POLL_TIMEOUT)) { + LogError("Error in poll(POLLOUT)"); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + ssize_t temp = TEMP_FAILURE_RETRY(::send(fd, &send[done], send.size() - done, MSG_NOSIGNAL)); + + if (-1 == temp) { + int err = errno; + LogError("Error in send: " << errnoToString(err)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + done += temp; + } + + do { + if (0 >= waitForSocket(fd, POLLIN, POLL_TIMEOUT)) { + LogError("Error in poll(POLLIN)"); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + ssize_t temp = TEMP_FAILURE_RETRY(::recv(fd, buffer, 2048, 0)); + + if (-1 == temp) { + int err = errno; + LogError("Error in recv: " << errnoToString(err)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + if (0 == temp) { + LogError("Read return 0/Connection closed by server(?)"); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + RawBuffer raw(buffer, buffer + temp); + recv.Push(raw); + } while (!recv.Ready()); + + return AUTH_PASSWD_API_SUCCESS; } -int sendToServer(char const * const interface, const RawBuffer &send, MessageBuffer &recv) { - int ret; - SockRAII sock; +int sendToServer(char const *const interface, const RawBuffer &send, MessageBuffer &recv) +{ + int ret; + SockRAII sock; - if (AUTH_PASSWD_API_SUCCESS != (ret = sock.Connect(interface))) { - LogError("Error in SockRAII"); - return ret; - } + if (AUTH_PASSWD_API_SUCCESS != (ret = sock.Connect(interface))) { + LogError("Error in SockRAII"); + return ret; + } - return sendToServerWithFd(sock.Get(), send, recv); + return sendToServerWithFd(sock.Get(), send, recv); } -int sendToServerAncData(char const * const interface, const RawBuffer &send, struct msghdr &hdr) { - int ret; - SockRAII sock; - ssize_t done = 0; - - if (AUTH_PASSWD_API_SUCCESS != (ret = sock.Connect(interface))) { - LogError("Error in SockRAII"); - return ret; - } - - while ((send.size() - done) > 0) { - if (0 >= waitForSocket(sock.Get(), POLLOUT, POLL_TIMEOUT)) { - LogError("Error in poll(POLLOUT)"); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - ssize_t temp = TEMP_FAILURE_RETRY(write(sock.Get(), &send[done], send.size() - done)); - if (-1 == temp) { - int err = errno; - LogError("Error in write: " << errnoToString(err)); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - done += temp; - } - - if (0 >= waitForSocket(sock.Get(), POLLIN, POLL_TIMEOUT)) { - LogError("Error in poll(POLLIN)"); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - ssize_t temp = TEMP_FAILURE_RETRY(recvmsg(sock.Get(), &hdr, MSG_CMSG_CLOEXEC)); - - if (temp < 0) { - int err = errno; - LogError("Error in recvmsg(): " << errnoToString(err) << " errno: " << err); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - if (0 == temp) { - LogError("Read return 0/Connection closed by server(?)"); - return AUTH_PASSWD_API_ERROR_SOCKET; - } - - return AUTH_PASSWD_API_SUCCESS; +int sendToServerAncData(char const *const interface, const RawBuffer &send, struct msghdr &hdr) +{ + int ret; + SockRAII sock; + ssize_t done = 0; + + if (AUTH_PASSWD_API_SUCCESS != (ret = sock.Connect(interface))) { + LogError("Error in SockRAII"); + return ret; + } + + while ((send.size() - done) > 0) { + if (0 >= waitForSocket(sock.Get(), POLLOUT, POLL_TIMEOUT)) { + LogError("Error in poll(POLLOUT)"); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + ssize_t temp = TEMP_FAILURE_RETRY(write(sock.Get(), &send[done], send.size() - done)); + + if (-1 == temp) { + int err = errno; + LogError("Error in write: " << errnoToString(err)); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + done += temp; + } + + if (0 >= waitForSocket(sock.Get(), POLLIN, POLL_TIMEOUT)) { + LogError("Error in poll(POLLIN)"); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + ssize_t temp = TEMP_FAILURE_RETRY(recvmsg(sock.Get(), &hdr, MSG_CMSG_CLOEXEC)); + + if (temp < 0) { + int err = errno; + LogError("Error in recvmsg(): " << errnoToString(err) << " errno: " << err); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + if (0 == temp) { + LogError("Read return 0/Connection closed by server(?)"); + return AUTH_PASSWD_API_ERROR_SOCKET; + } + + return AUTH_PASSWD_API_SUCCESS; } -int try_catch(const std::function& func) +int try_catch(const std::function &func) { - try { - return func(); - } catch (MessageBuffer::Exception::Base &e) { - LogError("AuthPasswd::MessageBuffer::Exception " << e.DumpToString()); - } catch (std::bad_alloc &e) { - LogError("Memory allocation failed " << e.what()); - return AUTH_PASSWD_API_ERROR_OUT_OF_MEMORY; - } catch (std::exception &e) { - LogError("STD exception " << e.what()); - } catch (...) { - LogError("Unknown exception occured"); - } - return AUTH_PASSWD_API_ERROR_UNKNOWN; + try { + return func(); + } catch (MessageBuffer::Exception::Base &e) { + LogError("AuthPasswd::MessageBuffer::Exception " << e.DumpToString()); + } catch (std::bad_alloc &e) { + LogError("Memory allocation failed " << e.what()); + return AUTH_PASSWD_API_ERROR_OUT_OF_MEMORY; + } catch (std::exception &e) { + LogError("STD exception " << e.what()); + } catch (...) { + LogError("Unknown exception occured"); + } + + return AUTH_PASSWD_API_ERROR_UNKNOWN; } } // namespace AuthPasswd -static void init_lib(void) __attribute__ ((constructor)); +static void init_lib(void) __attribute__((constructor)); static void init_lib(void) { - authPasswdClientEnableLogSystem(); + authPasswdClientEnableLogSystem(); } -static void fini_lib(void) __attribute__ ((destructor)); +static void fini_lib(void) __attribute__((destructor)); static void fini_lib(void) { - } diff --git a/src/client/client-password-admin.cpp b/src/client/client-password-admin.cpp index 56c7424..8b94a19 100644 --- a/src/client/client-password-admin.cpp +++ b/src/client/client-password-admin.cpp @@ -36,276 +36,261 @@ namespace { -inline bool isPasswordIncorrect(const char* pwd) +inline bool isPasswordIncorrect(const char *pwd) { - // NULL means that password must be cancelled. - return (pwd && (strlen(pwd) == 0 || strlen(pwd) > AuthPasswd::MAX_PASSWORD_LEN)); + // NULL means that password must be cancelled. + return (pwd && (strlen(pwd) == 0 || strlen(pwd) > AuthPasswd::MAX_PASSWORD_LEN)); } } // namespace anonymous AUTH_PASSWD_API int auth_passwd_reset_passwd(password_type passwd_type, - uid_t uid, - const char *new_passwd) + uid_t uid, + const char *new_passwd) { - using namespace AuthPasswd; + using namespace AuthPasswd; + return try_catch([&] { + if (isPasswordIncorrect(new_passwd)) { + LogError("Wrong input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - return try_catch([&] { - if (isPasswordIncorrect(new_passwd)) { - LogError("Wrong input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } + if (!new_passwd) + new_passwd = NO_PASSWORD; - if (!new_passwd) - new_passwd = NO_PASSWORD; + MessageBuffer send, recv; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_RST_PASSWD)); + Serialization::Serialize(send, passwd_type); + Serialization::Serialize(send, uid); + Serialization::Serialize(send, std::string(new_passwd)); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_RST_PASSWD)); - Serialization::Serialize(send, passwd_type); - Serialization::Serialize(send, uid); - Serialization::Serialize(send, std::string(new_passwd)); + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_RESET, send.Pop(), recv); + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogError("Error in sendToServer. Error code: " << retCode); + return retCode; + } - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_RESET, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogError("Error in sendToServer. Error code: " << retCode); - return retCode; - } + Deserialization::Deserialize(recv, retCode); - Deserialization::Deserialize(recv, retCode); - - return retCode; - }); + return retCode; + }); } AUTH_PASSWD_API int auth_passwd_new_policy(policy_h **pp_policy) { - if (!pp_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + if (!pp_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = new (std::nothrow) AuthPasswd::Policy; - if (policy == nullptr) - return AUTH_PASSWD_API_ERROR_OUT_OF_MEMORY; + auto policy = new(std::nothrow) AuthPasswd::Policy; - *pp_policy = reinterpret_cast(policy); + if (policy == nullptr) + return AUTH_PASSWD_API_ERROR_OUT_OF_MEMORY; - return AUTH_PASSWD_API_SUCCESS; + *pp_policy = reinterpret_cast(policy); + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_user(policy_h *p_policy, uid_t uid) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_USER); - policy->uid = uid; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_USER); + policy->uid = uid; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_max_attempts(policy_h *p_policy, unsigned int max_attempts) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - auto policy = reinterpret_cast(p_policy); - /* TODO: set flag & value in atomic operation */ - policy->setFlag(POLICY_MAX_ATTEMPTS); - policy->maxAttempts = max_attempts; - - return AUTH_PASSWD_API_SUCCESS; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + + auto policy = reinterpret_cast(p_policy); + /* TODO: set flag & value in atomic operation */ + policy->setFlag(POLICY_MAX_ATTEMPTS); + policy->maxAttempts = max_attempts; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_validity(policy_h *p_policy, unsigned int valid_days) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_VALID_PERIOD); - policy->validPeriod = valid_days; - - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_VALID_PERIOD); + policy->validPeriod = valid_days; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_history_size(policy_h *p_policy, unsigned int history_size) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_HISTORY_SIZE); - policy->historySize = history_size; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_HISTORY_SIZE); + policy->historySize = history_size; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_min_length(policy_h *p_policy, unsigned int min_length) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_MIN_LENGTH); - policy->minLength = min_length; - - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_MIN_LENGTH); + policy->minLength = min_length; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_min_complex_char_num(policy_h *p_policy, unsigned int val) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_MIN_COMPLEX_CHAR_NUMBER); - policy->minComplexCharNumber = val; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_MIN_COMPLEX_CHAR_NUMBER); + policy->minComplexCharNumber = val; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_max_char_occurrences(policy_h *p_policy, unsigned int val) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_MAX_CHAR_OCCURRENCES); - policy->maxCharOccurrences = val; - - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_MAX_CHAR_OCCURRENCES); + policy->maxCharOccurrences = val; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_max_num_seq_len(policy_h *p_policy, unsigned int val) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_MAX_NUMERIC_SEQ_LENGTH); - policy->maxNumSeqLength = val; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_MAX_NUMERIC_SEQ_LENGTH); + policy->maxNumSeqLength = val; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_quality(policy_h *p_policy, password_quality_type quality_type) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_QUALITY_TYPE); - policy->qualityType = quality_type; - - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_QUALITY_TYPE); + policy->qualityType = quality_type; + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_pattern(policy_h *p_policy, const char *pattern) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - if (!pattern) - pattern = AuthPasswd::NO_PATTERN; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_PATTERN); - policy->pattern = std::string(pattern); - - return AUTH_PASSWD_API_SUCCESS; + if (!pattern) + pattern = AuthPasswd::NO_PATTERN; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_PATTERN); + policy->pattern = std::string(pattern); + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_forbidden_passwd(policy_h *p_policy, const char *forbidden_passwd) { - if (!p_policy) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - - if (!forbidden_passwd) - forbidden_passwd = AuthPasswd::NO_FORBIDDEND_PASSWORD; + if (!p_policy) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - auto policy = reinterpret_cast(p_policy); - policy->setFlag(POLICY_FORBIDDEN_PASSWDS); - policy->forbiddenPasswds.insert(forbidden_passwd); + if (!forbidden_passwd) + forbidden_passwd = AuthPasswd::NO_FORBIDDEND_PASSWORD; - return AUTH_PASSWD_API_SUCCESS; + auto policy = reinterpret_cast(p_policy); + policy->setFlag(POLICY_FORBIDDEN_PASSWDS); + policy->forbiddenPasswds.insert(forbidden_passwd); + return AUTH_PASSWD_API_SUCCESS; } AUTH_PASSWD_API int auth_passwd_set_policy(policy_h *p_policy) { - using namespace AuthPasswd; + using namespace AuthPasswd; + return try_catch([&] { + if (!p_policy) { + LogError("Wrong input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - return try_catch([&] { - if (!p_policy) { - LogError("Wrong input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } + auto policy = reinterpret_cast(p_policy); - auto policy = reinterpret_cast(p_policy); + if (!policy->isFlagOn(POLICY_USER)) + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - if (!policy->isFlagOn(POLICY_USER)) - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + MessageBuffer send, recv; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_SET_PASSWD_POLICY)); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_SET_PASSWD_POLICY)); + PolicySerializable policys(*policy); + policys.Serialize(send); - PolicySerializable policys(*policy); - policys.Serialize(send); + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_POLICY, send.Pop(), recv); + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogError("Error in sendToServer. Error code: " << retCode); + return retCode; + } - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_POLICY, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogError("Error in sendToServer. Error code: " << retCode); - return retCode; - } + Deserialization::Deserialize(recv, retCode); - Deserialization::Deserialize(recv, retCode); - - return retCode; - }); + return retCode; + }); } AUTH_PASSWD_API void auth_passwd_free_policy(policy_h *p_policy) { - delete (reinterpret_cast(p_policy)); + delete(reinterpret_cast(p_policy)); } AUTH_PASSWD_API int auth_passwd_disable_policy(uid_t uid) { - using namespace AuthPasswd; - - return try_catch([&] { + using namespace AuthPasswd; + return try_catch([&] { + MessageBuffer send, recv; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_DIS_PASSWD_POLICY)); + Serialization::Serialize(send, uid); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_DIS_PASSWD_POLICY)); - Serialization::Serialize(send, uid); + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_POLICY, send.Pop(), recv); - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_POLICY, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogError("Error in sendToServer. Error code: " << retCode); - return retCode; - } + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogError("Error in sendToServer. Error code: " << retCode); + return retCode; + } - Deserialization::Deserialize(recv, retCode); + Deserialization::Deserialize(recv, retCode); - return retCode; - }); + return retCode; + }); } diff --git a/src/client/client-password.cpp b/src/client/client-password.cpp index 3f85185..600534b 100644 --- a/src/client/client-password.cpp +++ b/src/client/client-password.cpp @@ -39,219 +39,214 @@ namespace { -inline bool isPasswordIncorrect(const char* passwd) +inline bool isPasswordIncorrect(const char *passwd) { - // NULL means that password must be cancelled. - return (passwd && (strlen(passwd) == 0 || strlen(passwd) > AuthPasswd::MAX_PASSWORD_LEN)); + // NULL means that password must be cancelled. + return (passwd && (strlen(passwd) == 0 || strlen(passwd) > AuthPasswd::MAX_PASSWORD_LEN)); } } // namespace anonymous AUTH_PASSWD_API int auth_passwd_check_passwd(password_type passwd_type, - const char *passwd, - unsigned int *current_attempts, - unsigned int *max_attempts, - unsigned int *valid_secs) + const char *passwd, + unsigned int *current_attempts, + unsigned int *max_attempts, + unsigned int *valid_secs) { - using namespace AuthPasswd; - - return try_catch([&] { - if (isPasswordIncorrect(passwd) || - current_attempts == NULL || max_attempts == NULL || valid_secs == NULL) { - LogError("Wrong input param"); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - - if (!passwd) { - passwd = NO_PASSWORD; - } - - MessageBuffer send, recv; - - *current_attempts = 0; - *max_attempts = 0; - *valid_secs = 0; - - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_CHK_PASSWD)); - Serialization::Serialize(send, passwd_type); - - //Clear pwd memory - std::string passwd_str(passwd); - Serialization::Serialize(send, passwd_str); - passwd_str.clear(); - - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_CHECK, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogDebug("Error in sendToServer. Error code: " << retCode); - return retCode; - } - - Deserialization::Deserialize(recv, retCode); - - switch (retCode) { - case AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH: - case AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED: - case AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED: - case AUTH_PASSWD_API_SUCCESS: - Deserialization::Deserialize(recv, *current_attempts); - Deserialization::Deserialize(recv, *max_attempts); - Deserialization::Deserialize(recv, *valid_secs); - break; - default: - break; - } - - return retCode; - }); + using namespace AuthPasswd; + return try_catch([&] { + if (isPasswordIncorrect(passwd) || + current_attempts == NULL || max_attempts == NULL || valid_secs == NULL) { + LogError("Wrong input param"); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + if (!passwd) + passwd = NO_PASSWORD; + + MessageBuffer send, recv; + + *current_attempts = 0; + *max_attempts = 0; + *valid_secs = 0; + + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_CHK_PASSWD)); + Serialization::Serialize(send, passwd_type); + + //Clear pwd memory + std::string passwd_str(passwd); + Serialization::Serialize(send, passwd_str); + passwd_str.clear(); + + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_CHECK, send.Pop(), recv); + + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogDebug("Error in sendToServer. Error code: " << retCode); + return retCode; + } + + Deserialization::Deserialize(recv, retCode); + + switch (retCode) { + case AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH: + case AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED: + case AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED: + case AUTH_PASSWD_API_SUCCESS: + Deserialization::Deserialize(recv, *current_attempts); + Deserialization::Deserialize(recv, *max_attempts); + Deserialization::Deserialize(recv, *valid_secs); + break; + + default: + break; + } + + return retCode; + }); } AUTH_PASSWD_API int auth_passwd_check_passwd_state(password_type passwd_type, - unsigned int *current_attempts, - unsigned int *max_attempts, - unsigned int *valid_secs) + unsigned int *current_attempts, + unsigned int *max_attempts, + unsigned int *valid_secs) { - using namespace AuthPasswd; + using namespace AuthPasswd; + return try_catch([&] { + if (NULL == current_attempts || NULL == max_attempts || + NULL == valid_secs) { + LogError("Wrong input param"); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - return try_catch([&] { - if (NULL == current_attempts || NULL == max_attempts || - NULL == valid_secs) { + MessageBuffer send, recv; - LogError("Wrong input param"); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } + *current_attempts = 0; + *max_attempts = 0; + *valid_secs = 0; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_CHK_PASSWD_STATE)); + Serialization::Serialize(send, passwd_type); - *current_attempts = 0; - *max_attempts = 0; - *valid_secs = 0; + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_CHECK, send.Pop(), recv); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_CHK_PASSWD_STATE)); - Serialization::Serialize(send, passwd_type); + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogDebug("Error in sendToServer. Error code: " << retCode); + return retCode; + } - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_CHECK, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogDebug("Error in sendToServer. Error code: " << retCode); - return retCode; - } + Deserialization::Deserialize(recv, retCode); - Deserialization::Deserialize(recv, retCode); + if (retCode == AUTH_PASSWD_API_SUCCESS) { + Deserialization::Deserialize(recv, *current_attempts); + Deserialization::Deserialize(recv, *max_attempts); + Deserialization::Deserialize(recv, *valid_secs); + } - if(retCode == AUTH_PASSWD_API_SUCCESS) { - Deserialization::Deserialize(recv, *current_attempts); - Deserialization::Deserialize(recv, *max_attempts); - Deserialization::Deserialize(recv, *valid_secs); - } - - return retCode; - }); + return retCode; + }); } AUTH_PASSWD_API -int auth_passwd_check_passwd_reused(password_type passwd_type, - const char *passwd, - int *is_reused) +int auth_passwd_check_passwd_reused(password_type passwd_type, + const char *passwd, + int *is_reused) { - using namespace AuthPasswd; + using namespace AuthPasswd; + return try_catch([&] { + if (NULL == passwd || NULL == is_reused) { + LogError("Wrong input param"); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - return try_catch([&] { - if (NULL == passwd || NULL == is_reused) { - LogError("Wrong input param"); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } + MessageBuffer send, recv; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_CHK_PASSWD_REUSED)); + Serialization::Serialize(send, passwd_type); + Serialization::Serialize(send, std::string(passwd)); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_CHK_PASSWD_REUSED)); - Serialization::Serialize(send, passwd_type); - Serialization::Serialize(send, std::string(passwd)); + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_SET, send.Pop(), recv); - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_SET, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogDebug("Error in sendToServer. Error code: " << retCode); - return retCode; - } + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogDebug("Error in sendToServer. Error code: " << retCode); + return retCode; + } - Deserialization::Deserialize(recv, retCode); + Deserialization::Deserialize(recv, retCode); - if (AUTH_PASSWD_API_SUCCESS == retCode) { - Deserialization::Deserialize(recv, *is_reused); - } + if (AUTH_PASSWD_API_SUCCESS == retCode) + Deserialization::Deserialize(recv, *is_reused); - return retCode; - }); + return retCode; + }); } AUTH_PASSWD_API int auth_passwd_set_passwd(password_type passwd_type, - const char *cur_passwd, - const char *new_passwd) + const char *cur_passwd, + const char *new_passwd) { - using namespace AuthPasswd; + using namespace AuthPasswd; + return try_catch([&] { + if (!cur_passwd) + cur_passwd = NO_PASSWORD; - return try_catch([&] { - if (!cur_passwd) { - cur_passwd = NO_PASSWORD; - } + if (isPasswordIncorrect(new_passwd) || strlen(cur_passwd) > MAX_PASSWORD_LEN) { + LogError("Wrong input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - if (isPasswordIncorrect(new_passwd) || strlen(cur_passwd) > MAX_PASSWORD_LEN) { - LogError("Wrong input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } + if (!new_passwd) + new_passwd = NO_PASSWORD; - if (!new_passwd) { - new_passwd = NO_PASSWORD; - } + MessageBuffer send, recv; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_SET_PASSWD)); + Serialization::Serialize(send, passwd_type); + Serialization::Serialize(send, std::string(cur_passwd)); + Serialization::Serialize(send, std::string(new_passwd)); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_SET_PASSWD)); - Serialization::Serialize(send, passwd_type); - Serialization::Serialize(send, std::string(cur_passwd)); - Serialization::Serialize(send, std::string(new_passwd)); + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_SET, send.Pop(), recv); - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_SET, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogError("Error in sendToServer. Error code: " << retCode); - return retCode; - } + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogError("Error in sendToServer. Error code: " << retCode); + return retCode; + } - Deserialization::Deserialize(recv, retCode); + Deserialization::Deserialize(recv, retCode); - return retCode; - }); + return retCode; + }); } AUTH_PASSWD_API int auth_passwd_set_passwd_recovery(const char *cur_recovery_passwd, - const char *new_normal_passwd) + const char *new_normal_passwd) { - using namespace AuthPasswd; - - return try_catch([&] { - if (!new_normal_passwd || isPasswordIncorrect(new_normal_passwd) || - !cur_recovery_passwd || isPasswordIncorrect(cur_recovery_passwd)) { + using namespace AuthPasswd; + return try_catch([&] { + if (!new_normal_passwd || isPasswordIncorrect(new_normal_passwd) || + !cur_recovery_passwd || isPasswordIncorrect(cur_recovery_passwd)) { + LogError("Wrong input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - LogError("Wrong input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } + MessageBuffer send, recv; - MessageBuffer send, recv; + Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_SET_PASSWD_RECOVERY)); + Serialization::Serialize(send, std::string(cur_recovery_passwd)); + Serialization::Serialize(send, std::string(new_normal_passwd)); - Serialization::Serialize(send, static_cast(PasswordHdrs::HDR_SET_PASSWD_RECOVERY)); - Serialization::Serialize(send, std::string(cur_recovery_passwd)); - Serialization::Serialize(send, std::string(new_normal_passwd)); + int retCode = sendToServer(SERVICE_SOCKET_PASSWD_SET, send.Pop(), recv); - int retCode = sendToServer(SERVICE_SOCKET_PASSWD_SET, send.Pop(), recv); - if (AUTH_PASSWD_API_SUCCESS != retCode) { - LogError("Error in sendToServer. Error code: " << retCode); - return retCode; - } + if (AUTH_PASSWD_API_SUCCESS != retCode) { + LogError("Error in sendToServer. Error code: " << retCode); + return retCode; + } - Deserialization::Deserialize(recv, retCode); + Deserialization::Deserialize(recv, retCode); - return retCode; - }); + return retCode; + }); } diff --git a/src/client/include/client-common.h b/src/client/include/client-common.h index 6d24c51..ea80190 100644 --- a/src/client/include/client-common.h +++ b/src/client/include/client-common.h @@ -36,7 +36,7 @@ #define AUTH_PASSWD_API __attribute__((visibility("default"))) extern "C" { - struct msghdr; + struct msghdr; } namespace AuthPasswd { @@ -45,7 +45,7 @@ typedef std::vector RawBuffer; int sendToServerWithFd(int fd, const RawBuffer &send, MessageBuffer &recv); -int sendToServer(char const * const interface, const RawBuffer &send, MessageBuffer &recv); +int sendToServer(char const *const interface, const RawBuffer &send, MessageBuffer &recv); /* * sendToServerAncData is special case when we want to receive file descriptor @@ -55,34 +55,32 @@ int sendToServer(char const * const interface, const RawBuffer &send, MessageBuf * This function should be called _ONLY_ in this particular case. * */ -int sendToServerAncData(char const * const interface, const RawBuffer &send, struct msghdr &hdr); +int sendToServerAncData(char const *const interface, const RawBuffer &send, struct msghdr &hdr); /* * Decorator function that performs frequently repeated exception handling in * SS client API functions. Accepts lambda expression as an argument. */ -int try_catch(const std::function& func); +int try_catch(const std::function &func); class SockRAII { public: - SockRAII() - : m_sock(-1) - {} + SockRAII() : m_sock(-1) {} - ~SockRAII() { - if (m_sock > -1 ) - close(m_sock); - } + ~SockRAII() { + if (m_sock > -1) + close(m_sock); + } - int Connect(char const * const interface); + int Connect(char const *const interface); - int Get() const { - return m_sock; - } + int Get() const { + return m_sock; + } private: - int m_sock; + int m_sock; }; } // namespace AuthPasswd diff --git a/src/common/error-description.cpp b/src/common/error-description.cpp index 38d27a6..1b041c6 100644 --- a/src/common/error-description.cpp +++ b/src/common/error-description.cpp @@ -28,18 +28,22 @@ namespace AuthPasswd { COMMON_API -std::string errnoToString(int err) { - char buffer[MAX_BUF] = {}; - +std::string errnoToString(int err) +{ + char buffer[MAX_BUF] = {}; #if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE - if (0 == strerror_r(err, buffer, MAX_BUF)) - return std::string(buffer); + + if (0 == strerror_r(err, buffer, MAX_BUF)) + return std::string(buffer); + #else - char *result = strerror_r(err, buffer, MAX_BUF); - if (result) - return std::string(result); + char *result = strerror_r(err, buffer, MAX_BUF); + + if (result) + return std::string(result); + #endif - return std::string(); + return std::string(); } } // namespace AuthPasswd diff --git a/src/common/include/connection-info.h b/src/common/include/connection-info.h index ab58a24..3c2f89c 100644 --- a/src/common/include/connection-info.h +++ b/src/common/include/connection-info.h @@ -32,8 +32,8 @@ namespace AuthPasswd { struct ConnectionInfo { - InterfaceID interfaceID; - MessageBuffer buffer; + InterfaceID interfaceID; + MessageBuffer buffer; }; typedef std::map ConnectionInfoMap; diff --git a/src/common/include/message-buffer.h b/src/common/include/message-buffer.h index 56b707f..58cd3b4 100644 --- a/src/common/include/message-buffer.h +++ b/src/common/include/message-buffer.h @@ -38,40 +38,37 @@ typedef std::vector RawBuffer; class COMMON_API MessageBuffer : public AuthPasswd::IStream { public: - class Exception { - public: - DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) - DECLARE_EXCEPTION_TYPE(Base, OutOfData) - }; + class Exception { + public: + DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, OutOfData) + }; - MessageBuffer() - : m_bytesLeft(0) - {} + MessageBuffer() : m_bytesLeft(0) {} - void Push(const RawBuffer &data); + void Push(const RawBuffer &data); - RawBuffer Pop(); + RawBuffer Pop(); - bool Ready(); + bool Ready(); - virtual void Read(size_t num, void *bytes); + virtual void Read(size_t num, void *bytes); - virtual void Write(size_t num, const void *bytes); + virtual void Write(size_t num, const void *bytes); protected: + inline void CountBytesLeft() { + if (m_bytesLeft > 0) + return; // we already counted m_bytesLeft nothing to do - inline void CountBytesLeft() { - if (m_bytesLeft > 0) - return; // we already counted m_bytesLeft nothing to do + if (m_buffer.Size() < sizeof(size_t)) + return; // we cannot count m_bytesLeft because buffer is too small - if (m_buffer.Size() < sizeof(size_t)) - return; // we cannot count m_bytesLeft because buffer is too small + m_buffer.FlattenConsume(&m_bytesLeft, sizeof(size_t)); + } - m_buffer.FlattenConsume(&m_bytesLeft, sizeof(size_t)); - } - - size_t m_bytesLeft; - BinaryQueue m_buffer; + size_t m_bytesLeft; + BinaryQueue m_buffer; }; } // namespace AuthPasswd diff --git a/src/common/include/policy.h b/src/common/include/policy.h index cf06537..953dd62 100644 --- a/src/common/include/policy.h +++ b/src/common/include/policy.h @@ -53,13 +53,13 @@ COMMON_API extern const unsigned int PASSWORD_API_NO_EXPIRATION; COMMON_API -extern const char* NO_PASSWORD; +extern const char *NO_PASSWORD; COMMON_API -extern const char* NO_PATTERN; +extern const char *NO_PATTERN; COMMON_API -extern const char* NO_FORBIDDEND_PASSWORD; +extern const char *NO_FORBIDDEND_PASSWORD; COMMON_API @@ -78,55 +78,53 @@ COMMON_API extern const std::string REGEX_QUALITY_ALPHANUMERIC; struct COMMON_API Policy { - Policy(); - ~Policy(); - - std::string info(void) const; - - inline void setFlag(password_policy_type field) - { - flag |= (1 << field); - } - - inline bool isFlagOn(password_policy_type field) - { - return (flag & (1 << field)) ? true : false; - } - - // XOR-ed value of password_policy_type enum - int flag; - - uid_t uid; - - // maximum number of attempts that user can try to check the password without success in serial - unsigned int maxAttempts; - // number of days that this password is valid - unsigned int validPeriod; - // recent number of passwords which user cannot reuse - unsigned int historySize; - // a min number of characters of password - unsigned int minLength; - // a min number of complex chars(non-alphabetic) in password - unsigned int minComplexCharNumber; - // Maximum count of the same character in the password - unsigned int maxCharOccurrences; - // Maximum numeric sequence length in the password - // regardless descending order, ascending order or repetition - unsigned int maxNumSeqLength; - // password quality - unsigned int qualityType; - - // password regular expression - std::string pattern; - - // forbidden strings in password - std::set forbiddenPasswds; + Policy(); + ~Policy(); + + std::string info(void) const; + + inline void setFlag(password_policy_type field) { + flag |= (1 << field); + } + + inline bool isFlagOn(password_policy_type field) { + return (flag & (1 << field)) ? true : false; + } + + // XOR-ed value of password_policy_type enum + int flag; + + uid_t uid; + + // maximum number of attempts that user can try to check the password without success in serial + unsigned int maxAttempts; + // number of days that this password is valid + unsigned int validPeriod; + // recent number of passwords which user cannot reuse + unsigned int historySize; + // a min number of characters of password + unsigned int minLength; + // a min number of complex chars(non-alphabetic) in password + unsigned int minComplexCharNumber; + // Maximum count of the same character in the password + unsigned int maxCharOccurrences; + // Maximum numeric sequence length in the password + // regardless descending order, ascending order or repetition + unsigned int maxNumSeqLength; + // password quality + unsigned int qualityType; + + // password regular expression + std::string pattern; + + // forbidden strings in password + std::set forbiddenPasswds; }; struct COMMON_API PolicySerializable : public Policy, ISerializable { - explicit PolicySerializable(const Policy &); - explicit PolicySerializable(IStream &); - void Serialize(IStream &) const; + explicit PolicySerializable(const Policy &); + explicit PolicySerializable(IStream &); + void Serialize(IStream &) const; }; } diff --git a/src/common/include/protocols.h b/src/common/include/protocols.h index e851371..23e1429 100644 --- a/src/common/include/protocols.h +++ b/src/common/include/protocols.h @@ -35,26 +35,26 @@ namespace AuthPasswd { COMMON_API -extern char const * const SERVICE_SOCKET_PASSWD_CHECK; +extern char const *const SERVICE_SOCKET_PASSWD_CHECK; COMMON_API -extern char const * const SERVICE_SOCKET_PASSWD_SET; +extern char const *const SERVICE_SOCKET_PASSWD_SET; COMMON_API -extern char const * const SERVICE_SOCKET_PASSWD_RESET; +extern char const *const SERVICE_SOCKET_PASSWD_RESET; COMMON_API -extern char const * const SERVICE_SOCKET_PASSWD_POLICY; +extern char const *const SERVICE_SOCKET_PASSWD_POLICY; enum class PasswordHdrs { - HDR_CHK_PASSWD, - HDR_CHK_PASSWD_STATE, - HDR_CHK_PASSWD_REUSED, - HDR_SET_PASSWD, - HDR_SET_PASSWD_RECOVERY, - HDR_RST_PASSWD, - HDR_SET_PASSWD_POLICY, - HDR_DIS_PASSWD_POLICY + HDR_CHK_PASSWD, + HDR_CHK_PASSWD_STATE, + HDR_CHK_PASSWD_REUSED, + HDR_SET_PASSWD, + HDR_SET_PASSWD_RECOVERY, + HDR_RST_PASSWD, + HDR_SET_PASSWD_POLICY, + HDR_DIS_PASSWD_POLICY }; } // namespace AuthPasswd diff --git a/src/common/message-buffer.cpp b/src/common/message-buffer.cpp index 80bdd96..b9a98a3 100644 --- a/src/common/message-buffer.cpp +++ b/src/common/message-buffer.cpp @@ -28,41 +28,51 @@ namespace AuthPasswd { -void MessageBuffer::Push(const RawBuffer &data) { - m_buffer.AppendCopy(&data[0], data.size()); +void MessageBuffer::Push(const RawBuffer &data) +{ + m_buffer.AppendCopy(&data[0], data.size()); } -RawBuffer MessageBuffer::Pop() { - size_t size = m_buffer.Size(); - RawBuffer buffer; - buffer.resize(size + sizeof(size_t)); - memcpy(&buffer[0], &size, sizeof(size_t)); - m_buffer.FlattenConsume(&buffer[sizeof(size_t)], size); - return buffer; +RawBuffer MessageBuffer::Pop() +{ + size_t size = m_buffer.Size(); + RawBuffer buffer; + buffer.resize(size + sizeof(size_t)); + memcpy(&buffer[0], &size, sizeof(size_t)); + m_buffer.FlattenConsume(&buffer[sizeof(size_t)], size); + return buffer; } -bool MessageBuffer::Ready() { - CountBytesLeft(); - if (m_bytesLeft == 0) - return false; - if (m_bytesLeft > m_buffer.Size()) - return false; - return true; +bool MessageBuffer::Ready() +{ + CountBytesLeft(); + + if (m_bytesLeft == 0) + return false; + + if (m_bytesLeft > m_buffer.Size()) + return false; + + return true; } -void MessageBuffer::Read(size_t num, void *bytes) { - CountBytesLeft(); - if (num > m_bytesLeft) { - LogDebug("Protocol broken. OutOfData. Asked for: " << num << " Ready: " << m_bytesLeft << " Buffer.size(): " << m_buffer.Size()); - Throw(Exception::OutOfData); - } +void MessageBuffer::Read(size_t num, void *bytes) +{ + CountBytesLeft(); + + if (num > m_bytesLeft) { + LogDebug("Protocol broken. OutOfData. Asked for: " << num << " Ready: " << m_bytesLeft << + " Buffer.size(): " << m_buffer.Size()); + Throw(Exception::OutOfData); + } - m_buffer.FlattenConsume(bytes, num); - m_bytesLeft -= num; + m_buffer.FlattenConsume(bytes, num); + m_bytesLeft -= num; } -void MessageBuffer::Write(size_t num, const void *bytes) { - m_buffer.AppendCopy(bytes, num); +void MessageBuffer::Write(size_t num, const void *bytes) +{ + m_buffer.AppendCopy(bytes, num); } } // namespace AuthPasswd diff --git a/src/common/policy.cpp b/src/common/policy.cpp index 4e2cee8..05d2406 100644 --- a/src/common/policy.cpp +++ b/src/common/policy.cpp @@ -33,9 +33,9 @@ const unsigned int PASSWORD_INFINITE_EXPIRATION_DAYS = 0; const unsigned int PASSWORD_INFINITE_ATTEMPT_COUNT = 0; const unsigned int PASSWORD_API_NO_EXPIRATION = 0xFFFFFFFF; -const char* NO_PASSWORD = ""; -const char* NO_PATTERN = ""; -const char* NO_FORBIDDEND_PASSWORD = ""; +const char *NO_PASSWORD = ""; +const char *NO_PATTERN = ""; +const char *NO_FORBIDDEND_PASSWORD = ""; const std::string REGEX_QUALITY_UNSPECIFIED = "[.]*"; const std::string REGEX_QUALITY_SOMETHING = ".+"; @@ -44,17 +44,17 @@ const std::string REGEX_QUALITY_ALPHABETIC = "^[A-Za-z]+$"; const std::string REGEX_QUALITY_ALPHANUMERIC = "^[A-Za-z0-9]+$"; Policy::Policy() : - flag(0), - uid(0), - maxAttempts(0), - validPeriod(0), - historySize(0), - minLength(0), - minComplexCharNumber(0), - maxCharOccurrences(0), - maxNumSeqLength(0), - qualityType(AUTH_PWD_QUALITY_UNSPECIFIED), - pattern(NO_PATTERN) + flag(0), + uid(0), + maxAttempts(0), + validPeriod(0), + historySize(0), + minLength(0), + minComplexCharNumber(0), + maxCharOccurrences(0), + maxNumSeqLength(0), + qualityType(AUTH_PWD_QUALITY_UNSPECIFIED), + pattern(NO_PATTERN) { } @@ -64,24 +64,25 @@ Policy::~Policy() std::string Policy::info() const { - std::stringstream ss; - ss << "Uid: " << uid; - ss << " flag: " << flag; - ss << " maxAttempts: " << maxAttempts; - ss << " validPeriod: " << validPeriod; - ss << " historySize: " << historySize; - ss << " minLength: " << minLength; - ss << " minComplexCharNumber: " << minComplexCharNumber; - ss << " maxCharOccurrences: " << maxCharOccurrences; - ss << " maxNumSeqLength: " << maxNumSeqLength; - ss << " qualityType: " << qualityType; - ss << " pattern: " << pattern; - ss << " forbiddenPasswd size: " << forbiddenPasswds.size(); - ss << " forbiddenPasswd items:"; - for (auto &item : forbiddenPasswds) - ss << " " << item; + std::stringstream ss; + ss << "Uid: " << uid; + ss << " flag: " << flag; + ss << " maxAttempts: " << maxAttempts; + ss << " validPeriod: " << validPeriod; + ss << " historySize: " << historySize; + ss << " minLength: " << minLength; + ss << " minComplexCharNumber: " << minComplexCharNumber; + ss << " maxCharOccurrences: " << maxCharOccurrences; + ss << " maxNumSeqLength: " << maxNumSeqLength; + ss << " qualityType: " << qualityType; + ss << " pattern: " << pattern; + ss << " forbiddenPasswd size: " << forbiddenPasswds.size(); + ss << " forbiddenPasswd items:"; - return ss.str(); + for (auto &item : forbiddenPasswds) + ss << " " << item; + + return ss.str(); } PolicySerializable::PolicySerializable(const Policy &policy) : Policy(policy) @@ -90,34 +91,34 @@ PolicySerializable::PolicySerializable(const Policy &policy) : Policy(policy) PolicySerializable::PolicySerializable(IStream &stream) { - Deserialization::Deserialize(stream, flag); - Deserialization::Deserialize(stream, uid); - Deserialization::Deserialize(stream, maxAttempts); - Deserialization::Deserialize(stream, validPeriod); - Deserialization::Deserialize(stream, historySize); - Deserialization::Deserialize(stream, minLength); - Deserialization::Deserialize(stream, minComplexCharNumber); - Deserialization::Deserialize(stream, maxCharOccurrences); - Deserialization::Deserialize(stream, maxNumSeqLength); - Deserialization::Deserialize(stream, qualityType); - Deserialization::Deserialize(stream, pattern); - Deserialization::Deserialize(stream, forbiddenPasswds); + Deserialization::Deserialize(stream, flag); + Deserialization::Deserialize(stream, uid); + Deserialization::Deserialize(stream, maxAttempts); + Deserialization::Deserialize(stream, validPeriod); + Deserialization::Deserialize(stream, historySize); + Deserialization::Deserialize(stream, minLength); + Deserialization::Deserialize(stream, minComplexCharNumber); + Deserialization::Deserialize(stream, maxCharOccurrences); + Deserialization::Deserialize(stream, maxNumSeqLength); + Deserialization::Deserialize(stream, qualityType); + Deserialization::Deserialize(stream, pattern); + Deserialization::Deserialize(stream, forbiddenPasswds); } void PolicySerializable::Serialize(IStream &stream) const { - Serialization::Serialize(stream, flag); - Serialization::Serialize(stream, uid); - Serialization::Serialize(stream, maxAttempts); - Serialization::Serialize(stream, validPeriod); - Serialization::Serialize(stream, historySize); - Serialization::Serialize(stream, minLength); - Serialization::Serialize(stream, minComplexCharNumber); - Serialization::Serialize(stream, maxCharOccurrences); - Serialization::Serialize(stream, maxNumSeqLength); - Serialization::Serialize(stream, qualityType); - Serialization::Serialize(stream, pattern); - Serialization::Serialize(stream, forbiddenPasswds); + Serialization::Serialize(stream, flag); + Serialization::Serialize(stream, uid); + Serialization::Serialize(stream, maxAttempts); + Serialization::Serialize(stream, validPeriod); + Serialization::Serialize(stream, historySize); + Serialization::Serialize(stream, minLength); + Serialization::Serialize(stream, minComplexCharNumber); + Serialization::Serialize(stream, maxCharOccurrences); + Serialization::Serialize(stream, maxNumSeqLength); + Serialization::Serialize(stream, qualityType); + Serialization::Serialize(stream, pattern); + Serialization::Serialize(stream, forbiddenPasswds); } } // namespace AuthPasswd diff --git a/src/common/protocols.cpp b/src/common/protocols.cpp index 31a5a2e..f27f94b 100644 --- a/src/common/protocols.cpp +++ b/src/common/protocols.cpp @@ -27,10 +27,10 @@ namespace AuthPasswd { -char const * const SERVICE_SOCKET_PASSWD_CHECK = RUN_DIR "/." SOCK_PASSWD_CHECK; -char const * const SERVICE_SOCKET_PASSWD_SET = RUN_DIR "/." SOCK_PASSWD_SET; -char const * const SERVICE_SOCKET_PASSWD_RESET = RUN_DIR "/." SOCK_PASSWD_RESET; -char const * const SERVICE_SOCKET_PASSWD_POLICY = RUN_DIR "/." SOCK_PASSWD_POLICY; +char const *const SERVICE_SOCKET_PASSWD_CHECK = RUN_DIR "/." SOCK_PASSWD_CHECK; +char const *const SERVICE_SOCKET_PASSWD_SET = RUN_DIR "/." SOCK_PASSWD_SET; +char const *const SERVICE_SOCKET_PASSWD_RESET = RUN_DIR "/." SOCK_PASSWD_RESET; +char const *const SERVICE_SOCKET_PASSWD_POLICY = RUN_DIR "/." SOCK_PASSWD_POLICY; } // namespace AuthPasswd diff --git a/src/dpl/core/include/dpl/assert.h b/src/dpl/core/include/dpl/assert.h index adcd289..ef4c09e 100644 --- a/src/dpl/core/include/dpl/assert.h +++ b/src/dpl/core/include/dpl/assert.h @@ -29,15 +29,15 @@ namespace AuthPasswd { // Do not call directly // Always use Assert macro AUTHPASSWD_NORETURN void AssertProc(const char *condition, - const char *file, - int line, - const char *function); + const char *file, + int line, + const char *function); } // namespace AuthPasswd #define Assert(Condition) do { if (!(Condition)) { AuthPasswd::AssertProc(#Condition, \ - __FILE__, \ - __LINE__, \ - __FUNCTION__); \ - } } while (0) + __FILE__, \ + __LINE__, \ + __FUNCTION__); \ + } } while (0) #endif // AUTH_PASSWD_ASSERT_H diff --git a/src/dpl/core/include/dpl/binary_queue.h b/src/dpl/core/include/dpl/binary_queue.h index f2c1382..8ecd1a3 100644 --- a/src/dpl/core/include/dpl/binary_queue.h +++ b/src/dpl/core/include/dpl/binary_queue.h @@ -43,248 +43,248 @@ typedef std::auto_ptr BinaryQueueAutoPtr; */ class COMMON_API BinaryQueue { public: - class Exception { - public: - DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) - DECLARE_EXCEPTION_TYPE(Base, OutOfData) - }; - - typedef void (*BufferDeleter)(const void *buffer, size_t bufferSize, - void *userParam); - static void BufferDeleterFree(const void *buffer, - size_t bufferSize, - void *userParam); - - class BucketVisitor { - public: - /** - * Destructor - */ - virtual ~BucketVisitor(); - - /** - * Visit bucket - * - * @return none - * @param[in] buffer Constant pointer to bucket data buffer - * @param[in] bufferSize Number of bytes in bucket - */ - virtual void OnVisitBucket(const void *buffer, size_t bufferSize) = 0; - }; + class Exception { + public: + DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, OutOfData) + }; + + typedef void (*BufferDeleter)(const void *buffer, size_t bufferSize, + void *userParam); + static void BufferDeleterFree(const void *buffer, + size_t bufferSize, + void *userParam); + + class BucketVisitor { + public: + /** + * Destructor + */ + virtual ~BucketVisitor(); + + /** + * Visit bucket + * + * @return none + * @param[in] buffer Constant pointer to bucket data buffer + * @param[in] bufferSize Number of bytes in bucket + */ + virtual void OnVisitBucket(const void *buffer, size_t bufferSize) = 0; + }; private: - struct Bucket : private Noncopyable { - const void *buffer; - const void *ptr; - size_t size; - size_t left; + struct Bucket : private Noncopyable { + const void *buffer; + const void *ptr; + size_t size; + size_t left; - BufferDeleter deleter; - void *param; + BufferDeleter deleter; + void *param; - Bucket(const void *buffer, - size_t bufferSize, - BufferDeleter deleter, - void *userParam); - virtual ~Bucket(); - }; + Bucket(const void *buffer, + size_t bufferSize, + BufferDeleter deleter, + void *userParam); + virtual ~Bucket(); + }; - typedef std::list BucketList; - BucketList m_buckets; - size_t m_size; + typedef std::list BucketList; + BucketList m_buckets; + size_t m_size; - static void DeleteBucket(Bucket *bucket); + static void DeleteBucket(Bucket *bucket); - class BucketVisitorCall { - private: - BucketVisitor *m_visitor; + class BucketVisitorCall { + private: + BucketVisitor *m_visitor; - public: - BucketVisitorCall(BucketVisitor *visitor); - virtual ~BucketVisitorCall(); + public: + BucketVisitorCall(BucketVisitor *visitor); + virtual ~BucketVisitorCall(); - void operator()(Bucket *bucket) const; - }; + void operator()(Bucket *bucket) const; + }; public: - /** - * Construct empty binary queue - */ - BinaryQueue(); - - /** - * Construct binary queue via bare copy of other binary queue - * - * @param[in] other Other binary queue to copy from - * @warning One cannot assume that bucket structure is preserved during copy - */ - BinaryQueue(const BinaryQueue &other); - - /** - * Destructor - */ - virtual ~BinaryQueue(); - - /** - * Construct binary queue via bare copy of other binary queue - * - * @param[in] other Other binary queue to copy from - * @warning One cannot assume that bucket structure is preserved during copy - */ - const BinaryQueue &operator=(const BinaryQueue &other); - - /** - * Append copy of @a bufferSize bytes from memory pointed by @a buffer - * to the end of binary queue. Uses default deleter based on free. - * - * @return none - * @param[in] buffer Pointer to buffer to copy data from - * @param[in] bufferSize Number of bytes to copy - * @exception std::bad_alloc Cannot allocate memory to hold additional data - * @see BinaryQueue::BufferDeleterFree - */ - void AppendCopy(const void *buffer, size_t bufferSize); - - /** - * Append @a bufferSize bytes from memory pointed by @a buffer - * to the end of binary queue. Uses custom provided deleter. - * Responsibility for deleting provided buffer is transfered to BinaryQueue. - * - * @return none - * @param[in] buffer Pointer to data buffer - * @param[in] bufferSize Number of bytes available in buffer - * @param[in] deleter Pointer to deleter procedure used to free provided - * buffer - * @param[in] userParam User parameter passed to deleter routine - * @exception std::bad_alloc Cannot allocate memory to hold additional data - */ - void AppendUnmanaged( - const void *buffer, - size_t bufferSize, - BufferDeleter deleter = - &BinaryQueue::BufferDeleterFree, - void *userParam = NULL); - - /** - * Append copy of other binary queue to the end of this binary queue - * - * @return none - * @param[in] other Constant reference to other binary queue to copy data - * from - * @exception std::bad_alloc Cannot allocate memory to hold additional data - * @warning One cannot assume that bucket structure is preserved during copy - */ - void AppendCopyFrom(const BinaryQueue &other); - - /** - * Move bytes from other binary queue to the end of this binary queue. - * This also removes all bytes from other binary queue. - * This method is designed to be as fast as possible (only pointer swaps) - * and is suggested over making copies of binary queues. - * Bucket structure is preserved after operation. - * - * @return none - * @param[in] other Reference to other binary queue to move data from - * @exception std::bad_alloc Cannot allocate memory to hold additional data - */ - void AppendMoveFrom(BinaryQueue &other); - - /** - * Append copy of binary queue to the end of other binary queue - * - * @return none - * @param[in] other Constant reference to other binary queue to copy data to - * @exception std::bad_alloc Cannot allocate memory to hold additional data - * @warning One cannot assume that bucket structure is preserved during copy - */ - void AppendCopyTo(BinaryQueue &other) const; - - /** - * Move bytes from binary queue to the end of other binary queue. - * This also removes all bytes from binary queue. - * This method is designed to be as fast as possible (only pointer swaps) - * and is suggested over making copies of binary queues. - * Bucket structure is preserved after operation. - * - * @return none - * @param[in] other Reference to other binary queue to move data to - * @exception std::bad_alloc Cannot allocate memory to hold additional data - */ - void AppendMoveTo(BinaryQueue &other); - - /** - * Retrieve total size of all data contained in binary queue - * - * @return Number of bytes in binary queue - */ - size_t Size() const; - - /** - * Remove all data from binary queue - * - * @return none - */ - void Clear(); - - /** - * Check if binary queue is empty - * - * @return true if binary queue is empty, false otherwise - */ - bool Empty() const; - - /** - * Remove @a size bytes from beginning of binary queue - * - * @return none - * @param[in] size Number of bytes to remove - * @exception BinaryQueue::Exception::OutOfData Number of bytes is larger - * than available bytes in binary queue - */ - void Consume(size_t size); - - /** - * Retrieve @a bufferSize bytes from beginning of binary queue and copy them - * to user supplied buffer - * - * @return none - * @param[in] buffer Pointer to user buffer to receive bytes - * @param[in] bufferSize Size of user buffer pointed by @a buffer - * @exception BinaryQueue::Exception::OutOfData Number of bytes to flatten - * is larger than available bytes in binary queue - */ - void Flatten(void *buffer, size_t bufferSize) const; - - /** - * Retrieve @a bufferSize bytes from beginning of binary queue, copy them - * to user supplied buffer, and remove from binary queue - * - * @return none - * @param[in] buffer Pointer to user buffer to receive bytes - * @param[in] bufferSize Size of user buffer pointed by @a buffer - * @exception BinaryQueue::Exception::OutOfData Number of bytes to flatten - * is larger than available bytes in binary queue - */ - void FlattenConsume(void *buffer, size_t bufferSize); - - /** - * Visit each buffer with data using visitor object - * - * @return none - * @param[in] visitor Pointer to bucket visitor - * @see BinaryQueue::BucketVisitor - */ - void VisitBuckets(BucketVisitor *visitor) const; - - /** - * IAbstractInput interface - */ - virtual BinaryQueueAutoPtr Read(size_t size); - - /** - * IAbstractOutput interface - */ - virtual size_t Write(const BinaryQueue &buffer, size_t bufferSize); + /** + * Construct empty binary queue + */ + BinaryQueue(); + + /** + * Construct binary queue via bare copy of other binary queue + * + * @param[in] other Other binary queue to copy from + * @warning One cannot assume that bucket structure is preserved during copy + */ + BinaryQueue(const BinaryQueue &other); + + /** + * Destructor + */ + virtual ~BinaryQueue(); + + /** + * Construct binary queue via bare copy of other binary queue + * + * @param[in] other Other binary queue to copy from + * @warning One cannot assume that bucket structure is preserved during copy + */ + const BinaryQueue &operator=(const BinaryQueue &other); + + /** + * Append copy of @a bufferSize bytes from memory pointed by @a buffer + * to the end of binary queue. Uses default deleter based on free. + * + * @return none + * @param[in] buffer Pointer to buffer to copy data from + * @param[in] bufferSize Number of bytes to copy + * @exception std::bad_alloc Cannot allocate memory to hold additional data + * @see BinaryQueue::BufferDeleterFree + */ + void AppendCopy(const void *buffer, size_t bufferSize); + + /** + * Append @a bufferSize bytes from memory pointed by @a buffer + * to the end of binary queue. Uses custom provided deleter. + * Responsibility for deleting provided buffer is transfered to BinaryQueue. + * + * @return none + * @param[in] buffer Pointer to data buffer + * @param[in] bufferSize Number of bytes available in buffer + * @param[in] deleter Pointer to deleter procedure used to free provided + * buffer + * @param[in] userParam User parameter passed to deleter routine + * @exception std::bad_alloc Cannot allocate memory to hold additional data + */ + void AppendUnmanaged( + const void *buffer, + size_t bufferSize, + BufferDeleter deleter = + &BinaryQueue::BufferDeleterFree, + void *userParam = NULL); + + /** + * Append copy of other binary queue to the end of this binary queue + * + * @return none + * @param[in] other Constant reference to other binary queue to copy data + * from + * @exception std::bad_alloc Cannot allocate memory to hold additional data + * @warning One cannot assume that bucket structure is preserved during copy + */ + void AppendCopyFrom(const BinaryQueue &other); + + /** + * Move bytes from other binary queue to the end of this binary queue. + * This also removes all bytes from other binary queue. + * This method is designed to be as fast as possible (only pointer swaps) + * and is suggested over making copies of binary queues. + * Bucket structure is preserved after operation. + * + * @return none + * @param[in] other Reference to other binary queue to move data from + * @exception std::bad_alloc Cannot allocate memory to hold additional data + */ + void AppendMoveFrom(BinaryQueue &other); + + /** + * Append copy of binary queue to the end of other binary queue + * + * @return none + * @param[in] other Constant reference to other binary queue to copy data to + * @exception std::bad_alloc Cannot allocate memory to hold additional data + * @warning One cannot assume that bucket structure is preserved during copy + */ + void AppendCopyTo(BinaryQueue &other) const; + + /** + * Move bytes from binary queue to the end of other binary queue. + * This also removes all bytes from binary queue. + * This method is designed to be as fast as possible (only pointer swaps) + * and is suggested over making copies of binary queues. + * Bucket structure is preserved after operation. + * + * @return none + * @param[in] other Reference to other binary queue to move data to + * @exception std::bad_alloc Cannot allocate memory to hold additional data + */ + void AppendMoveTo(BinaryQueue &other); + + /** + * Retrieve total size of all data contained in binary queue + * + * @return Number of bytes in binary queue + */ + size_t Size() const; + + /** + * Remove all data from binary queue + * + * @return none + */ + void Clear(); + + /** + * Check if binary queue is empty + * + * @return true if binary queue is empty, false otherwise + */ + bool Empty() const; + + /** + * Remove @a size bytes from beginning of binary queue + * + * @return none + * @param[in] size Number of bytes to remove + * @exception BinaryQueue::Exception::OutOfData Number of bytes is larger + * than available bytes in binary queue + */ + void Consume(size_t size); + + /** + * Retrieve @a bufferSize bytes from beginning of binary queue and copy them + * to user supplied buffer + * + * @return none + * @param[in] buffer Pointer to user buffer to receive bytes + * @param[in] bufferSize Size of user buffer pointed by @a buffer + * @exception BinaryQueue::Exception::OutOfData Number of bytes to flatten + * is larger than available bytes in binary queue + */ + void Flatten(void *buffer, size_t bufferSize) const; + + /** + * Retrieve @a bufferSize bytes from beginning of binary queue, copy them + * to user supplied buffer, and remove from binary queue + * + * @return none + * @param[in] buffer Pointer to user buffer to receive bytes + * @param[in] bufferSize Size of user buffer pointed by @a buffer + * @exception BinaryQueue::Exception::OutOfData Number of bytes to flatten + * is larger than available bytes in binary queue + */ + void FlattenConsume(void *buffer, size_t bufferSize); + + /** + * Visit each buffer with data using visitor object + * + * @return none + * @param[in] visitor Pointer to bucket visitor + * @see BinaryQueue::BucketVisitor + */ + void VisitBuckets(BucketVisitor *visitor) const; + + /** + * IAbstractInput interface + */ + virtual BinaryQueueAutoPtr Read(size_t size); + + /** + * IAbstractOutput interface + */ + virtual size_t Write(const BinaryQueue &buffer, size_t bufferSize); }; } // namespace AuthPasswd diff --git a/src/dpl/core/include/dpl/colors.h b/src/dpl/core/include/dpl/colors.h index 400647e..a65b6f7 100644 --- a/src/dpl/core/include/dpl/colors.h +++ b/src/dpl/core/include/dpl/colors.h @@ -27,45 +27,45 @@ namespace AuthPasswd { namespace Colors { namespace Text { -extern const char* BOLD_GREEN_BEGIN; -extern const char* BOLD_GREEN_END; -extern const char* PURPLE_BEGIN; -extern const char* PURPLE_END; -extern const char* RED_BEGIN; -extern const char* RED_END; -extern const char* GREEN_BEGIN; -extern const char* GREEN_END; -extern const char* CYAN_BEGIN; -extern const char* CYAN_END; -extern const char* BOLD_RED_BEGIN; -extern const char* BOLD_RED_END; -extern const char* BOLD_YELLOW_BEGIN; -extern const char* BOLD_YELLOW_END; -extern const char* BOLD_GOLD_BEGIN; -extern const char* BOLD_GOLD_END; -extern const char* BOLD_WHITE_BEGIN; -extern const char* BOLD_WHITE_END; +extern const char *BOLD_GREEN_BEGIN; +extern const char *BOLD_GREEN_END; +extern const char *PURPLE_BEGIN; +extern const char *PURPLE_END; +extern const char *RED_BEGIN; +extern const char *RED_END; +extern const char *GREEN_BEGIN; +extern const char *GREEN_END; +extern const char *CYAN_BEGIN; +extern const char *CYAN_END; +extern const char *BOLD_RED_BEGIN; +extern const char *BOLD_RED_END; +extern const char *BOLD_YELLOW_BEGIN; +extern const char *BOLD_YELLOW_END; +extern const char *BOLD_GOLD_BEGIN; +extern const char *BOLD_GOLD_END; +extern const char *BOLD_WHITE_BEGIN; +extern const char *BOLD_WHITE_END; } //namespace Text namespace Html { -extern const char* BOLD_GREEN_BEGIN; -extern const char* BOLD_GREEN_END; -extern const char* PURPLE_BEGIN; -extern const char* PURPLE_END; -extern const char* RED_BEGIN; -extern const char* RED_END; -extern const char* GREEN_BEGIN; -extern const char* GREEN_END; -extern const char* CYAN_BEGIN; -extern const char* CYAN_END; -extern const char* BOLD_RED_BEGIN; -extern const char* BOLD_RED_END; -extern const char* BOLD_YELLOW_BEGIN; -extern const char* BOLD_YELLOW_END; -extern const char* BOLD_GOLD_BEGIN; -extern const char* BOLD_GOLD_END; -extern const char* BOLD_WHITE_BEGIN; -extern const char* BOLD_WHITE_END; +extern const char *BOLD_GREEN_BEGIN; +extern const char *BOLD_GREEN_END; +extern const char *PURPLE_BEGIN; +extern const char *PURPLE_END; +extern const char *RED_BEGIN; +extern const char *RED_END; +extern const char *GREEN_BEGIN; +extern const char *GREEN_END; +extern const char *CYAN_BEGIN; +extern const char *CYAN_END; +extern const char *BOLD_RED_BEGIN; +extern const char *BOLD_RED_END; +extern const char *BOLD_YELLOW_BEGIN; +extern const char *BOLD_YELLOW_END; +extern const char *BOLD_GOLD_BEGIN; +extern const char *BOLD_GOLD_END; +extern const char *BOLD_WHITE_BEGIN; +extern const char *BOLD_WHITE_END; } //namespace Html } //namespace Colors } //namespace AuthPasswd diff --git a/src/dpl/core/include/dpl/exception.h b/src/dpl/core/include/dpl/exception.h index 6d88659..b586276 100644 --- a/src/dpl/core/include/dpl/exception.h +++ b/src/dpl/core/include/dpl/exception.h @@ -34,259 +34,222 @@ namespace AuthPasswd { void LogUnhandledException(const std::string &str); void LogUnhandledException(const std::string &str, - const char *filename, - int line, - const char *function); + const char *filename, + int line, + const char *function); } namespace AuthPasswd { class COMMON_API Exception { private: - static unsigned int m_exceptionCount; - static Exception* m_lastException; - static void (*m_terminateHandler)(); - - static void AddRef(Exception* exception) - { - if (!m_exceptionCount) { - m_terminateHandler = std::set_terminate(&TerminateHandler); - } - - ++m_exceptionCount; - m_lastException = exception; - } - - static void UnRef(Exception* e) - { - if (m_lastException == e) { - m_lastException = NULL; - } - - --m_exceptionCount; - - if (!m_exceptionCount) { - std::set_terminate(m_terminateHandler); - m_terminateHandler = NULL; - } - } - - static void TerminateHandler() - { - if (m_lastException != NULL) { - DisplayKnownException(*m_lastException); - abort(); - } else { - DisplayUnknownException(); - abort(); - } - } - - Exception *m_reason; - std::string m_path; - std::string m_function; - int m_line; + static unsigned int m_exceptionCount; + static Exception *m_lastException; + static void (*m_terminateHandler)(); + + static void AddRef(Exception *exception) { + if (!m_exceptionCount) + m_terminateHandler = std::set_terminate(&TerminateHandler); + + ++m_exceptionCount; + m_lastException = exception; + } + + static void UnRef(Exception *e) { + if (m_lastException == e) + m_lastException = NULL; + + --m_exceptionCount; + + if (!m_exceptionCount) { + std::set_terminate(m_terminateHandler); + m_terminateHandler = NULL; + } + } + + static void TerminateHandler() { + if (m_lastException != NULL) { + DisplayKnownException(*m_lastException); + abort(); + } else { + DisplayUnknownException(); + abort(); + } + } + + Exception *m_reason; + std::string m_path; + std::string m_function; + int m_line; protected: - std::string m_message; - std::string m_className; + std::string m_message; + std::string m_className; public: - static std::string KnownExceptionToString(const Exception &e) - { - std::ostringstream message; - message << - "\033[1;5;31m\n=== Unhandled AuthPasswd exception occurred ===\033[m\n\n"; - message << "\033[1;33mException trace:\033[m\n\n"; - message << e.DumpToString(); - message << "\033[1;31m\n=== Will now abort ===\033[m\n"; - - return message.str(); - } - - static std::string UnknownExceptionToString() - { - std::ostringstream message; - message << - "\033[1;5;31m\n=== Unhandled non-AuthPasswd exception occurred ===\033[m\n\n"; - message << "\033[1;31m\n=== Will now abort ===\033[m\n"; - - return message.str(); - } - - static void DisplayKnownException(const Exception& e) - { - LogUnhandledException(KnownExceptionToString(e).c_str()); - } - - static void DisplayUnknownException() - { - LogUnhandledException(UnknownExceptionToString().c_str()); - } - - Exception(const Exception &other) - { - // Deep copy - if (other.m_reason != NULL) { - m_reason = new Exception(*other.m_reason); - } else { - m_reason = NULL; - } - - m_message = other.m_message; - m_path = other.m_path; - m_function = other.m_function; - m_line = other.m_line; - - m_className = other.m_className; - - AddRef(this); - } - - const Exception &operator =(const Exception &other) - { - if (this == &other) { - return *this; - } - - // Deep copy - if (other.m_reason != NULL) { - m_reason = new Exception(*other.m_reason); - } else { - m_reason = NULL; - } - - m_message = other.m_message; - m_path = other.m_path; - m_function = other.m_function; - m_line = other.m_line; - - m_className = other.m_className; - - AddRef(this); - - return *this; - } - - Exception(const char *path, - const char *function, - int line, - const std::string &message) : - m_reason(NULL), - m_path(path), - m_function(function), - m_line(line), - m_message(message) - { - AddRef(this); - } - - Exception(const char *path, - const char *function, - int line, - const Exception &reason, - const std::string &message) : - m_reason(new Exception(reason)), - m_path(path), - m_function(function), - m_line(line), - m_message(message) - { - AddRef(this); - } - - virtual ~Exception() throw() - { - if (m_reason != NULL) { - delete m_reason; - m_reason = NULL; - } - - UnRef(this); - } - - void Dump() const - { - // Show reason first - if (m_reason != NULL) { - m_reason->Dump(); - } - - // Afterward, dump exception - const char *file = strchr(m_path.c_str(), '/'); - - if (file == NULL) { - file = m_path.c_str(); - } else { - ++file; - } - - printf("\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n", - file, m_line, - m_function.c_str(), - m_className.c_str(), - m_message.empty() ? "" : m_message.c_str()); - } - - std::string DumpToString() const - { - std::string ret; - if (m_reason != NULL) { - ret = m_reason->DumpToString(); - } - - const char *file = strchr(m_path.c_str(), '/'); - - if (file == NULL) { - file = m_path.c_str(); - } else { - ++file; - } - - char buf[1024]; - snprintf(buf, - sizeof(buf), - "\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n", - file, - m_line, - m_function.c_str(), - m_className.c_str(), - m_message.empty() ? "" : m_message.c_str()); - - buf[sizeof(buf) - 1] = '\n'; - ret += buf; - - return ret; - } - - Exception *GetReason() const - { - return m_reason; - } - - std::string GetPath() const - { - return m_path; - } - - std::string GetFunction() const - { - return m_function; - } - - int GetLine() const - { - return m_line; - } - - std::string GetMessage() const - { - return m_message; - } - - std::string GetClassName() const - { - return m_className; - } + static std::string KnownExceptionToString(const Exception &e) { + std::ostringstream message; + message << + "\033[1;5;31m\n=== Unhandled AuthPasswd exception occurred ===\033[m\n\n"; + message << "\033[1;33mException trace:\033[m\n\n"; + message << e.DumpToString(); + message << "\033[1;31m\n=== Will now abort ===\033[m\n"; + return message.str(); + } + + static std::string UnknownExceptionToString() { + std::ostringstream message; + message << + "\033[1;5;31m\n=== Unhandled non-AuthPasswd exception occurred ===\033[m\n\n"; + message << "\033[1;31m\n=== Will now abort ===\033[m\n"; + return message.str(); + } + + static void DisplayKnownException(const Exception &e) { + LogUnhandledException(KnownExceptionToString(e).c_str()); + } + + static void DisplayUnknownException() { + LogUnhandledException(UnknownExceptionToString().c_str()); + } + + Exception(const Exception &other) { + // Deep copy + if (other.m_reason != NULL) + m_reason = new Exception(*other.m_reason); + else + m_reason = NULL; + + m_message = other.m_message; + m_path = other.m_path; + m_function = other.m_function; + m_line = other.m_line; + m_className = other.m_className; + AddRef(this); + } + + const Exception &operator =(const Exception &other) { + if (this == &other) + return *this; + + // Deep copy + if (other.m_reason != NULL) + m_reason = new Exception(*other.m_reason); + else + m_reason = NULL; + + m_message = other.m_message; + m_path = other.m_path; + m_function = other.m_function; + m_line = other.m_line; + m_className = other.m_className; + AddRef(this); + return *this; + } + + Exception(const char *path, + const char *function, + int line, + const std::string &message) : + m_reason(NULL), + m_path(path), + m_function(function), + m_line(line), + m_message(message) { + AddRef(this); + } + + Exception(const char *path, + const char *function, + int line, + const Exception &reason, + const std::string &message) : + m_reason(new Exception(reason)), + m_path(path), + m_function(function), + m_line(line), + m_message(message) { + AddRef(this); + } + + virtual ~Exception() throw() { + if (m_reason != NULL) { + delete m_reason; + m_reason = NULL; + } + + UnRef(this); + } + + void Dump() const { + // Show reason first + if (m_reason != NULL) + m_reason->Dump(); + + // Afterward, dump exception + const char *file = strchr(m_path.c_str(), '/'); + + if (file == NULL) + file = m_path.c_str(); + else + ++file; + + printf("\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n", + file, m_line, + m_function.c_str(), + m_className.c_str(), + m_message.empty() ? "" : m_message.c_str()); + } + + std::string DumpToString() const { + std::string ret; + + if (m_reason != NULL) + ret = m_reason->DumpToString(); + + const char *file = strchr(m_path.c_str(), '/'); + + if (file == NULL) + file = m_path.c_str(); + else + ++file; + + char buf[1024]; + snprintf(buf, + sizeof(buf), + "\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n", + file, + m_line, + m_function.c_str(), + m_className.c_str(), + m_message.empty() ? "" : m_message.c_str()); + buf[sizeof(buf) - 1] = '\n'; + ret += buf; + return ret; + } + + Exception *GetReason() const { + return m_reason; + } + + std::string GetPath() const { + return m_path; + } + + std::string GetFunction() const { + return m_function; + } + + int GetLine() const { + return m_line; + } + + std::string GetMessage() const { + return m_message; + } + + std::string GetClassName() const { + return m_className; + } }; } // namespace AuthPasswd @@ -294,80 +257,69 @@ public: #define Try try #define Throw(ClassName) \ - throw ClassName(__FILE__, __FUNCTION__, __LINE__) + throw ClassName(__FILE__, __FUNCTION__, __LINE__) -#define ThrowMsg(ClassName, Message) \ - do \ - { \ - std::ostringstream dplLoggingStream; \ - dplLoggingStream << Message; \ - throw ClassName(__FILE__, __FUNCTION__, __LINE__, dplLoggingStream.str()); \ - } while (0) +#define ThrowMsg(ClassName, Message) \ + do { \ + std::ostringstream dplLoggingStream; \ + dplLoggingStream << Message; \ + throw ClassName(__FILE__, __FUNCTION__, __LINE__, dplLoggingStream.str()); \ + } while (0) #define ReThrow(ClassName) \ - throw ClassName(__FILE__, __FUNCTION__, __LINE__, _rethrown_exception) + throw ClassName(__FILE__, __FUNCTION__, __LINE__, _rethrown_exception) -#define ReThrowMsg(ClassName, Message) \ - throw ClassName(__FILE__, \ - __FUNCTION__, \ - __LINE__, \ - _rethrown_exception, \ - Message) +#define ReThrowMsg(ClassName, Message) \ + throw ClassName(__FILE__, \ + __FUNCTION__, \ + __LINE__, \ + _rethrown_exception, \ + Message) #define Catch(ClassName) \ - catch (const ClassName &_rethrown_exception) - -#define DECLARE_EXCEPTION_TYPE(BaseClass, Class) \ - class Class : \ - public BaseClass \ - { \ - public: \ - Class(const char *path, \ - const char *function, \ - int line, \ - const std::string & message = std::string()) : \ - BaseClass(path, function, line, message) \ - { \ - BaseClass::m_className = #Class; \ - } \ - \ - Class(const char *path, \ - const char *function, \ - int line, \ - const AuthPasswd::Exception & reason, \ - const std::string & message = std::string()) : \ - BaseClass(path, function, line, reason, message) \ - { \ - BaseClass::m_className = #Class; \ - } \ - }; + catch (const ClassName &_rethrown_exception) + +#define DECLARE_EXCEPTION_TYPE(BaseClass, Class) \ + class Class : public BaseClass { \ + public: \ + Class(const char *path, \ + const char *function, \ + int line, \ + const std::string & message = std::string()) : \ + BaseClass(path, function, line, message) { \ + BaseClass::m_className = #Class; \ + } \ + Class(const char *path, \ + const char *function, \ + int line, \ + const AuthPasswd::Exception & reason, \ + const std::string & message = std::string()) : \ + BaseClass(path, function, line, reason, message) { \ + BaseClass::m_className = #Class; \ + } \ + }; #define UNHANDLED_EXCEPTION_HANDLER_BEGIN try -#define UNHANDLED_EXCEPTION_HANDLER_END \ - catch (const AuthPasswd::Exception &exception) \ - { \ - std::ostringstream msg; \ - msg << AuthPasswd::Exception::KnownExceptionToString(exception); \ - AuthPasswd::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \ - abort(); \ - } \ - catch (std::exception& e) \ - { \ - std::ostringstream msg; \ - msg << e.what(); \ - msg << "\n"; \ - msg << AuthPasswd::Exception::UnknownExceptionToString(); \ - AuthPasswd::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \ - abort(); \ - } \ - catch (...) \ - { \ - std::ostringstream msg; \ - msg << AuthPasswd::Exception::UnknownExceptionToString(); \ - AuthPasswd::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \ - abort(); \ - } +#define UNHANDLED_EXCEPTION_HANDLER_END \ + catch (const AuthPasswd::Exception &exception) { \ + std::ostringstream msg; \ + msg << AuthPasswd::Exception::KnownExceptionToString(exception); \ + AuthPasswd::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \ + abort(); \ + } catch (std::exception& e) { \ + std::ostringstream msg; \ + msg << e.what(); \ + msg << "\n"; \ + msg << AuthPasswd::Exception::UnknownExceptionToString(); \ + AuthPasswd::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \ + abort(); \ + } catch (...) { \ + std::ostringstream msg; \ + msg << AuthPasswd::Exception::UnknownExceptionToString(); \ + AuthPasswd::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \ + abort(); \ + } namespace AuthPasswd { namespace CommonException { @@ -379,8 +331,8 @@ namespace CommonException { * important messages. */ DECLARE_EXCEPTION_TYPE(Exception, InternalError) ///< Unexpected error from - // underlying libraries or - // kernel +// underlying libraries or +// kernel } } diff --git a/src/dpl/core/include/dpl/fstream_accessors.h b/src/dpl/core/include/dpl/fstream_accessors.h index ea692bd..e0ff4fa 100644 --- a/src/dpl/core/include/dpl/fstream_accessors.h +++ b/src/dpl/core/include/dpl/fstream_accessors.h @@ -36,11 +36,12 @@ namespace DPL { template class FstreamAccessors : T::__filebuf_type { - typedef FstreamAccessors MyType; + typedef FstreamAccessors MyType; public: - static int GetFd(T &strm) { - return static_cast(strm.rdbuf())->_M_file.fd(); - } + static int GetFd(T &strm) + { + return static_cast(strm.rdbuf())->_M_file.fd(); + } }; } // namespace DPL diff --git a/src/dpl/core/include/dpl/noncopyable.h b/src/dpl/core/include/dpl/noncopyable.h index e2abee7..b4f3415 100644 --- a/src/dpl/core/include/dpl/noncopyable.h +++ b/src/dpl/core/include/dpl/noncopyable.h @@ -25,12 +25,12 @@ namespace AuthPasswd { class Noncopyable { public: - Noncopyable() {} - virtual ~Noncopyable() {} + Noncopyable() {} + virtual ~Noncopyable() {} private: - Noncopyable(const Noncopyable &); - const Noncopyable &operator=(const Noncopyable &); + Noncopyable(const Noncopyable &); + const Noncopyable &operator=(const Noncopyable &); }; } // namespace AuthPasswd diff --git a/src/dpl/core/include/dpl/serialization.h b/src/dpl/core/include/dpl/serialization.h index 02840f1..d078c8d 100644 --- a/src/dpl/core/include/dpl/serialization.h +++ b/src/dpl/core/include/dpl/serialization.h @@ -33,395 +33,346 @@ namespace AuthPasswd { // Abstract data stream buffer class IStream { public: - virtual void Read(size_t num, void * bytes) = 0; - virtual void Write(size_t num, const void * bytes) = 0; - virtual ~IStream(){} + virtual void Read(size_t num, void *bytes) = 0; + virtual void Write(size_t num, const void *bytes) = 0; + virtual ~IStream() {} }; // Serializable interface class ISerializable { public: - ISerializable() {} - ISerializable(IStream&) {} - virtual void Serialize(IStream &) const = 0; - virtual ~ISerializable() {} + ISerializable() {} + ISerializable(IStream &) {} + virtual void Serialize(IStream &) const = 0; + virtual ~ISerializable() {} }; struct Serialization { - // serialization - // normal functions - - // ISerializable objects - static void Serialize(IStream& stream, const ISerializable& object) - { - object.Serialize(stream); - } - static void Serialize(IStream& stream, const ISerializable* const object) - { - object->Serialize(stream); - } - - // char - static void Serialize(IStream& stream, const char value) - { - stream.Write(sizeof(value), &value); - } - static void Serialize(IStream& stream, const char* const value) - { - stream.Write(sizeof(*value), value); - } - - // unsigned char - static void Serialize(IStream& stream, const unsigned char value) - { - stream.Write(sizeof(value), &value); - } - static void Serialize(IStream& stream, const unsigned char* const value) - { - stream.Write(sizeof(*value), value); - } - - // unsigned int - static void Serialize(IStream& stream, const unsigned value) - { - stream.Write(sizeof(value), &value); - } - static void Serialize(IStream& stream, const unsigned* const value) - { - stream.Write(sizeof(*value), value); - } - - // int - static void Serialize(IStream& stream, const int value) - { - stream.Write(sizeof(value), &value); - } - static void Serialize(IStream& stream, const int* const value) - { - stream.Write(sizeof(*value), value); - } - - // bool - static void Serialize(IStream& stream, const bool value) - { - stream.Write(sizeof(value), &value); - } - static void Serialize(IStream& stream, const bool* const value) - { - stream.Write(sizeof(*value), value); - } - - // time_t - static void Serialize(IStream& stream, const time_t value) - { - stream.Write(sizeof(value), &value); - } - static void Serialize(IStream& stream, const time_t* const value) - { - stream.Write(sizeof(*value), value); - } - - // std::string - static void Serialize(IStream& stream, const std::string& str) - { - int length = str.size(); - stream.Write(sizeof(length), &length); - stream.Write(length, str.c_str()); - } - static void Serialize(IStream& stream, const std::string* const str) - { - int length = str->size(); - stream.Write(sizeof(length), &length); - stream.Write(length, str->c_str()); - } - - // STL templates - - // std::list - template - static void Serialize(IStream& stream, const std::list& list) - { - int length = list.size(); - stream.Write(sizeof(length), &length); - for (typename std::list::const_iterator list_iter = list.begin(); - list_iter != list.end(); list_iter++) - { - Serialize(stream, *list_iter); - } - } - template - static void Serialize(IStream& stream, const std::list* const list) - { - Serialize(stream, *list); - } - - // std::vector - template - static void Serialize(IStream& stream, const std::vector& vec) - { - int length = vec.size(); - stream.Write(sizeof(length), &length); - for (typename std::vector::const_iterator vec_iter = vec.begin(); - vec_iter != vec.end(); vec_iter++) - { - Serialize(stream, *vec_iter); - } - } - template - static void Serialize(IStream& stream, const std::vector* const vec) - { - Serialize(stream, *vec); - } - - // std::set - template - static void Serialize(IStream& stream, const std::set& set) - { - size_t length = set.size(); - stream.Write(sizeof(length), &length); - for (const auto &item : set) { - Serialize(stream, item); - } - } - - // std::pair - template - static void Serialize(IStream& stream, const std::pair& p) - { - Serialize(stream, p.first); - Serialize(stream, p.second); - } - template - static void Serialize(IStream& stream, const std::pair* const p) - { - Serialize(stream, *p); - } - - // std::map - template - static void Serialize(IStream& stream, const std::map& map) - { - int length = map.size(); - stream.Write(sizeof(length), &length); - typename std::map::const_iterator it; - for (it = map.begin(); it != map.end(); ++it) { - Serialize(stream, (*it).first); - Serialize(stream, (*it).second); - } - } - template - static void Serialize(IStream& stream, const std::map* const map) - { - Serialize(stream, *map); - } - - // std::unique_ptr - template - static void Serialize(IStream& stream, const std::unique_ptr& p) - { - Serialize(stream, *p); - } - - // std::shared_ptr - template - static void Serialize(IStream& stream, const std::shared_ptr& p) - { - Serialize(stream, *p); - } + // serialization + // normal functions + + // ISerializable objects + static void Serialize(IStream &stream, const ISerializable &object) { + object.Serialize(stream); + } + static void Serialize(IStream &stream, const ISerializable *const object) { + object->Serialize(stream); + } + + // char + static void Serialize(IStream &stream, const char value) { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream &stream, const char *const value) { + stream.Write(sizeof(*value), value); + } + + // unsigned char + static void Serialize(IStream &stream, const unsigned char value) { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream &stream, const unsigned char *const value) { + stream.Write(sizeof(*value), value); + } + + // unsigned int + static void Serialize(IStream &stream, const unsigned value) { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream &stream, const unsigned *const value) { + stream.Write(sizeof(*value), value); + } + + // int + static void Serialize(IStream &stream, const int value) { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream &stream, const int *const value) { + stream.Write(sizeof(*value), value); + } + + // bool + static void Serialize(IStream &stream, const bool value) { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream &stream, const bool *const value) { + stream.Write(sizeof(*value), value); + } + + // time_t + static void Serialize(IStream &stream, const time_t value) { + stream.Write(sizeof(value), &value); + } + static void Serialize(IStream &stream, const time_t *const value) { + stream.Write(sizeof(*value), value); + } + + // std::string + static void Serialize(IStream &stream, const std::string &str) { + int length = str.size(); + stream.Write(sizeof(length), &length); + stream.Write(length, str.c_str()); + } + static void Serialize(IStream &stream, const std::string *const str) { + int length = str->size(); + stream.Write(sizeof(length), &length); + stream.Write(length, str->c_str()); + } + + // STL templates + + // std::list + template + static void Serialize(IStream &stream, const std::list &list) { + int length = list.size(); + stream.Write(sizeof(length), &length); + + for (typename std::list::const_iterator list_iter = list.begin(); + list_iter != list.end(); list_iter++) + Serialize(stream, *list_iter); + } + template + static void Serialize(IStream &stream, const std::list *const list) { + Serialize(stream, *list); + } + + // std::vector + template + static void Serialize(IStream &stream, const std::vector &vec) { + int length = vec.size(); + stream.Write(sizeof(length), &length); + + for (typename std::vector::const_iterator vec_iter = vec.begin(); + vec_iter != vec.end(); vec_iter++) + Serialize(stream, *vec_iter); + } + template + static void Serialize(IStream &stream, const std::vector *const vec) { + Serialize(stream, *vec); + } + + // std::set + template + static void Serialize(IStream &stream, const std::set &set) { + size_t length = set.size(); + stream.Write(sizeof(length), &length); + + for (const auto &item : set) + Serialize(stream, item); + } + + // std::pair + template + static void Serialize(IStream &stream, const std::pair &p) { + Serialize(stream, p.first); + Serialize(stream, p.second); + } + template + static void Serialize(IStream &stream, const std::pair *const p) { + Serialize(stream, *p); + } + + // std::map + template + static void Serialize(IStream &stream, const std::map &map) { + int length = map.size(); + stream.Write(sizeof(length), &length); + typename std::map::const_iterator it; + + for (it = map.begin(); it != map.end(); ++it) { + Serialize(stream, (*it).first); + Serialize(stream, (*it).second); + } + } + template + static void Serialize(IStream &stream, const std::map *const map) { + Serialize(stream, *map); + } + + // std::unique_ptr + template + static void Serialize(IStream &stream, const std::unique_ptr &p) { + Serialize(stream, *p); + } + + // std::shared_ptr + template + static void Serialize(IStream &stream, const std::shared_ptr &p) { + Serialize(stream, *p); + } }; // struct Serialization struct Deserialization { - // deserialization - // normal functions - - // ISerializable objects - // T instead of ISerializable is needed to call proper constructor - template - static void Deserialize(IStream& stream, T& object) - { - object = T(stream); - } - template - static void Deserialize(IStream& stream, T*& object) - { - object = new T(stream); - } - - // char - static void Deserialize(IStream& stream, char& value) - { - stream.Read(sizeof(value), &value); - } - static void Deserialize(IStream& stream, char*& value) - { - value = new char; - stream.Read(sizeof(*value), value); - } - - // unsigned char - static void Deserialize(IStream& stream, unsigned char& value) - { - stream.Read(sizeof(value), &value); - } - static void Deserialize(IStream& stream, unsigned char*& value) - { - value = new unsigned char; - stream.Read(sizeof(*value), value); - } - - // unsigned int - static void Deserialize(IStream& stream, unsigned& value) - { - stream.Read(sizeof(value), &value); - } - static void Deserialize(IStream& stream, unsigned*& value) - { - value = new unsigned; - stream.Read(sizeof(*value), value); - } - - // int - static void Deserialize(IStream& stream, int& value) - { - stream.Read(sizeof(value), &value); - } - static void Deserialize(IStream& stream, int*& value) - { - value = new int; - stream.Read(sizeof(*value), value); - } - - // bool - static void Deserialize(IStream& stream, bool& value) - { - stream.Read(sizeof(value), &value); - } - static void Deserialize(IStream& stream, bool*& value) - { - value = new bool; - stream.Read(sizeof(*value), value); - } - - // time_t - static void Deserialize(IStream& stream, time_t& value) - { - stream.Read(sizeof(value), &value); - } - static void Deserialize(IStream& stream, time_t*& value) - { - value = new time_t; - stream.Read(sizeof(*value), value); - } - - // std::string - static void Deserialize(IStream& stream, std::string& str) - { - int length; - stream.Read(sizeof(length), &length); - char * buf = new char[length + 1]; - stream.Read(length, buf); - buf[length] = 0; - str = std::string(buf); - delete[] buf; - } - static void Deserialize(IStream& stream, std::string*& str) - { - int length; - stream.Read(sizeof(length), &length); - char * buf = new char[length + 1]; - stream.Read(length, buf); - buf[length] = 0; - str = new std::string(buf); - delete[] buf; - } - - // STL templates - - // std::list - template - static void Deserialize(IStream& stream, std::list& list) - { - int length; - stream.Read(sizeof(length), &length); - for (int i = 0; i < length; ++i) { - T obj; - Deserialize(stream, obj); - list.push_back(std::move(obj)); - } - } - template - static void Deserialize(IStream& stream, std::list*& list) - { - list = new std::list; - Deserialize(stream, *list); - } - - // std::vector - template - static void Deserialize(IStream& stream, std::vector& vec) - { - int length; - stream.Read(sizeof(length), &length); - for (int i = 0; i < length; ++i) { - T obj; - Deserialize(stream, obj); - vec.push_back(std::move(obj)); - } - } - template - static void Deserialize(IStream& stream, std::vector*& vec) - { - vec = new std::vector; - Deserialize(stream, *vec); - } - - // std::set - template - static void Deserialize(IStream& stream, std::set& set) - { - size_t length; - stream.Read(sizeof(length), &length); - for (size_t i = 0; i < length; ++i) { - T obj; - Deserialize(stream, obj); - set.insert(std::move(obj)); - } - } - - // std::pair - template - static void Deserialize(IStream& stream, std::pair& p) - { - Deserialize(stream, p.first); - Deserialize(stream, p.second); - } - template - static void Deserialize(IStream& stream, std::pair*& p) - { - p = new std::pair; - Deserialize(stream, *p); - } - - // std::map - template - static void Deserialize(IStream& stream, std::map& map) - { - int length; - stream.Read(sizeof(length), &length); - for (int i = 0; i < length; ++i) { - K key; - T obj; - Deserialize(stream, key); - Deserialize(stream, obj); - map[key] = std::move(obj); - } - } - template - static void Deserialize(IStream& stream, std::map*& map) - { - map = new std::map; - Deserialize(stream, *map); - } + // deserialization + // normal functions + + // ISerializable objects + // T instead of ISerializable is needed to call proper constructor + template + static void Deserialize(IStream &stream, T &object) { + object = T(stream); + } + template + static void Deserialize(IStream &stream, T *&object) { + object = new T(stream); + } + + // char + static void Deserialize(IStream &stream, char &value) { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream &stream, char *&value) { + value = new char; + stream.Read(sizeof(*value), value); + } + + // unsigned char + static void Deserialize(IStream &stream, unsigned char &value) { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream &stream, unsigned char *&value) { + value = new unsigned char; + stream.Read(sizeof(*value), value); + } + + // unsigned int + static void Deserialize(IStream &stream, unsigned &value) { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream &stream, unsigned *&value) { + value = new unsigned; + stream.Read(sizeof(*value), value); + } + + // int + static void Deserialize(IStream &stream, int &value) { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream &stream, int *&value) { + value = new int; + stream.Read(sizeof(*value), value); + } + + // bool + static void Deserialize(IStream &stream, bool &value) { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream &stream, bool *&value) { + value = new bool; + stream.Read(sizeof(*value), value); + } + + // time_t + static void Deserialize(IStream &stream, time_t &value) { + stream.Read(sizeof(value), &value); + } + static void Deserialize(IStream &stream, time_t *&value) { + value = new time_t; + stream.Read(sizeof(*value), value); + } + + // std::string + static void Deserialize(IStream &stream, std::string &str) { + int length; + stream.Read(sizeof(length), &length); + char *buf = new char[length + 1]; + stream.Read(length, buf); + buf[length] = 0; + str = std::string(buf); + delete[] buf; + } + static void Deserialize(IStream &stream, std::string *&str) { + int length; + stream.Read(sizeof(length), &length); + char *buf = new char[length + 1]; + stream.Read(length, buf); + buf[length] = 0; + str = new std::string(buf); + delete[] buf; + } + + // STL templates + + // std::list + template + static void Deserialize(IStream &stream, std::list &list) { + int length; + stream.Read(sizeof(length), &length); + + for (int i = 0; i < length; ++i) { + T obj; + Deserialize(stream, obj); + list.push_back(std::move(obj)); + } + } + template + static void Deserialize(IStream &stream, std::list *&list) { + list = new std::list; + Deserialize(stream, *list); + } + + // std::vector + template + static void Deserialize(IStream &stream, std::vector &vec) { + int length; + stream.Read(sizeof(length), &length); + + for (int i = 0; i < length; ++i) { + T obj; + Deserialize(stream, obj); + vec.push_back(std::move(obj)); + } + } + template + static void Deserialize(IStream &stream, std::vector *&vec) { + vec = new std::vector; + Deserialize(stream, *vec); + } + + // std::set + template + static void Deserialize(IStream &stream, std::set &set) { + size_t length; + stream.Read(sizeof(length), &length); + + for (size_t i = 0; i < length; ++i) { + T obj; + Deserialize(stream, obj); + set.insert(std::move(obj)); + } + } + + // std::pair + template + static void Deserialize(IStream &stream, std::pair &p) { + Deserialize(stream, p.first); + Deserialize(stream, p.second); + } + template + static void Deserialize(IStream &stream, std::pair *&p) { + p = new std::pair; + Deserialize(stream, *p); + } + + // std::map + template + static void Deserialize(IStream &stream, std::map &map) { + int length; + stream.Read(sizeof(length), &length); + + for (int i = 0; i < length; ++i) { + K key; + T obj; + Deserialize(stream, key); + Deserialize(stream, obj); + map[key] = std::move(obj); + } + } + template + static void Deserialize(IStream &stream, std::map *&map) { + map = new std::map; + Deserialize(stream, *map); + } }; // struct Deserialization } // namespace AuthPasswd diff --git a/src/dpl/core/include/dpl/singleton.h b/src/dpl/core/include/dpl/singleton.h index 2b42513..d3e17bf 100644 --- a/src/dpl/core/include/dpl/singleton.h +++ b/src/dpl/core/include/dpl/singleton.h @@ -25,26 +25,23 @@ namespace AuthPasswd { template class Singleton : - private Class -{ - // - // Note: - // - // To remove posibility of instantiating directly Class, - // make Class' default constructor protected - // + private Class { + // + // Note: + // + // To remove posibility of instantiating directly Class, + // make Class' default constructor protected + // - private: - Singleton() - {} +private: + Singleton() {} - static Singleton &InternalInstance(); + static Singleton &InternalInstance(); - public: - virtual ~Singleton() - {} +public: + virtual ~Singleton() {} - static Class &Instance(); + static Class &Instance(); }; } // namespace AuthPasswd diff --git a/src/dpl/core/include/dpl/singleton_impl.h b/src/dpl/core/include/dpl/singleton_impl.h index 9f2e425..00d2fed 100644 --- a/src/dpl/core/include/dpl/singleton_impl.h +++ b/src/dpl/core/include/dpl/singleton_impl.h @@ -32,22 +32,22 @@ namespace AuthPasswd { template -Singleton& Singleton::InternalInstance() +Singleton &Singleton::InternalInstance() { - static Singleton instance; - return instance; + static Singleton instance; + return instance; } template Class &Singleton::Instance() { - Singleton& instance = Singleton::InternalInstance(); - return instance; + Singleton &instance = Singleton::InternalInstance(); + return instance; } } // namespace AuthPasswd #define IMPLEMENT_SINGLETON(Type) \ - template AuthPasswd::Singleton&AuthPasswd::Singleton::InternalInstance(); \ - template Type & AuthPasswd::Singleton::Instance(); \ + template AuthPasswd::Singleton&AuthPasswd::Singleton::InternalInstance(); \ + template Type & AuthPasswd::Singleton::Instance(); \ #endif // AUTHPASSWD_SINGLETON_IMPL_H diff --git a/src/dpl/core/include/dpl/singleton_safe_impl.h b/src/dpl/core/include/dpl/singleton_safe_impl.h index 3ab2028..c50fbd3 100644 --- a/src/dpl/core/include/dpl/singleton_safe_impl.h +++ b/src/dpl/core/include/dpl/singleton_safe_impl.h @@ -22,24 +22,20 @@ #ifndef AUTHPASSWD_SINGLETON_SAFE_IMPL_H #define AUTHPASSWD_SINGLETON_SAFE_IMPL_H -#define IMPLEMENT_SAFE_SINGLETON(Class) \ - namespace AuthPasswd { \ - template<> \ - Singleton&Singleton::InternalInstance() \ - { \ - static Singleton instance; \ - return instance; \ - } \ - \ - template<> \ - Class & Singleton::Instance() \ - { \ - Singleton& instance = Singleton::InternalInstance(); \ - return instance; \ - } \ - \ - template Singleton&Singleton::InternalInstance(); \ - template Class & Singleton::Instance(); \ - } // namespace AuthPasswd +#define IMPLEMENT_SAFE_SINGLETON(Class) \ + namespace AuthPasswd { \ + template<> \ + Singleton&Singleton::InternalInstance() { \ + static Singleton instance; \ + return instance; \ + } \ + template<> \ + Class & Singleton::Instance() { \ + Singleton& instance = Singleton::InternalInstance(); \ + return instance; \ + } \ + template Singleton&Singleton::InternalInstance(); \ + template Class & Singleton::Instance(); \ + } // namespace AuthPasswd #endif // AUTHPASSWD_SINGLETON_SAFE_IMPL_H diff --git a/src/dpl/core/src/assert.cpp b/src/dpl/core/src/assert.cpp index 2be2309..dfde939 100644 --- a/src/dpl/core/src/assert.cpp +++ b/src/dpl/core/src/assert.cpp @@ -30,41 +30,38 @@ namespace AuthPasswd { COMMON_API void AssertProc(const char *condition, - const char *file, - int line, - const char *function) + const char *file, + int line, + const char *function) { -#define INTERNAL_LOG(message) \ - do \ - { \ - std::ostringstream platformLog; \ - platformLog << message; \ - AuthPasswd::Log::LogSystemSingleton::Instance().Pedantic( \ - platformLog.str().c_str(), \ - __FILE__, __LINE__, __FUNCTION__); \ - } \ - while (0) +#define INTERNAL_LOG(message) \ + do { \ + std::ostringstream platformLog; \ + platformLog << message; \ + AuthPasswd::Log::LogSystemSingleton::Instance().Pedantic( \ + platformLog.str().c_str(), \ + __FILE__, __LINE__, __FUNCTION__); \ + } while (0) - // Try to log failed assertion to log system - Try - { - INTERNAL_LOG( - "################################################################################"); - INTERNAL_LOG( - "### AuthPasswd assertion failed! ###"); - INTERNAL_LOG( - "################################################################################"); - INTERNAL_LOG("### Condition: " << condition); - INTERNAL_LOG("### File: " << file); - INTERNAL_LOG("### Line: " << line); - INTERNAL_LOG("### Function: " << function); - INTERNAL_LOG( - "################################################################################"); - } catch (Exception) { - // Just ignore possible double errors - } + // Try to log failed assertion to log system + Try { + INTERNAL_LOG( + "################################################################################"); + INTERNAL_LOG( + "### AuthPasswd assertion failed! ###"); + INTERNAL_LOG( + "################################################################################"); + INTERNAL_LOG("### Condition: " << condition); + INTERNAL_LOG("### File: " << file); + INTERNAL_LOG("### Line: " << line); + INTERNAL_LOG("### Function: " << function); + INTERNAL_LOG( + "################################################################################"); + } catch (Exception) { + // Just ignore possible double errors + } - // Fail with c-library abort - abort(); + // Fail with c-library abort + abort(); } } // namespace AuthPasswd diff --git a/src/dpl/core/src/binary_queue.cpp b/src/dpl/core/src/binary_queue.cpp index 12277d4..66d9d79 100644 --- a/src/dpl/core/src/binary_queue.cpp +++ b/src/dpl/core/src/binary_queue.cpp @@ -29,245 +29,235 @@ namespace AuthPasswd { BinaryQueue::BinaryQueue() : - m_size(0) + m_size(0) {} BinaryQueue::BinaryQueue(const BinaryQueue &other) : - m_size(0) + m_size(0) { - AppendCopyFrom(other); + AppendCopyFrom(other); } BinaryQueue::~BinaryQueue() { - // Remove all remainig buckets - Clear(); + // Remove all remainig buckets + Clear(); } const BinaryQueue &BinaryQueue::operator=(const BinaryQueue &other) { - if (this != &other) { - Clear(); - AppendCopyFrom(other); - } + if (this != &other) { + Clear(); + AppendCopyFrom(other); + } - return *this; + return *this; } void BinaryQueue::AppendCopyFrom(const BinaryQueue &other) { - // To speed things up, always copy as one bucket - void *bufferCopy = malloc(other.m_size); - - if (bufferCopy == NULL) { - throw std::bad_alloc(); - } - - try { - other.Flatten(bufferCopy, other.m_size); - AppendUnmanaged(bufferCopy, other.m_size, &BufferDeleterFree, NULL); - } catch (const std::bad_alloc &) { - // Free allocated memory - free(bufferCopy); - throw; - } + // To speed things up, always copy as one bucket + void *bufferCopy = malloc(other.m_size); + + if (bufferCopy == NULL) + throw std::bad_alloc(); + + try { + other.Flatten(bufferCopy, other.m_size); + AppendUnmanaged(bufferCopy, other.m_size, &BufferDeleterFree, NULL); + } catch (const std::bad_alloc &) { + // Free allocated memory + free(bufferCopy); + throw; + } } void BinaryQueue::AppendMoveFrom(BinaryQueue &other) { - // Copy all buckets - std::copy(other.m_buckets.begin(), - other.m_buckets.end(), std::back_inserter(m_buckets)); - m_size += other.m_size; - - // Clear other, but do not free memory - other.m_buckets.clear(); - other.m_size = 0; + // Copy all buckets + std::copy(other.m_buckets.begin(), + other.m_buckets.end(), std::back_inserter(m_buckets)); + m_size += other.m_size; + // Clear other, but do not free memory + other.m_buckets.clear(); + other.m_size = 0; } void BinaryQueue::AppendCopyTo(BinaryQueue &other) const { - other.AppendCopyFrom(*this); + other.AppendCopyFrom(*this); } void BinaryQueue::AppendMoveTo(BinaryQueue &other) { - other.AppendMoveFrom(*this); + other.AppendMoveFrom(*this); } void BinaryQueue::Clear() { - std::for_each(m_buckets.begin(), m_buckets.end(), &DeleteBucket); - m_buckets.clear(); - m_size = 0; + std::for_each(m_buckets.begin(), m_buckets.end(), &DeleteBucket); + m_buckets.clear(); + m_size = 0; } -void BinaryQueue::AppendCopy(const void* buffer, size_t bufferSize) +void BinaryQueue::AppendCopy(const void *buffer, size_t bufferSize) { - // Create data copy with malloc/free - void *bufferCopy = malloc(bufferSize); - - // Check if allocation succeded - if (bufferCopy == NULL) { - throw std::bad_alloc(); - } - - // Copy user data - memcpy(bufferCopy, buffer, bufferSize); - - try { - // Try to append new bucket - AppendUnmanaged(bufferCopy, bufferSize, &BufferDeleterFree, NULL); - } catch (const std::bad_alloc &) { - // Free allocated memory - free(bufferCopy); - throw; - } + // Create data copy with malloc/free + void *bufferCopy = malloc(bufferSize); + + // Check if allocation succeded + if (bufferCopy == NULL) + throw std::bad_alloc(); + + // Copy user data + memcpy(bufferCopy, buffer, bufferSize); + + try { + // Try to append new bucket + AppendUnmanaged(bufferCopy, bufferSize, &BufferDeleterFree, NULL); + } catch (const std::bad_alloc &) { + // Free allocated memory + free(bufferCopy); + throw; + } } -void BinaryQueue::AppendUnmanaged(const void* buffer, - size_t bufferSize, - BufferDeleter deleter, - void* userParam) +void BinaryQueue::AppendUnmanaged(const void *buffer, + size_t bufferSize, + BufferDeleter deleter, + void *userParam) { - // Do not attach empty buckets - if (bufferSize == 0) { - deleter(buffer, bufferSize, userParam); - return; - } - - // Just add new bucket with selected deleter - Bucket *bucket = new Bucket(buffer, bufferSize, deleter, userParam); - try { - m_buckets.push_back(bucket); - } catch (const std::bad_alloc &) { - delete bucket; - throw; - } - - // Increase total queue size - m_size += bufferSize; + // Do not attach empty buckets + if (bufferSize == 0) { + deleter(buffer, bufferSize, userParam); + return; + } + + // Just add new bucket with selected deleter + Bucket *bucket = new Bucket(buffer, bufferSize, deleter, userParam); + + try { + m_buckets.push_back(bucket); + } catch (const std::bad_alloc &) { + delete bucket; + throw; + } + + // Increase total queue size + m_size += bufferSize; } size_t BinaryQueue::Size() const { - return m_size; + return m_size; } bool BinaryQueue::Empty() const { - return m_size == 0; + return m_size == 0; } void BinaryQueue::Consume(size_t size) { - // Check parameters - if (size > m_size) { - Throw(Exception::OutOfData); - } - - size_t bytesLeft = size; - - // Consume data and/or remove buckets - while (bytesLeft > 0) { - // Get consume size - size_t count = std::min(bytesLeft, m_buckets.front()->left); - - m_buckets.front()->ptr = - static_cast(m_buckets.front()->ptr) + count; - m_buckets.front()->left -= count; - bytesLeft -= count; - m_size -= count; - - if (m_buckets.front()->left == 0) { - DeleteBucket(m_buckets.front()); - m_buckets.pop_front(); - } - } + // Check parameters + if (size > m_size) + Throw(Exception::OutOfData); + + size_t bytesLeft = size; + + // Consume data and/or remove buckets + while (bytesLeft > 0) { + // Get consume size + size_t count = std::min(bytesLeft, m_buckets.front()->left); + m_buckets.front()->ptr = + static_cast(m_buckets.front()->ptr) + count; + m_buckets.front()->left -= count; + bytesLeft -= count; + m_size -= count; + + if (m_buckets.front()->left == 0) { + DeleteBucket(m_buckets.front()); + m_buckets.pop_front(); + } + } } void BinaryQueue::Flatten(void *buffer, size_t bufferSize) const { - // Check parameters - if (bufferSize == 0) { - return; - } - - if (bufferSize > m_size) { - Throw(Exception::OutOfData); - } - - size_t bytesLeft = bufferSize; - void *ptr = buffer; - BucketList::const_iterator bucketIterator = m_buckets.begin(); - Assert(m_buckets.end() != bucketIterator); - - // Flatten data - while (bytesLeft > 0) { - // Get consume size - size_t count = std::min(bytesLeft, (*bucketIterator)->left); - - // Copy data to user pointer - memcpy(ptr, (*bucketIterator)->ptr, count); - - // Update flattened bytes count - bytesLeft -= count; - ptr = static_cast(ptr) + count; - - // Take next bucket - ++bucketIterator; - } + // Check parameters + if (bufferSize == 0) + return; + + if (bufferSize > m_size) + Throw(Exception::OutOfData); + + size_t bytesLeft = bufferSize; + void *ptr = buffer; + BucketList::const_iterator bucketIterator = m_buckets.begin(); + Assert(m_buckets.end() != bucketIterator); + + // Flatten data + while (bytesLeft > 0) { + // Get consume size + size_t count = std::min(bytesLeft, (*bucketIterator)->left); + // Copy data to user pointer + memcpy(ptr, (*bucketIterator)->ptr, count); + // Update flattened bytes count + bytesLeft -= count; + ptr = static_cast(ptr) + count; + // Take next bucket + ++bucketIterator; + } } void BinaryQueue::FlattenConsume(void *buffer, size_t bufferSize) { - // FIXME: Optimize - Flatten(buffer, bufferSize); - Consume(bufferSize); + // FIXME: Optimize + Flatten(buffer, bufferSize); + Consume(bufferSize); } void BinaryQueue::DeleteBucket(BinaryQueue::Bucket *bucket) { - delete bucket; + delete bucket; } -void BinaryQueue::BufferDeleterFree(const void* data, - size_t dataSize, - void* userParam) +void BinaryQueue::BufferDeleterFree(const void *data, + size_t dataSize, + void *userParam) { - (void)dataSize; - (void)userParam; - - // Default free deleter - free(const_cast(data)); + (void)dataSize; + (void)userParam; + // Default free deleter + free(const_cast(data)); } -BinaryQueue::Bucket::Bucket(const void* data, - size_t dataSize, - BufferDeleter dataDeleter, - void* userParam) : - buffer(data), - ptr(data), - size(dataSize), - left(dataSize), - deleter(dataDeleter), - param(userParam) +BinaryQueue::Bucket::Bucket(const void *data, + size_t dataSize, + BufferDeleter dataDeleter, + void *userParam) : + buffer(data), + ptr(data), + size(dataSize), + left(dataSize), + deleter(dataDeleter), + param(userParam) { - Assert(data != NULL); - Assert(deleter != NULL); + Assert(data != NULL); + Assert(deleter != NULL); } BinaryQueue::Bucket::~Bucket() { - // Invoke deleter on bucket data - deleter(buffer, size, param); + // Invoke deleter on bucket data + deleter(buffer, size, param); } BinaryQueue::BucketVisitor::~BucketVisitor() {} BinaryQueue::BucketVisitorCall::BucketVisitorCall(BucketVisitor *visitor) : - m_visitor(visitor) + m_visitor(visitor) {} BinaryQueue::BucketVisitorCall::~BucketVisitorCall() @@ -275,43 +265,38 @@ BinaryQueue::BucketVisitorCall::~BucketVisitorCall() void BinaryQueue::BucketVisitorCall::operator()(Bucket *bucket) const { - m_visitor->OnVisitBucket(bucket->ptr, bucket->left); + m_visitor->OnVisitBucket(bucket->ptr, bucket->left); } void BinaryQueue::VisitBuckets(BucketVisitor *visitor) const { - Assert(visitor != NULL); - - // Visit all buckets - std::for_each(m_buckets.begin(), m_buckets.end(), BucketVisitorCall(visitor)); + Assert(visitor != NULL); + // Visit all buckets + std::for_each(m_buckets.begin(), m_buckets.end(), BucketVisitorCall(visitor)); } BinaryQueueAutoPtr BinaryQueue::Read(size_t size) { - // Simulate input stream - size_t available = std::min(size, m_size); - - std::unique_ptr> - bufferCopy(malloc(available), free); - - if (!bufferCopy.get()) { - throw std::bad_alloc(); - } - - BinaryQueueAutoPtr result(new BinaryQueue()); - - Flatten(bufferCopy.get(), available); - result->AppendUnmanaged( - bufferCopy.release(), available, &BufferDeleterFree, NULL); - Consume(available); - - return result; + // Simulate input stream + size_t available = std::min(size, m_size); + std::unique_ptr> + bufferCopy(malloc(available), free); + + if (!bufferCopy.get()) + throw std::bad_alloc(); + + BinaryQueueAutoPtr result(new BinaryQueue()); + Flatten(bufferCopy.get(), available); + result->AppendUnmanaged( + bufferCopy.release(), available, &BufferDeleterFree, NULL); + Consume(available); + return result; } size_t BinaryQueue::Write(const BinaryQueue &buffer, size_t bufferSize) { - // Simulate output stream - AppendCopyFrom(buffer); - return bufferSize; + // Simulate output stream + AppendCopyFrom(buffer); + return bufferSize; } } // namespace AuthPasswd diff --git a/src/dpl/core/src/colors.cpp b/src/dpl/core/src/colors.cpp index 083ab37..28ed658 100644 --- a/src/dpl/core/src/colors.cpp +++ b/src/dpl/core/src/colors.cpp @@ -26,45 +26,45 @@ namespace AuthPasswd { namespace Colors { namespace Text { -const char* BOLD_GREEN_BEGIN = "\033[1;32m"; -const char* BOLD_GREEN_END = "\033[m"; -const char* RED_BEGIN = "\033[0;31m"; -const char* RED_END = "\033[m"; -const char* PURPLE_BEGIN = "\033[0;35m"; -const char* PURPLE_END = "\033[m"; -const char* GREEN_BEGIN = "\033[0;32m"; -const char* GREEN_END = "\033[m"; -const char* CYAN_BEGIN = "\033[0;36m"; -const char* CYAN_END = "\033[m"; -const char* BOLD_RED_BEGIN = "\033[1;31m"; -const char* BOLD_RED_END = "\033[m"; -const char* BOLD_YELLOW_BEGIN = "\033[1;33m"; -const char* BOLD_YELLOW_END = "\033[m"; -const char* BOLD_GOLD_BEGIN = "\033[0;33m"; -const char* BOLD_GOLD_END = "\033[m"; -const char* BOLD_WHITE_BEGIN = "\033[1;37m"; -const char* BOLD_WHITE_END = "\033[m"; +const char *BOLD_GREEN_BEGIN = "\033[1;32m"; +const char *BOLD_GREEN_END = "\033[m"; +const char *RED_BEGIN = "\033[0;31m"; +const char *RED_END = "\033[m"; +const char *PURPLE_BEGIN = "\033[0;35m"; +const char *PURPLE_END = "\033[m"; +const char *GREEN_BEGIN = "\033[0;32m"; +const char *GREEN_END = "\033[m"; +const char *CYAN_BEGIN = "\033[0;36m"; +const char *CYAN_END = "\033[m"; +const char *BOLD_RED_BEGIN = "\033[1;31m"; +const char *BOLD_RED_END = "\033[m"; +const char *BOLD_YELLOW_BEGIN = "\033[1;33m"; +const char *BOLD_YELLOW_END = "\033[m"; +const char *BOLD_GOLD_BEGIN = "\033[0;33m"; +const char *BOLD_GOLD_END = "\033[m"; +const char *BOLD_WHITE_BEGIN = "\033[1;37m"; +const char *BOLD_WHITE_END = "\033[m"; } //namespace Text namespace Html { -const char* BOLD_GREEN_BEGIN = ""; -const char* BOLD_GREEN_END = ""; -const char* PURPLE_BEGIN = ""; -const char* PURPLE_END = ""; -const char* RED_BEGIN = ""; -const char* RED_END = ""; -const char* GREEN_BEGIN = ""; -const char* GREEN_END = ""; -const char* CYAN_BEGIN = ""; -const char* CYAN_END = ""; -const char* BOLD_RED_BEGIN = ""; -const char* BOLD_RED_END = ""; -const char* BOLD_YELLOW_BEGIN = ""; -const char* BOLD_YELLOW_END = ""; -const char* BOLD_GOLD_BEGIN = ""; -const char* BOLD_GOLD_END = ""; -const char* BOLD_WHITE_BEGIN = ""; -const char* BOLD_WHITE_END = ""; +const char *BOLD_GREEN_BEGIN = ""; +const char *BOLD_GREEN_END = ""; +const char *PURPLE_BEGIN = ""; +const char *PURPLE_END = ""; +const char *RED_BEGIN = ""; +const char *RED_END = ""; +const char *GREEN_BEGIN = ""; +const char *GREEN_END = ""; +const char *CYAN_BEGIN = ""; +const char *CYAN_END = ""; +const char *BOLD_RED_BEGIN = ""; +const char *BOLD_RED_END = ""; +const char *BOLD_YELLOW_BEGIN = ""; +const char *BOLD_YELLOW_END = ""; +const char *BOLD_GOLD_BEGIN = ""; +const char *BOLD_GOLD_END = ""; +const char *BOLD_WHITE_BEGIN = ""; +const char *BOLD_WHITE_END = ""; } //namespace Html } //namespace Colors } //namespace AuthPasswd diff --git a/src/dpl/core/src/exception.cpp b/src/dpl/core/src/exception.cpp index 78f7ecd..9a4daab 100644 --- a/src/dpl/core/src/exception.cpp +++ b/src/dpl/core/src/exception.cpp @@ -25,35 +25,33 @@ #include namespace AuthPasswd { -Exception* Exception::m_lastException = NULL; +Exception *Exception::m_lastException = NULL; unsigned int Exception::m_exceptionCount = 0; void (*Exception::m_terminateHandler)() = NULL; COMMON_API void LogUnhandledException(const std::string &str) { - // Logging to console - printf("%s\n", str.c_str()); - - // Logging to dlog - LogPedantic(str); + // Logging to console + printf("%s\n", str.c_str()); + // Logging to dlog + LogPedantic(str); } COMMON_API void LogUnhandledException(const std::string &str, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - // Logging to console - std::ostringstream msg; - msg << "\033[1;5;31m\n=== [" << filename << ":" << line << "] " << - function << " ===\033[m"; - msg << str; - printf("%s\n", msg.str().c_str()); - - // Logging to dlog - AuthPasswd::Log::LogSystemSingleton::Instance().Error( - str.c_str(), filename, line, function); + // Logging to console + std::ostringstream msg; + msg << "\033[1;5;31m\n=== [" << filename << ":" << line << "] " << + function << " ===\033[m"; + msg << str; + printf("%s\n", msg.str().c_str()); + // Logging to dlog + AuthPasswd::Log::LogSystemSingleton::Instance().Error( + str.c_str(), filename, line, function); } } // namespace AuthPasswd diff --git a/src/dpl/log/include/dpl/log/abstract_log_provider.h b/src/dpl/log/include/dpl/log/abstract_log_provider.h index 021d705..40e2deb 100644 --- a/src/dpl/log/include/dpl/log/abstract_log_provider.h +++ b/src/dpl/log/include/dpl/log/abstract_log_provider.h @@ -24,52 +24,51 @@ namespace AuthPasswd { namespace Log { -class AbstractLogProvider -{ - public: - virtual ~AbstractLogProvider() {} +class AbstractLogProvider { +public: + virtual ~AbstractLogProvider() {} - virtual void SetTag(const char *tag); + virtual void SetTag(const char *tag); - virtual void Debug(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void Info(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void Warning(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void Error(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void Pedantic(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void SecureDebug(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void SecureInfo(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void SecureWarning(const char *message, - const char *fileName, - int line, - const char *function) = 0; - virtual void SecureError(const char *message, - const char *fileName, - int line, - const char *function) = 0; + virtual void Debug(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void Info(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void Warning(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void Error(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void Pedantic(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void SecureDebug(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void SecureInfo(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void SecureWarning(const char *message, + const char *fileName, + int line, + const char *function) = 0; + virtual void SecureError(const char *message, + const char *fileName, + int line, + const char *function) = 0; - protected: - static const char *LocateSourceFileName(const char *filename); +protected: + static const char *LocateSourceFileName(const char *filename); }; } } // namespace AuthPasswd diff --git a/src/dpl/log/include/dpl/log/dlog_log_provider.h b/src/dpl/log/include/dpl/log/dlog_log_provider.h index f87c7d5..92b752e 100644 --- a/src/dpl/log/include/dpl/log/dlog_log_provider.h +++ b/src/dpl/log/include/dpl/log/dlog_log_provider.h @@ -29,59 +29,58 @@ namespace AuthPasswd { namespace Log { class DLOGLogProvider : - public AbstractLogProvider -{ - private: - std::unique_ptr m_tag; + public AbstractLogProvider { +private: + std::unique_ptr m_tag; - static std::string FormatMessage(const char *message, - const char *filename, - int line, - const char *function); + static std::string FormatMessage(const char *message, + const char *filename, + int line, + const char *function); - public: - DLOGLogProvider(); - virtual ~DLOGLogProvider(); +public: + DLOGLogProvider(); + virtual ~DLOGLogProvider(); - virtual void Debug(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Info(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Warning(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Error(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Pedantic(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureDebug(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureInfo(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureWarning(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureError(const char *message, - const char *fileName, - int line, - const char *function); + virtual void Debug(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Info(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Warning(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Error(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Pedantic(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureDebug(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureInfo(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureWarning(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureError(const char *message, + const char *fileName, + int line, + const char *function); - // Set global Tag according to DLOG - void SetTag(const char *tag); + // Set global Tag according to DLOG + void SetTag(const char *tag); }; } // namespace Log diff --git a/src/dpl/log/include/dpl/log/log.h b/src/dpl/log/include/dpl/log/log.h index 5b1a897..beeaadc 100644 --- a/src/dpl/log/include/dpl/log/log.h +++ b/src/dpl/log/include/dpl/log/log.h @@ -39,104 +39,104 @@ namespace Log { */ class COMMON_API LogSystem : private Noncopyable { private: - typedef std::list AbstractLogProviderPtrList; - AbstractLogProviderPtrList m_providers; + typedef std::list AbstractLogProviderPtrList; + AbstractLogProviderPtrList m_providers; - bool m_isLoggingEnabled; + bool m_isLoggingEnabled; public: - bool IsLoggingEnabled() const; - LogSystem(); - virtual ~LogSystem(); - - /** - * Log debug message - */ - void Debug(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log info message - */ - void Info(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log warning message - */ - void Warning(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log error message - */ - void Error(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log pedantic message - */ - void Pedantic(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log pedantic message with secure macro - */ - void SecureDebug(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log info message with secure macro - */ - void SecureInfo(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log warning message with secure macro - */ - void SecureWarning(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Log error message with secure macro - */ - void SecureError(const char *message, - const char *filename, - int line, - const char *function); - - /** - * Set default's DLOG provider Tag - */ - void SetTag(const char *tag); - - /** - * Add abstract provider to providers list - * - * @notice Ownership is transfered to LogSystem and deleted upon exit - */ - void AddProvider(AbstractLogProvider *provider); - - /** - * Remove abstract provider from providers list - */ - void RemoveProvider(AbstractLogProvider *provider); + bool IsLoggingEnabled() const; + LogSystem(); + virtual ~LogSystem(); + + /** + * Log debug message + */ + void Debug(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log info message + */ + void Info(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log warning message + */ + void Warning(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log error message + */ + void Error(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log pedantic message + */ + void Pedantic(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log pedantic message with secure macro + */ + void SecureDebug(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log info message with secure macro + */ + void SecureInfo(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log warning message with secure macro + */ + void SecureWarning(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Log error message with secure macro + */ + void SecureError(const char *message, + const char *filename, + int line, + const char *function); + + /** + * Set default's DLOG provider Tag + */ + void SetTag(const char *tag); + + /** + * Add abstract provider to providers list + * + * @notice Ownership is transfered to LogSystem and deleted upon exit + */ + void AddProvider(AbstractLogProvider *provider); + + /** + * Remove abstract provider from providers list + */ + void RemoveProvider(AbstractLogProvider *provider); }; /* @@ -144,13 +144,13 @@ public: */ class COMMON_API NullStream { public: - NullStream() {} + NullStream() {} - template - NullStream& operator<<(const T&) - { - return *this; - } + template + NullStream &operator<<(const T &) + { + return *this; + } }; /** @@ -166,45 +166,43 @@ typedef Singleton LogSystemSingleton; // /* avoid warnings about unused variables */ -#define DPL_MACRO_DUMMY_LOGGING(message, function) \ - do { \ - AuthPasswd::Log::NullStream ns; \ - ns << message; \ - } while (0) - -#define DPL_MACRO_FOR_LOGGING(message, function) \ -do \ -{ \ - if (AuthPasswd::Log::LogSystemSingleton::Instance().IsLoggingEnabled()) \ - { \ - std::ostringstream platformLog; \ - platformLog << message; \ - AuthPasswd::Log::LogSystemSingleton::Instance().function( \ - platformLog.str().c_str(), \ - __FILE__, __LINE__, __FUNCTION__); \ - } \ -} while (0) +#define DPL_MACRO_DUMMY_LOGGING(message, function) \ + do { \ + AuthPasswd::Log::NullStream ns; \ + ns << message; \ + } while (0) + +#define DPL_MACRO_FOR_LOGGING(message, function) \ + do { \ + if (AuthPasswd::Log::LogSystemSingleton::Instance().IsLoggingEnabled()) { \ + std::ostringstream platformLog; \ + platformLog << message; \ + AuthPasswd::Log::LogSystemSingleton::Instance().function( \ + platformLog.str().c_str(), \ + __FILE__, __LINE__, __FUNCTION__); \ + } \ + } while (0) /* Errors must be always logged. */ #define LogError(message) DPL_MACRO_FOR_LOGGING(message, Error) #define LogSecureError(message) DPL_MACRO_FOR_LOGGING(message, SecureError) #ifdef BUILD_TYPE_DEBUG - #define LogDebug(message) DPL_MACRO_FOR_LOGGING(message, Debug) - #define LogInfo(message) DPL_MACRO_FOR_LOGGING(message, Info) - #define LogWarning(message) DPL_MACRO_FOR_LOGGING(message, Warning) - #define LogPedantic(message) DPL_MACRO_FOR_LOGGING(message, Pedantic) - #define LogSecureDebug(message) DPL_MACRO_FOR_LOGGING(message, SecureDebug) - #define LogSecureInfo(message) DPL_MACRO_FOR_LOGGING(message, SecureInfo) - #define LogSecureWarning(message) DPL_MACRO_FOR_LOGGING(message, SecureWarning) +#define LogDebug(message) DPL_MACRO_FOR_LOGGING(message, Debug) +#define LogInfo(message) DPL_MACRO_FOR_LOGGING(message, Info) +#define LogWarning(message) DPL_MACRO_FOR_LOGGING(message, Warning) +#define LogPedantic(message) DPL_MACRO_FOR_LOGGING(message, Pedantic) +#define LogSecureDebug(message) DPL_MACRO_FOR_LOGGING(message, SecureDebug) +#define LogSecureInfo(message) DPL_MACRO_FOR_LOGGING(message, SecureInfo) +#define LogSecureWarning(message) DPL_MACRO_FOR_LOGGING(message, SecureWarning) #else - #define LogDebug(message) DPL_MACRO_DUMMY_LOGGING(message, Debug) - #define LogInfo(message) DPL_MACRO_DUMMY_LOGGING(message, Info) - #define LogWarning(message) DPL_MACRO_DUMMY_LOGGING(message, Warning) - #define LogPedantic(message) DPL_MACRO_DUMMY_LOGGING(message, Pedantic) - #define LogSecureDebug(message) DPL_MACRO_DUMMY_LOGGING(message, SecureDebug) - #define LogSecureInfo(message) DPL_MACRO_DUMMY_LOGGING(message, SecureInfo) - #define LogSecureWarning(message) DPL_MACRO_DUMMY_LOGGING(message, SecureWarning) +#define LogDebug(message) DPL_MACRO_DUMMY_LOGGING(message, Debug) +#define LogInfo(message) DPL_MACRO_DUMMY_LOGGING(message, Info) +#define LogWarning(message) DPL_MACRO_DUMMY_LOGGING(message, Warning) +#define LogPedantic(message) DPL_MACRO_DUMMY_LOGGING(message, Pedantic) +#define LogSecureDebug(message) DPL_MACRO_DUMMY_LOGGING(message, SecureDebug) +#define LogSecureInfo(message) DPL_MACRO_DUMMY_LOGGING(message, SecureInfo) +#define LogSecureWarning(message) DPL_MACRO_DUMMY_LOGGING(message, SecureWarning) #endif // BUILD_TYPE_DEBUG #endif // AUTHPASSWD_LOG_H diff --git a/src/dpl/log/include/dpl/log/old_style_log_provider.h b/src/dpl/log/include/dpl/log/old_style_log_provider.h index 39e58e6..b9ca8cb 100644 --- a/src/dpl/log/include/dpl/log/old_style_log_provider.h +++ b/src/dpl/log/include/dpl/log/old_style_log_provider.h @@ -28,71 +28,70 @@ namespace AuthPasswd { namespace Log { class OldStyleLogProvider : - public AbstractLogProvider -{ - private: - bool m_showDebug; - bool m_showInfo; - bool m_showWarning; - bool m_showError; - bool m_showPedantic; - bool m_printStdErr; + public AbstractLogProvider { +private: + bool m_showDebug; + bool m_showInfo; + bool m_showWarning; + bool m_showError; + bool m_showPedantic; + bool m_printStdErr; - static std::string FormatMessage(const char *message, - const char *filename, - int line, - const char *function); + static std::string FormatMessage(const char *message, + const char *filename, + int line, + const char *function); - public: - OldStyleLogProvider(bool showDebug, - bool showInfo, - bool showWarning, - bool showError, - bool showPedantic); - OldStyleLogProvider(bool showDebug, - bool showInfo, - bool showWarning, - bool showError, - bool showPedantic, - bool printStdErr); - virtual ~OldStyleLogProvider() {} +public: + OldStyleLogProvider(bool showDebug, + bool showInfo, + bool showWarning, + bool showError, + bool showPedantic); + OldStyleLogProvider(bool showDebug, + bool showInfo, + bool showWarning, + bool showError, + bool showPedantic, + bool printStdErr); + virtual ~OldStyleLogProvider() {} - virtual void Debug(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Info(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Warning(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Error(const char *message, - const char *fileName, - int line, - const char *function); - virtual void Pedantic(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureDebug(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureInfo(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureWarning(const char *message, - const char *fileName, - int line, - const char *function); - virtual void SecureError(const char *message, - const char *fileName, - int line, - const char *function); + virtual void Debug(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Info(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Warning(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Error(const char *message, + const char *fileName, + int line, + const char *function); + virtual void Pedantic(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureDebug(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureInfo(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureWarning(const char *message, + const char *fileName, + int line, + const char *function); + virtual void SecureError(const char *message, + const char *fileName, + int line, + const char *function); }; } } // namespace AuthPasswd diff --git a/src/dpl/log/src/abstract_log_provider.cpp b/src/dpl/log/src/abstract_log_provider.cpp index 7f7c07f..778947b 100644 --- a/src/dpl/log/src/abstract_log_provider.cpp +++ b/src/dpl/log/src/abstract_log_provider.cpp @@ -32,8 +32,8 @@ void AbstractLogProvider::SetTag(const char *tag UNUSED) {} const char *AbstractLogProvider::LocateSourceFileName(const char *filename) { - const char *ptr = strrchr(filename, '/'); - return ptr != NULL ? ptr + 1 : filename; + const char *ptr = strrchr(filename, '/'); + return ptr != NULL ? ptr + 1 : filename; } } } diff --git a/src/dpl/log/src/dlog_log_provider.cpp b/src/dpl/log/src/dlog_log_provider.cpp index a9cfc8f..1064036 100644 --- a/src/dpl/log/src/dlog_log_provider.cpp +++ b/src/dpl/log/src/dlog_log_provider.cpp @@ -30,17 +30,15 @@ namespace AuthPasswd { namespace Log { std::string DLOGLogProvider::FormatMessage(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - std::ostringstream val; - - val << std::string("[") << - LocateSourceFileName(filename) << std::string(":") << line << - std::string("] ") << function << std::string("(): ") << message; - - return val.str(); + std::ostringstream val; + val << std::string("[") << + LocateSourceFileName(filename) << std::string(":") << line << + std::string("] ") << function << std::string("(): ") << message; + return val.str(); } DLOGLogProvider::DLOGLogProvider() @@ -51,94 +49,96 @@ DLOGLogProvider::~DLOGLogProvider() void DLOGLogProvider::SetTag(const char *tag) { - size_t size = strlen(tag)+1; - char *buff = new (std::nothrow) char[size]; - if (buff) - memcpy(buff, tag, size); - m_tag.reset(buff); + size_t size = strlen(tag) + 1; + char *buff = new(std::nothrow) char[size]; + + if (buff) + memcpy(buff, tag, size); + + m_tag.reset(buff); } void DLOGLogProvider::Debug(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - SLOG(LOG_DEBUG, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SLOG(LOG_DEBUG, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::Info(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - SLOG(LOG_INFO, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SLOG(LOG_INFO, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::Warning(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - SLOG(LOG_WARN, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SLOG(LOG_WARN, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::Error(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - SLOG(LOG_ERROR, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SLOG(LOG_ERROR, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::Pedantic(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - SLOG(LOG_DEBUG, "AuthPasswd", "%s", FormatMessage(message, - filename, - line, - function).c_str()); + SLOG(LOG_DEBUG, "AuthPasswd", "%s", FormatMessage(message, + filename, + line, + function).c_str()); } void DLOGLogProvider::SecureDebug(const char *message UNUSED, - const char *filename UNUSED, - int line UNUSED, - const char *function UNUSED) + const char *filename UNUSED, + int line UNUSED, + const char *function UNUSED) { - SECURE_SLOG(LOG_DEBUG, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SECURE_SLOG(LOG_DEBUG, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::SecureInfo(const char *message UNUSED, - const char *filename UNUSED, - int line UNUSED, - const char *function UNUSED) + const char *filename UNUSED, + int line UNUSED, + const char *function UNUSED) { - SECURE_SLOG(LOG_INFO, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SECURE_SLOG(LOG_INFO, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::SecureWarning(const char *message UNUSED, - const char *filename UNUSED, - int line UNUSED, - const char *function UNUSED) + const char *filename UNUSED, + int line UNUSED, + const char *function UNUSED) { - SECURE_SLOG(LOG_WARN, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SECURE_SLOG(LOG_WARN, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } void DLOGLogProvider::SecureError(const char *message UNUSED, - const char *filename UNUSED, - int line UNUSED, - const char *function UNUSED) + const char *filename UNUSED, + int line UNUSED, + const char *function UNUSED) { - SECURE_SLOG(LOG_ERROR, m_tag.get(), "%s", - FormatMessage(message, filename, line, function).c_str()); + SECURE_SLOG(LOG_ERROR, m_tag.get(), "%s", + FormatMessage(message, filename, line, function).c_str()); } } // nemespace Log diff --git a/src/dpl/log/src/log.cpp b/src/dpl/log/src/log.cpp index cf4f256..ab04fcc 100644 --- a/src/dpl/log/src/log.cpp +++ b/src/dpl/log/src/log.cpp @@ -31,12 +31,11 @@ IMPLEMENT_SINGLETON(AuthPasswd::Log::LogSystem) namespace AuthPasswd { namespace Log { -namespace // anonymous -{ +namespace { // anonymous #ifdef BUILD_TYPE_DEBUG const char *OLD_STYLE_LOGS_ENV_NAME = "DPL_USE_OLD_STYLE_LOGS"; const char *OLD_STYLE_PEDANTIC_LOGS_ENV_NAME = - "DPL_USE_OLD_STYLE_PEDANTIC_LOGS"; + "DPL_USE_OLD_STYLE_PEDANTIC_LOGS"; const char *OLD_STYLE_LOGS_MASK_ENV_NAME = "DPL_USE_OLD_STYLE_LOGS_MASK"; #endif // BUILD_TYPE_DEBUG const char *AUTH_PASSWD_LOG_OFF = "DPL_LOG_OFF"; @@ -44,236 +43,208 @@ const char *AUTH_PASSWD_LOG_OFF = "DPL_LOG_OFF"; bool LogSystem::IsLoggingEnabled() const { - return m_isLoggingEnabled; + return m_isLoggingEnabled; } LogSystem::LogSystem() : - m_isLoggingEnabled(!getenv(AUTH_PASSWD_LOG_OFF)) + m_isLoggingEnabled(!getenv(AUTH_PASSWD_LOG_OFF)) { #ifdef BUILD_TYPE_DEBUG - bool oldStyleLogs = false; - bool oldStyleDebugLogs = true; - bool oldStyleInfoLogs = true; - bool oldStyleWarningLogs = true; - bool oldStyleErrorLogs = true; - bool oldStylePedanticLogs = false; - - // Check environment settings about pedantic logs - const char *value = getenv(OLD_STYLE_LOGS_ENV_NAME); - - if (value != NULL && !strcmp(value, "1")) { - oldStyleLogs = true; - } - - value = getenv(OLD_STYLE_PEDANTIC_LOGS_ENV_NAME); - - if (value != NULL && !strcmp(value, "1")) { - oldStylePedanticLogs = true; - } - - value = getenv(OLD_STYLE_LOGS_MASK_ENV_NAME); + bool oldStyleLogs = false; + bool oldStyleDebugLogs = true; + bool oldStyleInfoLogs = true; + bool oldStyleWarningLogs = true; + bool oldStyleErrorLogs = true; + bool oldStylePedanticLogs = false; + // Check environment settings about pedantic logs + const char *value = getenv(OLD_STYLE_LOGS_ENV_NAME); + + if (value != NULL && !strcmp(value, "1")) + oldStyleLogs = true; + + value = getenv(OLD_STYLE_PEDANTIC_LOGS_ENV_NAME); + + if (value != NULL && !strcmp(value, "1")) + oldStylePedanticLogs = true; + + value = getenv(OLD_STYLE_LOGS_MASK_ENV_NAME); + + if (value != NULL) { + size_t len = strlen(value); + + if (len >= 1) { + if (value[0] == '0') + oldStyleDebugLogs = false; + else if (value[0] == '1') + oldStyleDebugLogs = true; + } + + if (len >= 2) { + if (value[1] == '0') + oldStyleInfoLogs = false; + else if (value[1] == '1') + oldStyleInfoLogs = true; + } + + if (len >= 3) { + if (value[2] == '0') + oldStyleWarningLogs = false; + else if (value[2] == '1') + oldStyleWarningLogs = true; + } + + if (len >= 4) { + if (value[3] == '0') + oldStyleErrorLogs = false; + else if (value[3] == '1') + oldStyleErrorLogs = true; + } + } + + // Setup default DLOG and old style logging + if (oldStyleLogs) { + // Old style + AddProvider(new OldStyleLogProvider(oldStyleDebugLogs, + oldStyleInfoLogs, + oldStyleWarningLogs, + oldStyleErrorLogs, + oldStylePedanticLogs)); + } else { + // DLOG + AddProvider(new DLOGLogProvider()); + } - if (value != NULL) { - size_t len = strlen(value); - - if (len >= 1) { - if (value[0] == '0') { - oldStyleDebugLogs = false; - } else if (value[0] == '1') { - oldStyleDebugLogs = true; - } - } - - if (len >= 2) { - if (value[1] == '0') { - oldStyleInfoLogs = false; - } else if (value[1] == '1') { - oldStyleInfoLogs = true; - } - } - - if (len >= 3) { - if (value[2] == '0') { - oldStyleWarningLogs = false; - } else if (value[2] == '1') { - oldStyleWarningLogs = true; - } - } - - if (len >= 4) { - if (value[3] == '0') { - oldStyleErrorLogs = false; - } else if (value[3] == '1') { - oldStyleErrorLogs = true; - } - } - } - - // Setup default DLOG and old style logging - if (oldStyleLogs) { - // Old style - AddProvider(new OldStyleLogProvider(oldStyleDebugLogs, - oldStyleInfoLogs, - oldStyleWarningLogs, - oldStyleErrorLogs, - oldStylePedanticLogs)); - } else { - // DLOG - AddProvider(new DLOGLogProvider()); - } #else // BUILD_TYPE_DEBUG - AddProvider(new DLOGLogProvider()); + AddProvider(new DLOGLogProvider()); #endif // BUILD_TYPE_DEBUG } LogSystem::~LogSystem() { - // Delete all providers - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - delete *iterator; - } + // Delete all providers + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + delete *iterator; - m_providers.clear(); + m_providers.clear(); } -void LogSystem::SetTag(const char* tag) +void LogSystem::SetTag(const char *tag) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->SetTag(tag); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->SetTag(tag); } void LogSystem::AddProvider(AbstractLogProvider *provider) { - m_providers.push_back(provider); + m_providers.push_back(provider); } void LogSystem::RemoveProvider(AbstractLogProvider *provider) { - m_providers.remove(provider); + m_providers.remove(provider); } void LogSystem::Debug(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->Debug(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->Debug(message, filename, line, function); } void LogSystem::Info(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->Info(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->Info(message, filename, line, function); } void LogSystem::Warning(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->Warning(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->Warning(message, filename, line, function); } void LogSystem::Error(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->Error(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->Error(message, filename, line, function); } void LogSystem::Pedantic(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->Pedantic(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->Pedantic(message, filename, line, function); } void LogSystem::SecureInfo(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->SecureInfo(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->SecureInfo(message, filename, line, function); } void LogSystem::SecureDebug(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->SecureDebug(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->SecureDebug(message, filename, line, function); } void LogSystem::SecureError(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->SecureError(message, filename, line, function); - } + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->SecureError(message, filename, line, function); } void LogSystem::SecureWarning(const char *message, - const char *filename, - int line, - const char *function) -{ - for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); - iterator != m_providers.end(); - ++iterator) - { - (*iterator)->SecureWarning(message, filename, line, function); - } + const char *filename, + int line, + const char *function) +{ + for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); + iterator != m_providers.end(); + ++iterator) + (*iterator)->SecureWarning(message, filename, line, function); } } diff --git a/src/dpl/log/src/old_style_log_provider.cpp b/src/dpl/log/src/old_style_log_provider.cpp index fcdf111..8b02256 100644 --- a/src/dpl/log/src/old_style_log_provider.cpp +++ b/src/dpl/log/src/old_style_log_provider.cpp @@ -31,8 +31,7 @@ namespace AuthPasswd { namespace Log { -namespace // anonymous -{ +namespace { // anonymous using namespace AuthPasswd::Colors::Text; const char *DEBUG_BEGIN = GREEN_BEGIN; const char *DEBUG_END = GREEN_END; @@ -47,254 +46,258 @@ const char *PEDANTIC_END = PURPLE_END; std::string GetFormattedTime() { - timeval tv; - tm localNowTime; - - gettimeofday(&tv, NULL); - localtime_r(&tv.tv_sec, &localNowTime); - - char format[64]; - snprintf(format, - sizeof(format), - "%02i:%02i:%02i.%03i", - localNowTime.tm_hour, - localNowTime.tm_min, - localNowTime.tm_sec, - static_cast(tv.tv_usec / 1000)); - return format; + timeval tv; + tm localNowTime; + gettimeofday(&tv, NULL); + localtime_r(&tv.tv_sec, &localNowTime); + char format[64]; + snprintf(format, + sizeof(format), + "%02i:%02i:%02i.%03i", + localNowTime.tm_hour, + localNowTime.tm_min, + localNowTime.tm_sec, + static_cast(tv.tv_usec / 1000)); + return format; } } // namespace anonymous std::string OldStyleLogProvider::FormatMessage(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - std::ostringstream val; - - val << std::string("[") << GetFormattedTime() << std::string("] [") << - static_cast(pthread_self()) << "/" << - static_cast(getpid()) << std::string("] [") << - LocateSourceFileName(filename) << std::string(":") << line << - std::string("] ") << function << std::string("(): ") << message; - - return val.str(); + std::ostringstream val; + val << std::string("[") << GetFormattedTime() << std::string("] [") << + static_cast(pthread_self()) << "/" << + static_cast(getpid()) << std::string("] [") << + LocateSourceFileName(filename) << std::string(":") << line << + std::string("] ") << function << std::string("(): ") << message; + return val.str(); } OldStyleLogProvider::OldStyleLogProvider(bool showDebug, - bool showInfo, - bool showWarning, - bool showError, - bool showPedantic) : - m_showDebug(showDebug), - m_showInfo(showInfo), - m_showWarning(showWarning), - m_showError(showError), - m_showPedantic(showPedantic), - m_printStdErr(false) + bool showInfo, + bool showWarning, + bool showError, + bool showPedantic) : + m_showDebug(showDebug), + m_showInfo(showInfo), + m_showWarning(showWarning), + m_showError(showError), + m_showPedantic(showPedantic), + m_printStdErr(false) {} OldStyleLogProvider::OldStyleLogProvider(bool showDebug, - bool showInfo, - bool showWarning, - bool showError, - bool showPedantic, - bool printStdErr) : - m_showDebug(showDebug), - m_showInfo(showInfo), - m_showWarning(showWarning), - m_showError(showError), - m_showPedantic(showPedantic), - m_printStdErr(printStdErr) + bool showInfo, + bool showWarning, + bool showError, + bool showPedantic, + bool printStdErr) : + m_showDebug(showDebug), + m_showInfo(showInfo), + m_showWarning(showWarning), + m_showError(showError), + m_showPedantic(showPedantic), + m_printStdErr(printStdErr) {} void OldStyleLogProvider::Debug(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - if (m_showDebug) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", DEBUG_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), DEBUG_END); - } else { - fprintf(stdout, "%s%s%s\n", DEBUG_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), DEBUG_END); - } - } + if (m_showDebug) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", DEBUG_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), DEBUG_END); + } else { + fprintf(stdout, "%s%s%s\n", DEBUG_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), DEBUG_END); + } + } } void OldStyleLogProvider::Info(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - if (m_showInfo) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", INFO_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), INFO_END); - } else { - fprintf(stdout, "%s%s%s\n", INFO_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), INFO_END); - } - } + if (m_showInfo) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", INFO_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), INFO_END); + } else { + fprintf(stdout, "%s%s%s\n", INFO_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), INFO_END); + } + } } void OldStyleLogProvider::Warning(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - if (m_showWarning) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", WARNING_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), WARNING_END); - } else { - fprintf(stdout, "%s%s%s\n", WARNING_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), WARNING_END); - } - } + if (m_showWarning) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", WARNING_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), WARNING_END); + } else { + fprintf(stdout, "%s%s%s\n", WARNING_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), WARNING_END); + } + } } void OldStyleLogProvider::Error(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - if (m_showError) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", ERROR_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), ERROR_END); - } else { - fprintf(stdout, "%s%s%s\n", ERROR_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), ERROR_END); - } - } + if (m_showError) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", ERROR_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), ERROR_END); + } else { + fprintf(stdout, "%s%s%s\n", ERROR_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), ERROR_END); + } + } } void OldStyleLogProvider::Pedantic(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { - if (m_showPedantic) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", PEDANTIC_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), PEDANTIC_END); - } else { - fprintf(stdout, "%s%s%s\n", PEDANTIC_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), PEDANTIC_END); - } - } + if (m_showPedantic) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", PEDANTIC_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), PEDANTIC_END); + } else { + fprintf(stdout, "%s%s%s\n", PEDANTIC_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), PEDANTIC_END); + } + } } void OldStyleLogProvider::SecureDebug(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { #ifdef _SECURE_LOG - if (m_showDebug) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", DEBUG_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), DEBUG_END); - } else { - fprintf(stdout, "%s%s%s\n", DEBUG_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), DEBUG_END); - } - } + + if (m_showDebug) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", DEBUG_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), DEBUG_END); + } else { + fprintf(stdout, "%s%s%s\n", DEBUG_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), DEBUG_END); + } + } + #else - (void)message; - (void)filename; - (void)line; - (void)function; + (void)message; + (void)filename; + (void)line; + (void)function; #endif } void OldStyleLogProvider::SecureInfo(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { #ifdef _SECURE_LOG - if (m_showInfo) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", INFO_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), INFO_END); - } else { - fprintf(stdout, "%s%s%s\n", INFO_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), INFO_END); - } - } + + if (m_showInfo) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", INFO_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), INFO_END); + } else { + fprintf(stdout, "%s%s%s\n", INFO_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), INFO_END); + } + } + #else - (void)message; - (void)filename; - (void)line; - (void)function; + (void)message; + (void)filename; + (void)line; + (void)function; #endif } void OldStyleLogProvider::SecureWarning(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { #ifdef _SECURE_LOG - if (m_showWarning) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", WARNING_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), WARNING_END); - } else { - fprintf(stdout, "%s%s%s\n", WARNING_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), WARNING_END); - } - } + + if (m_showWarning) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", WARNING_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), WARNING_END); + } else { + fprintf(stdout, "%s%s%s\n", WARNING_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), WARNING_END); + } + } + #else - (void)message; - (void)filename; - (void)line; - (void)function; + (void)message; + (void)filename; + (void)line; + (void)function; #endif } void OldStyleLogProvider::SecureError(const char *message, - const char *filename, - int line, - const char *function) + const char *filename, + int line, + const char *function) { #ifdef _SECURE_LOG - if (m_showError) { - if (m_printStdErr) { - fprintf(stderr, "%s%s%s\n", ERROR_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), ERROR_END); - } else { - fprintf(stdout, "%s%s%s\n", ERROR_BEGIN, - FormatMessage(message, filename, line, - function).c_str(), ERROR_END); - } - } + + if (m_showError) { + if (m_printStdErr) { + fprintf(stderr, "%s%s%s\n", ERROR_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), ERROR_END); + } else { + fprintf(stdout, "%s%s%s\n", ERROR_BEGIN, + FormatMessage(message, filename, line, + function).c_str(), ERROR_END); + } + } + #else - (void)message; - (void)filename; - (void)line; - (void)function; + (void)message; + (void)filename; + (void)line; + (void)function; #endif } diff --git a/src/include/auth-passwd-admin.h b/src/include/auth-passwd-admin.h index d1400b9..67d0745 100644 --- a/src/include/auth-passwd-admin.h +++ b/src/include/auth-passwd-admin.h @@ -52,8 +52,8 @@ extern "C" { #endif int auth_passwd_reset_passwd(password_type passwd_type, - uid_t uid, - const char *new_passwd); + uid_t uid, + const char *new_passwd); int auth_passwd_new_policy(policy_h **pp_policy); diff --git a/src/include/auth-passwd-policy-types.h b/src/include/auth-passwd-policy-types.h index 45a7c9d..e024671 100644 --- a/src/include/auth-passwd-policy-types.h +++ b/src/include/auth-passwd-policy-types.h @@ -29,33 +29,33 @@ extern "C" { typedef struct _policy_h policy_h; typedef enum { - POLICY_USER, - POLICY_MAX_ATTEMPTS, - POLICY_VALID_PERIOD, - POLICY_HISTORY_SIZE, - POLICY_MIN_LENGTH, - POLICY_MIN_COMPLEX_CHAR_NUMBER, - POLICY_MAX_CHAR_OCCURRENCES, - POLICY_MAX_NUMERIC_SEQ_LENGTH, - POLICY_QUALITY_TYPE, - POLICY_PATTERN, - POLICY_FORBIDDEN_PASSWDS, - POLICY_TYPE_FIRST = POLICY_MAX_ATTEMPTS, - POLICY_TYPE_LAST = POLICY_FORBIDDEN_PASSWDS + POLICY_USER, + POLICY_MAX_ATTEMPTS, + POLICY_VALID_PERIOD, + POLICY_HISTORY_SIZE, + POLICY_MIN_LENGTH, + POLICY_MIN_COMPLEX_CHAR_NUMBER, + POLICY_MAX_CHAR_OCCURRENCES, + POLICY_MAX_NUMERIC_SEQ_LENGTH, + POLICY_QUALITY_TYPE, + POLICY_PATTERN, + POLICY_FORBIDDEN_PASSWDS, + POLICY_TYPE_FIRST = POLICY_MAX_ATTEMPTS, + POLICY_TYPE_LAST = POLICY_FORBIDDEN_PASSWDS } password_policy_type; typedef enum { - AUTH_PWD_NORMAL, - AUTH_PWD_RECOVERY + AUTH_PWD_NORMAL, + AUTH_PWD_RECOVERY } password_type; typedef enum { - AUTH_PWD_QUALITY_UNSPECIFIED, - AUTH_PWD_QUALITY_SOMETHING, - AUTH_PWD_QUALITY_NUMERIC, - AUTH_PWD_QUALITY_ALPHABETIC, - AUTH_PWD_QUALITY_ALPHANUMERIC, - AUTH_PWD_QUALITY_LAST = AUTH_PWD_QUALITY_ALPHANUMERIC + AUTH_PWD_QUALITY_UNSPECIFIED, + AUTH_PWD_QUALITY_SOMETHING, + AUTH_PWD_QUALITY_NUMERIC, + AUTH_PWD_QUALITY_ALPHABETIC, + AUTH_PWD_QUALITY_ALPHANUMERIC, + AUTH_PWD_QUALITY_LAST = AUTH_PWD_QUALITY_ALPHANUMERIC } password_quality_type; #ifdef __cplusplus diff --git a/src/include/auth-passwd.h b/src/include/auth-passwd.h index bd4516c..7824331 100644 --- a/src/include/auth-passwd.h +++ b/src/include/auth-passwd.h @@ -52,26 +52,26 @@ extern "C" { #endif int auth_passwd_check_passwd(password_type passwd_type, - const char *passwd, - unsigned int *current_attempts, - unsigned int *max_attempts, - unsigned int *valid_secs); + const char *passwd, + unsigned int *current_attempts, + unsigned int *max_attempts, + unsigned int *valid_secs); int auth_passwd_check_passwd_state(password_type passwd_type, - unsigned int *current_attempts, - unsigned int *max_attempts, - unsigned int *valid_secs); + unsigned int *current_attempts, + unsigned int *max_attempts, + unsigned int *valid_secs); int auth_passwd_check_passwd_reused(password_type passwd_type, - const char *passwd, - int *is_reused); + const char *passwd, + int *is_reused); int auth_passwd_set_passwd(password_type passwd_type, - const char *cur_passwd, - const char *new_passwd); + const char *cur_passwd, + const char *new_passwd); int auth_passwd_set_passwd_recovery(const char *cur_recovery_passwd, - const char *new_normal_passwd); + const char *new_normal_passwd); #ifdef __cplusplus } diff --git a/src/server/main/generic-socket-manager.cpp b/src/server/main/generic-socket-manager.cpp index 1e0dbdd..2a2cd39 100644 --- a/src/server/main/generic-socket-manager.cpp +++ b/src/server/main/generic-socket-manager.cpp @@ -31,86 +31,87 @@ namespace AuthPasswd { class SendMsgData::Internal { public: - Internal(int resultCode, int fileDesc) - : m_resultCode(resultCode) - , m_fileDesc(fileDesc) - { - memset(&m_hdr, 0, sizeof(msghdr)); - memset(m_cmsgbuf, 0, CMSG_SPACE(sizeof(int))); - - m_iov.iov_base = &m_resultCode; - m_iov.iov_len = sizeof(m_resultCode); - - m_hdr.msg_iov = &m_iov; - m_hdr.msg_iovlen = 1; - - if (fileDesc != -1) { - m_hdr.msg_control = m_cmsgbuf; - m_hdr.msg_controllen = CMSG_SPACE(sizeof(int)); - - m_cmsg = CMSG_FIRSTHDR(&m_hdr); - m_cmsg->cmsg_len = CMSG_LEN(sizeof(int)); - m_cmsg->cmsg_level = SOL_SOCKET; - m_cmsg->cmsg_type = SCM_RIGHTS; - - memmove(CMSG_DATA(m_cmsg), &m_fileDesc, sizeof(int)); - } - } - - msghdr* data() { return &m_hdr; } + Internal(int resultCode, int fileDesc) : + m_resultCode(resultCode), + m_fileDesc(fileDesc) { + memset(&m_hdr, 0, sizeof(msghdr)); + memset(m_cmsgbuf, 0, CMSG_SPACE(sizeof(int))); + m_iov.iov_base = &m_resultCode; + m_iov.iov_len = sizeof(m_resultCode); + m_hdr.msg_iov = &m_iov; + m_hdr.msg_iovlen = 1; + + if (fileDesc != -1) { + m_hdr.msg_control = m_cmsgbuf; + m_hdr.msg_controllen = CMSG_SPACE(sizeof(int)); + m_cmsg = CMSG_FIRSTHDR(&m_hdr); + m_cmsg->cmsg_len = CMSG_LEN(sizeof(int)); + m_cmsg->cmsg_level = SOL_SOCKET; + m_cmsg->cmsg_type = SCM_RIGHTS; + memmove(CMSG_DATA(m_cmsg), &m_fileDesc, sizeof(int)); + } + } + + msghdr *data() { + return &m_hdr; + } private: - msghdr m_hdr; - iovec m_iov; - cmsghdr *m_cmsg; - unsigned char m_cmsgbuf[CMSG_SPACE(sizeof(int))]; - int m_resultCode; - int m_fileDesc; + msghdr m_hdr; + iovec m_iov; + cmsghdr *m_cmsg; + unsigned char m_cmsgbuf[CMSG_SPACE(sizeof(int))]; + int m_resultCode; + int m_fileDesc; }; -SendMsgData::SendMsgData() - : m_resultCode(0) - , m_fileDesc(-1) - , m_flags(0) - , m_pimpl(NULL) +SendMsgData::SendMsgData() : + m_resultCode(0), + m_fileDesc(-1), + m_flags(0), + m_pimpl(NULL) {} -SendMsgData::SendMsgData(int resultCode, int fileDesc, int paramFlags) - : m_resultCode(resultCode) - , m_fileDesc(fileDesc) - , m_flags(paramFlags) - , m_pimpl(NULL) +SendMsgData::SendMsgData(int resultCode, int fileDesc, int paramFlags) : + m_resultCode(resultCode), + m_fileDesc(fileDesc), + m_flags(paramFlags), + m_pimpl(NULL) {} -SendMsgData::SendMsgData(const SendMsgData &second) - : m_resultCode(second.m_resultCode) - , m_fileDesc(second.m_fileDesc) - , m_flags(second.m_flags) - , m_pimpl(NULL) +SendMsgData::SendMsgData(const SendMsgData &second) : + m_resultCode(second.m_resultCode), + m_fileDesc(second.m_fileDesc), + m_flags(second.m_flags), + m_pimpl(NULL) {} -SendMsgData::~SendMsgData() { - delete m_pimpl; +SendMsgData::~SendMsgData() +{ + delete m_pimpl; } -SendMsgData& SendMsgData::operator=(const SendMsgData &second) { - m_resultCode = second.m_resultCode; - m_fileDesc = second.m_fileDesc; - m_flags = second.m_flags; - delete m_pimpl; - m_pimpl = NULL; - return *this; +SendMsgData &SendMsgData::operator=(const SendMsgData &second) +{ + m_resultCode = second.m_resultCode; + m_fileDesc = second.m_fileDesc; + m_flags = second.m_flags; + delete m_pimpl; + m_pimpl = NULL; + return *this; } -msghdr* SendMsgData::getMsghdr() { - if (!m_pimpl) - m_pimpl = new Internal(m_resultCode, m_fileDesc); - return m_pimpl->data(); +msghdr *SendMsgData::getMsghdr() +{ + if (!m_pimpl) + m_pimpl = new Internal(m_resultCode, m_fileDesc); + + return m_pimpl->data(); } -int SendMsgData::flags() { - return m_flags; +int SendMsgData::flags() +{ + return m_flags; } } // namespace AuthPasswd - diff --git a/src/server/main/include/generic-event.h b/src/server/main/include/generic-event.h index ef119fe..78a283d 100644 --- a/src/server/main/include/generic-event.h +++ b/src/server/main/include/generic-event.h @@ -28,7 +28,7 @@ namespace AuthPasswd { struct GenericEvent { - virtual ~GenericEvent(){} + virtual ~GenericEvent() {} }; } // namespace AuthPasswd diff --git a/src/server/main/include/generic-socket-manager.h b/src/server/main/include/generic-socket-manager.h index f39e7a1..0bb0e9a 100644 --- a/src/server/main/include/generic-socket-manager.h +++ b/src/server/main/include/generic-socket-manager.h @@ -33,7 +33,7 @@ #include extern "C" { -struct msghdr; + struct msghdr; } // extern "C" namespace AuthPasswd { @@ -41,17 +41,19 @@ namespace AuthPasswd { typedef int InterfaceID; struct ConnectionID { - int sock; // This is decriptor used for connection - int counter; // Unique handler per socket - inline bool operator<(const ConnectionID &second) const { - return counter < second.counter; - } - inline bool operator==(const ConnectionID &second) const { - return counter == second.counter; - } - inline bool operator!=(const ConnectionID &second) const { - return counter != second.counter; - } + int sock; // This is decriptor used for connection + int counter; // Unique handler per socket + inline bool operator<(const ConnectionID &second) const { + return counter < second.counter; + } + + inline bool operator==(const ConnectionID &second) const { + return counter == second.counter; + } + + inline bool operator!=(const ConnectionID &second) const { + return counter != second.counter; + } }; typedef std::vector RawBuffer; @@ -59,115 +61,116 @@ typedef std::vector RawBuffer; struct GenericSocketManager; struct GenericSocketService { - typedef std::string SmackLabel; - typedef std::string ServiceHandlerPath; - struct ServiceDescription { - ServiceDescription(const char *paramPath, - const char *paramSmackLabel, - InterfaceID paramInterfaceID = 0, - bool paramUseSendMsg = false) - : type(SOCKET_SERVICE), - interfaceID(paramInterfaceID), - useSendMsg(paramUseSendMsg), - smackLabel(paramSmackLabel), - serviceHandlerPath(paramPath), - fileDesc(-1) - {} - - ServiceDescription(int fileDesc, - InterfaceID paramInterfaceID = 0, - bool paramUseSendMsg = false) - : type(FILE_DESC_SERVICE), - interfaceID(paramInterfaceID), - useSendMsg(paramUseSendMsg), - fileDesc(fileDesc) - {} - - enum ServiceType { - SOCKET_SERVICE = 0, - FILE_DESC_SERVICE - }; - ServiceType type; - InterfaceID interfaceID; // All data from serviceHandlerPath will be marked with this interfaceHandler - bool useSendMsg; - - // if a socket service - SmackLabel smackLabel; // Smack label for socket - ServiceHandlerPath serviceHandlerPath; // Path to file - - // if a file descriptor - int fileDesc; - }; - - typedef std::vector ServiceDescriptionVector; - - struct AcceptEvent : public GenericEvent { - ConnectionID connectionID; - InterfaceID interfaceID; - }; - - struct WriteEvent : public GenericEvent { - ConnectionID connectionID; - size_t size; - size_t left; - }; - - struct ReadEvent : public GenericEvent { - ConnectionID connectionID; - RawBuffer rawBuffer; - InterfaceID interfaceID; - }; - - struct CloseEvent : public GenericEvent { - ConnectionID connectionID; - }; - - virtual void SetSocketManager(GenericSocketManager *manager) { - m_serviceManager = manager; - } - - virtual ServiceDescriptionVector GetServiceDescription() = 0; - - virtual void Start() = 0; - virtual void Stop() = 0; - - virtual void Event(const AcceptEvent &event) = 0; - virtual void Event(const WriteEvent &event) = 0; - virtual void Event(const ReadEvent &event) = 0; - virtual void Event(const CloseEvent &event) = 0; - - GenericSocketService() : m_serviceManager(NULL) {} - virtual ~GenericSocketService(){} + typedef std::string SmackLabel; + typedef std::string ServiceHandlerPath; + struct ServiceDescription { + ServiceDescription(const char *paramPath, + const char *paramSmackLabel, + InterfaceID paramInterfaceID = 0, + bool paramUseSendMsg = false) : + type(SOCKET_SERVICE), + interfaceID(paramInterfaceID), + useSendMsg(paramUseSendMsg), + smackLabel(paramSmackLabel), + serviceHandlerPath(paramPath), + fileDesc(-1) {} + + ServiceDescription(int fileDesc, + InterfaceID paramInterfaceID = 0, + bool paramUseSendMsg = false) : + type(FILE_DESC_SERVICE), + interfaceID(paramInterfaceID), + useSendMsg(paramUseSendMsg), + fileDesc(fileDesc) {} + + enum ServiceType { + SOCKET_SERVICE = 0, + FILE_DESC_SERVICE + }; + ServiceType type; + InterfaceID + interfaceID; // All data from serviceHandlerPath will be marked with this interfaceHandler + bool useSendMsg; + + // if a socket service + SmackLabel smackLabel; // Smack label for socket + ServiceHandlerPath serviceHandlerPath; // Path to file + + // if a file descriptor + int fileDesc; + }; + + typedef std::vector ServiceDescriptionVector; + + struct AcceptEvent : public GenericEvent { + ConnectionID connectionID; + InterfaceID interfaceID; + }; + + struct WriteEvent : public GenericEvent { + ConnectionID connectionID; + size_t size; + size_t left; + }; + + struct ReadEvent : public GenericEvent { + ConnectionID connectionID; + RawBuffer rawBuffer; + InterfaceID interfaceID; + }; + + struct CloseEvent : public GenericEvent { + ConnectionID connectionID; + }; + + virtual void SetSocketManager(GenericSocketManager *manager) { + m_serviceManager = manager; + } + + virtual ServiceDescriptionVector GetServiceDescription() = 0; + + virtual void Start() = 0; + virtual void Stop() = 0; + + virtual void Event(const AcceptEvent &event) = 0; + virtual void Event(const WriteEvent &event) = 0; + virtual void Event(const ReadEvent &event) = 0; + virtual void Event(const CloseEvent &event) = 0; + + GenericSocketService() : m_serviceManager(NULL) {} + virtual ~GenericSocketService() {} + protected: - GenericSocketManager *m_serviceManager; + GenericSocketManager *m_serviceManager; }; class SendMsgData { public: - class Internal; + class Internal; + + SendMsgData(); + SendMsgData(int resultCode, int fileDesc, int flags = 0); + SendMsgData(const SendMsgData &second); + SendMsgData &operator=(const SendMsgData &second); + virtual ~SendMsgData(); - SendMsgData(); - SendMsgData(int resultCode, int fileDesc, int flags = 0); - SendMsgData(const SendMsgData &second); - SendMsgData& operator=(const SendMsgData &second); - virtual ~SendMsgData(); + msghdr *getMsghdr(); + int flags(); - msghdr* getMsghdr(); - int flags(); private: - int m_resultCode; - int m_fileDesc; - int m_flags; - Internal *m_pimpl; + int m_resultCode; + int m_fileDesc; + int m_flags; + Internal *m_pimpl; }; struct GenericSocketManager { - virtual void MainLoop() = 0; - virtual void RegisterSocketService(GenericSocketService *ptr) = 0; - virtual void Close(ConnectionID connectionID) = 0; - virtual void Write(ConnectionID connectionID, const RawBuffer &rawBuffer) = 0; - virtual void Write(ConnectionID connectionID, const SendMsgData &sendMsgData) = 0; - virtual ~GenericSocketManager(){} + virtual void MainLoop() = 0; + virtual void RegisterSocketService(GenericSocketService *ptr) = 0; + virtual void Close(ConnectionID connectionID) = 0; + virtual void Write(ConnectionID connectionID, const RawBuffer &rawBuffer) = 0; + virtual void Write(ConnectionID connectionID, const SendMsgData &sendMsgData) = 0; + virtual ~GenericSocketManager() {} }; } // namespace AuthPasswd diff --git a/src/server/main/include/service-thread.h b/src/server/main/include/service-thread.h index ea9bfd2..fe9771d 100644 --- a/src/server/main/include/service-thread.h +++ b/src/server/main/include/service-thread.h @@ -38,138 +38,137 @@ #include "generic-event.h" -#define DEFINE_THREAD_EVENT(eventType) \ - void Event(const eventType &event) { \ - AuthPasswd::ServiceThread:: \ - Event(event, \ - this, \ - &ParentClassName::EventInternal##eventType); \ - } \ - void EventInternal##eventType(const eventType &event) - -#define DECLARE_THREAD_EVENT(eventType, methodName) \ - void Event(const eventType &event) { \ - AuthPasswd::ServiceThread:: \ - Event(event, \ - this, \ - &ParentClassName::methodName); \ - } +#define DEFINE_THREAD_EVENT(eventType) \ + void Event(const eventType &event) { \ + AuthPasswd::ServiceThread:: \ + Event(event, \ + this, \ + &ParentClassName::EventInternal##eventType); \ + } \ + void EventInternal##eventType(const eventType &event) + +#define DECLARE_THREAD_EVENT(eventType, methodName) \ + void Event(const eventType &event) { \ + AuthPasswd::ServiceThread:: \ + Event(event, \ + this, \ + &ParentClassName::methodName); \ + } namespace AuthPasswd { template class ServiceThread { public: - typedef Service ParentClassName; - enum class State { - NoThread, - Work, - }; - - ServiceThread() - : m_state(State::NoThread) - , m_quit(false) - {} - - void Create() { - assert(m_state == State::NoThread); - m_thread = std::thread(ThreadLoopStatic, this); - m_state = State::Work; - } - - void Join() { - assert(m_state != State::NoThread); - { - std::lock_guard lock(m_eventQueueMutex); - m_quit = true; - m_waitCondition.notify_one(); - } - m_thread.join(); - m_state = State::NoThread; - } - - virtual ~ServiceThread() - { - assert((m_state == State::NoThread) && "You must stop thread before destruction!"); - - while (!m_eventQueue.empty()){ - auto front = m_eventQueue.front(); - delete front.eventPtr; - m_eventQueue.pop(); - } - } - - template - void Event(const T &event, - Service *servicePtr, - void (Service::*serviceFunction)(const T &)) - { - EventDescription description; - description.serviceFunctionPtr = - reinterpret_cast(serviceFunction); - description.servicePtr = servicePtr; - description.eventFunctionPtr = &ServiceThread::EventCall; - description.eventPtr = new T(event); - { - std::lock_guard lock(m_eventQueueMutex); - m_eventQueue.push(description); - } - m_waitCondition.notify_one(); - } + typedef Service ParentClassName; + enum class State { + NoThread, + Work, + }; + + ServiceThread() : m_state(State::NoThread), m_quit(false) {} + + void Create() { + assert(m_state == State::NoThread); + m_thread = std::thread(ThreadLoopStatic, this); + m_state = State::Work; + } + + void Join() { + assert(m_state != State::NoThread); + + do { + std::lock_guard lock(m_eventQueueMutex); + m_quit = true; + m_waitCondition.notify_one(); + } while (false); + + m_thread.join(); + m_state = State::NoThread; + } + + virtual ~ServiceThread() { + assert((m_state == State::NoThread) && "You must stop thread before destruction!"); + + while (!m_eventQueue.empty()) { + auto front = m_eventQueue.front(); + delete front.eventPtr; + m_eventQueue.pop(); + } + } + + template + void Event(const T &event, + Service *servicePtr, + void (Service::*serviceFunction)(const T &)) { + EventDescription description; + description.serviceFunctionPtr = + reinterpret_cast(serviceFunction); + description.servicePtr = servicePtr; + description.eventFunctionPtr = &ServiceThread::EventCall; + description.eventPtr = new T(event); + + do { + std::lock_guard lock(m_eventQueueMutex); + m_eventQueue.push(description); + } while (false); + + m_waitCondition.notify_one(); + } protected: - - struct EventDescription { - void (Service::*serviceFunctionPtr)(void *); - Service *servicePtr; - void (ServiceThread::*eventFunctionPtr)(const EventDescription &event); - GenericEvent* eventPtr; - }; - - template - void EventCall(const EventDescription &desc) { - auto fun = reinterpret_cast(desc.serviceFunctionPtr); - const T& eventLocale = *(static_cast(desc.eventPtr)); - (desc.servicePtr->*fun)(eventLocale); - } - - static void ThreadLoopStatic(ServiceThread *ptr) { - ptr->ThreadLoop(); - } - - void ThreadLoop(){ - for (;;) { - EventDescription description = {NULL, NULL, NULL, NULL}; - { - std::unique_lock ulock(m_eventQueueMutex); - if (m_quit) - return; - if (!m_eventQueue.empty()) { - description = m_eventQueue.front(); - m_eventQueue.pop(); - } else { - m_waitCondition.wait(ulock); - } - } - - if (description.eventPtr != NULL) { - UNHANDLED_EXCEPTION_HANDLER_BEGIN - { - (this->*description.eventFunctionPtr)(description); - delete description.eventPtr; - } - UNHANDLED_EXCEPTION_HANDLER_END - } - } - } - - std::thread m_thread; - std::mutex m_eventQueueMutex; - std::queue m_eventQueue; - std::condition_variable m_waitCondition; - - State m_state; - bool m_quit; + struct EventDescription { + void (Service::*serviceFunctionPtr)(void *); + Service *servicePtr; + void (ServiceThread::*eventFunctionPtr)(const EventDescription &event); + GenericEvent *eventPtr; + }; + + template + void EventCall(const EventDescription &desc) { + auto fun = reinterpret_cast(desc.serviceFunctionPtr); + const T &eventLocale = *(static_cast(desc.eventPtr)); + (desc.servicePtr->*fun)(eventLocale); + } + + static void ThreadLoopStatic(ServiceThread *ptr) { + ptr->ThreadLoop(); + } + + void ThreadLoop() { + for (;;) { + EventDescription description = {NULL, NULL, NULL, NULL}; + do { + std::unique_lock ulock(m_eventQueueMutex); + + if (m_quit) + return; + + if (!m_eventQueue.empty()) { + description = m_eventQueue.front(); + m_eventQueue.pop(); + } else { + m_waitCondition.wait(ulock); + } + } while (false); + + if (description.eventPtr != NULL) { + UNHANDLED_EXCEPTION_HANDLER_BEGIN { + (this->*description.eventFunctionPtr)(description); + delete description.eventPtr; + } + UNHANDLED_EXCEPTION_HANDLER_END + } + } + } + + std::thread m_thread; + std::mutex m_eventQueueMutex; + std::queue m_eventQueue; + std::condition_variable m_waitCondition; + + State m_state; + bool m_quit; }; } // namespace AuthPasswd diff --git a/src/server/main/include/socket-manager.h b/src/server/main/include/socket-manager.h index 75bc815..4c63e02 100644 --- a/src/server/main/include/socket-manager.h +++ b/src/server/main/include/socket-manager.h @@ -39,95 +39,97 @@ namespace AuthPasswd { class SocketManager : public GenericSocketManager { public: - class Exception { - public: - DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) - DECLARE_EXCEPTION_TYPE(Base, InitFailed) - }; - SocketManager(); - virtual ~SocketManager(); - virtual void MainLoop(); - virtual void MainLoopStop(); - - virtual void RegisterSocketService(GenericSocketService *service); - virtual void Close(ConnectionID connectionID); - virtual void Write(ConnectionID connectionID, const RawBuffer &rawBuffer); - virtual void Write(ConnectionID connectionID, const SendMsgData &sendMsgData); + class Exception { + public: + DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, InitFailed) + }; + SocketManager(); + virtual ~SocketManager(); + virtual void MainLoop(); + virtual void MainLoopStop(); + + virtual void RegisterSocketService(GenericSocketService *service); + virtual void Close(ConnectionID connectionID); + virtual void Write(ConnectionID connectionID, const RawBuffer &rawBuffer); + virtual void Write(ConnectionID connectionID, const SendMsgData &sendMsgData); protected: - void CreateDomainSocket( - GenericSocketService *service, - const GenericSocketService::ServiceDescription &desc); - int CreateDomainSocketHelp( - const GenericSocketService::ServiceDescription &desc); - int GetSocketFromSystemD( - const GenericSocketService::ServiceDescription &desc); - - void ReadyForRead(int sock); - void ReadyForWrite(int sock); - void ReadyForWriteBuffer(int sock); - void ReadyForSendMsg(int sock); - void ReadyForAccept(int sock); - void ProcessQueue(void); - void NotifyMe(void); - void CloseSocket(int sock); - - struct SocketDescription { - bool isListen; - bool isOpen; - bool isTimeout; - bool useSendMsg; - InterfaceID interfaceID; - GenericSocketService *service; - time_t timeout; - RawBuffer rawBuffer; - std::queue sendMsgDataQueue; - int counter; - - SocketDescription() - : isListen(false) - , isOpen(false) - , isTimeout(false) - , useSendMsg(false) - , interfaceID(-1) - , service(NULL) - {} - }; - - SocketDescription& CreateDefaultReadSocketDescription(int sock, bool timeout, InterfaceID ifaceID = 0, GenericSocketService *service = NULL); - - typedef std::vector SocketDescriptionVector; - - struct WriteBuffer { - ConnectionID connectionID; - RawBuffer rawBuffer; - }; - - struct WriteData { - ConnectionID connectionID; - SendMsgData sendMsgData; - }; - - struct Timeout { - time_t time; - int sock; - bool operator<(const Timeout &second) const { - return time > second.time; // mininum first! - } - }; - - SocketDescriptionVector m_socketDescriptionVector; - fd_set m_readSet; - fd_set m_writeSet; - int m_maxDesc; - bool m_working; - std::mutex m_eventQueueMutex; - std::queue m_writeBufferQueue; - std::queue m_writeDataQueue; - std::queue m_closeQueue; - int m_notifyMe[2]; - int m_counter; - std::priority_queue m_timeoutQueue; + void CreateDomainSocket( + GenericSocketService *service, + const GenericSocketService::ServiceDescription &desc); + int CreateDomainSocketHelp( + const GenericSocketService::ServiceDescription &desc); + int GetSocketFromSystemD( + const GenericSocketService::ServiceDescription &desc); + + void ReadyForRead(int sock); + void ReadyForWrite(int sock); + void ReadyForWriteBuffer(int sock); + void ReadyForSendMsg(int sock); + void ReadyForAccept(int sock); + void ProcessQueue(void); + void NotifyMe(void); + void CloseSocket(int sock); + + struct SocketDescription { + bool isListen; + bool isOpen; + bool isTimeout; + bool useSendMsg; + InterfaceID interfaceID; + GenericSocketService *service; + time_t timeout; + RawBuffer rawBuffer; + std::queue sendMsgDataQueue; + int counter; + + SocketDescription() + : isListen(false) + , isOpen(false) + , isTimeout(false) + , useSendMsg(false) + , interfaceID(-1) + , service(NULL) + {} + }; + + SocketDescription &CreateDefaultReadSocketDescription(int sock, bool timeout, + InterfaceID ifaceID = 0, GenericSocketService *service = NULL); + + typedef std::vector SocketDescriptionVector; + + struct WriteBuffer { + ConnectionID connectionID; + RawBuffer rawBuffer; + }; + + struct WriteData { + ConnectionID connectionID; + SendMsgData sendMsgData; + }; + + struct Timeout { + time_t time; + int sock; + bool operator<(const Timeout &second) const + { + return time > second.time; // mininum first! + } + }; + + SocketDescriptionVector m_socketDescriptionVector; + fd_set m_readSet; + fd_set m_writeSet; + int m_maxDesc; + bool m_working; + std::mutex m_eventQueueMutex; + std::queue m_writeBufferQueue; + std::queue m_writeDataQueue; + std::queue m_closeQueue; + int m_notifyMe[2]; + int m_counter; + std::priority_queue m_timeoutQueue; }; } // namespace AuthPasswd diff --git a/src/server/main/server-main.cpp b/src/server/main/server-main.cpp index 0850300..2437439 100644 --- a/src/server/main/server-main.cpp +++ b/src/server/main/server-main.cpp @@ -35,54 +35,55 @@ IMPLEMENT_SAFE_SINGLETON(AuthPasswd::Log::LogSystem); #define REGISTER_SOCKET_SERVICE(manager, service) \ - registerSocketService(manager, #service) + registerSocketService(manager, #service) template -void registerSocketService(AuthPasswd::SocketManager &manager, const std::string& serviceName) +void registerSocketService(AuthPasswd::SocketManager &manager, const std::string &serviceName) { - T *service = NULL; - try { - service = new T(); - service->Start(); - manager.RegisterSocketService(service); - service = NULL; - } catch (const AuthPasswd::Exception &exception) { - LogError("Error in creating service " << serviceName << - ", details:\n" << exception.DumpToString()); - } catch (const std::exception& e) { - LogError("Error in creating service " << serviceName << - ", details:\n" << e.what()); - } catch (...) { - LogError("Error in creating service " << serviceName << - ", unknown exception occured"); - } - if (service) - delete service; + T *service = NULL; + + try { + service = new T(); + service->Start(); + manager.RegisterSocketService(service); + service = NULL; + } catch (const AuthPasswd::Exception &exception) { + LogError("Error in creating service " << serviceName << + ", details:\n" << exception.DumpToString()); + } catch (const std::exception &e) { + LogError("Error in creating service " << serviceName << + ", details:\n" << e.what()); + } catch (...) { + LogError("Error in creating service " << serviceName << + ", unknown exception occured"); + } + + if (service) + delete service; } -int main(void) { +int main(void) +{ + UNHANDLED_EXCEPTION_HANDLER_BEGIN { + AuthPasswd::Singleton::Instance().SetTag("AUTH_PASSWD"); - UNHANDLED_EXCEPTION_HANDLER_BEGIN - { - AuthPasswd::Singleton::Instance().SetTag("AUTH_PASSWD"); + sigset_t mask; + sigemptyset(&mask); + sigaddset(&mask, SIGTERM); + sigaddset(&mask, SIGPIPE); - sigset_t mask; - sigemptyset(&mask); - sigaddset(&mask, SIGTERM); - sigaddset(&mask, SIGPIPE); - if (-1 == pthread_sigmask(SIG_BLOCK, &mask, NULL)) { - LogError("Error in pthread_sigmask"); - return 1; - } + if (-1 == pthread_sigmask(SIG_BLOCK, &mask, NULL)) { + LogError("Error in pthread_sigmask"); + return 1; + } - LogInfo("Start!"); - AuthPasswd::SocketManager manager; + LogInfo("Start!"); + AuthPasswd::SocketManager manager; - REGISTER_SOCKET_SERVICE(manager, AuthPasswd::PasswordService); + REGISTER_SOCKET_SERVICE(manager, AuthPasswd::PasswordService); - manager.MainLoop(); - } - UNHANDLED_EXCEPTION_HANDLER_END - return 0; + manager.MainLoop(); + } + UNHANDLED_EXCEPTION_HANDLER_END + return 0; } - diff --git a/src/server/main/smack-check.cpp b/src/server/main/smack-check.cpp index 5edf69a..5c3b3b9 100644 --- a/src/server/main/smack-check.cpp +++ b/src/server/main/smack-check.cpp @@ -30,25 +30,27 @@ namespace AuthPasswd { int smack_runtime_check(void) { - static int smack_present = -1; - if (-1 == smack_present) { - if (NULL == smack_smackfs_path()) { - LogDebug("no smack found on device"); - smack_present = 0; - } else { - LogDebug("found smack on device"); - smack_present = 1; - } - } - return smack_present; + static int smack_present = -1; + + if (-1 == smack_present) { + if (NULL == smack_smackfs_path()) { + LogDebug("no smack found on device"); + smack_present = 0; + } else { + LogDebug("found smack on device"); + smack_present = 1; + } + } + + return smack_present; } int smack_check(void) { #ifndef SMACK_ENABLED - return 0; + return 0; #else - return smack_runtime_check(); + return smack_runtime_check(); #endif } diff --git a/src/server/main/socket-manager.cpp b/src/server/main/socket-manager.cpp index 4852173..4361179 100644 --- a/src/server/main/socket-manager.cpp +++ b/src/server/main/socket-manager.cpp @@ -56,711 +56,729 @@ const time_t SOCKET_TIMEOUT = 300; namespace AuthPasswd { struct DummyService : public GenericSocketService { - ServiceDescriptionVector GetServiceDescription() { - return ServiceDescriptionVector(); - } + ServiceDescriptionVector GetServiceDescription() { + return ServiceDescriptionVector(); + } - void Start() {} - void Stop() {} + void Start() {} + void Stop() {} - void Event(const AcceptEvent &event) { (void)event; } - void Event(const WriteEvent &event) { (void)event; } - void Event(const ReadEvent &event) { (void)event; } - void Event(const CloseEvent &event) { (void)event; } + void Event(const AcceptEvent &) {} + void Event(const WriteEvent &) {} + void Event(const ReadEvent &) {} + void Event(const CloseEvent &) {} }; struct SignalService : public GenericSocketService { - int GetDescriptor() { - LogInfo("set up"); - sigset_t mask; - sigemptyset(&mask); - sigaddset(&mask, SIGTERM); - if (-1 == pthread_sigmask(SIG_BLOCK, &mask, NULL)) - return -1; - return signalfd(-1, &mask, 0); - } - - ServiceDescriptionVector GetServiceDescription() { - return ServiceDescriptionVector(); - } - - void Start() {} - void Stop() {} - - void Event(const AcceptEvent &event) { (void)event; } // not supported - void Event(const WriteEvent &event) { (void)event; } // not supported - void Event(const CloseEvent &event) { (void)event; } // not supported - - void Event(const ReadEvent &event) { - LogDebug("Get signal information"); - - if(sizeof(struct signalfd_siginfo) != event.rawBuffer.size()) { - LogError("Wrong size of signalfd_siginfo struct. Expected: " - << sizeof(signalfd_siginfo) << " Get: " - << event.rawBuffer.size()); - return; - } - - const signalfd_siginfo *siginfo = reinterpret_cast( - reinterpret_cast(event.rawBuffer.data())); - - if (siginfo->ssi_signo == SIGTERM) { - LogInfo("Got signal: SIGTERM"); - static_cast(m_serviceManager)->MainLoopStop(); - return; - } - - LogInfo("This should not happend. Got signal: " << siginfo->ssi_signo); - } + int GetDescriptor() { + LogInfo("set up"); + sigset_t mask; + sigemptyset(&mask); + sigaddset(&mask, SIGTERM); + + if (-1 == pthread_sigmask(SIG_BLOCK, &mask, NULL)) + return -1; + + return signalfd(-1, &mask, 0); + } + + ServiceDescriptionVector GetServiceDescription() { + return ServiceDescriptionVector(); + } + + void Start() {} + void Stop() {} + + void Event(const AcceptEvent &) {} + void Event(const WriteEvent &) {} + void Event(const CloseEvent &) {} + + void Event(const ReadEvent &event) { + LogDebug("Get signal information"); + + if (sizeof(struct signalfd_siginfo) != event.rawBuffer.size()) { + LogError("Wrong size of signalfd_siginfo struct. Expected: " + << sizeof(signalfd_siginfo) << " Get: " + << event.rawBuffer.size()); + return; + } + + const signalfd_siginfo *siginfo = reinterpret_cast( + reinterpret_cast(event.rawBuffer.data())); + + if (siginfo->ssi_signo == SIGTERM) { + LogInfo("Got signal: SIGTERM"); + static_cast(m_serviceManager)->MainLoopStop(); + return; + } + + LogInfo("This should not happend. Got signal: " << siginfo->ssi_signo); + } }; -SocketManager::SocketDescription& -SocketManager::CreateDefaultReadSocketDescription(int sock, bool timeout, InterfaceID ifaceID /*= 0*/, GenericSocketService *service /* = NULL*/) +SocketManager::SocketDescription & +SocketManager::CreateDefaultReadSocketDescription(int sock, bool timeout, + InterfaceID ifaceID /*= 0*/, GenericSocketService *service /* = NULL*/) { - if ((int)m_socketDescriptionVector.size() <= sock) - m_socketDescriptionVector.resize(sock+20); - - auto &desc = m_socketDescriptionVector[sock]; - desc.isListen = false; - desc.isOpen = true; - desc.interfaceID = ifaceID; - desc.service = service; - desc.counter = ++m_counter; - - if (timeout) { - desc.timeout = time(NULL) + SOCKET_TIMEOUT; - if (false == desc.isTimeout) { - Timeout tm; - tm.time = desc.timeout; - tm.sock = sock; - m_timeoutQueue.push(tm); - } - } - - desc.isTimeout = timeout; - - FD_SET(sock, &m_readSet); - m_maxDesc = sock > m_maxDesc ? sock : m_maxDesc; - return desc; + if ((int)m_socketDescriptionVector.size() <= sock) + m_socketDescriptionVector.resize(sock + 20); + + auto &desc = m_socketDescriptionVector[sock]; + desc.isListen = false; + desc.isOpen = true; + desc.interfaceID = ifaceID; + desc.service = service; + desc.counter = ++m_counter; + + if (timeout) { + desc.timeout = time(NULL) + SOCKET_TIMEOUT; + + if (false == desc.isTimeout) { + Timeout tm; + tm.time = desc.timeout; + tm.sock = sock; + m_timeoutQueue.push(tm); + } + } + + desc.isTimeout = timeout; + FD_SET(sock, &m_readSet); + m_maxDesc = sock > m_maxDesc ? sock : m_maxDesc; + return desc; } -SocketManager::SocketManager() - : m_maxDesc(0) - , m_counter(0) +SocketManager::SocketManager() : + m_maxDesc(0), + m_counter(0) { - FD_ZERO(&m_readSet); - FD_ZERO(&m_writeSet); - if (-1 == pipe(m_notifyMe)) { - int err = errno; - ThrowMsg(Exception::InitFailed, "Error in pipe: " << errnoToString(err)); - } - LogInfo("Pipe: Read desc: " << m_notifyMe[0] << " Write desc: " << m_notifyMe[1]); - - auto &desc = CreateDefaultReadSocketDescription(m_notifyMe[0], false); - desc.service = new DummyService; - - // std::thread bases on pthread so this should work fine - sigset_t set; - sigemptyset(&set); - sigaddset(&set, SIGPIPE); - pthread_sigmask(SIG_BLOCK, &set, NULL); - - // add support for TERM signal (passed from systemd) - auto *signalService = new SignalService; - signalService->SetSocketManager(this); - int filefd = signalService->GetDescriptor(); - if (-1 == filefd) { - LogError("Error in SignalService.GetDescriptor()"); - delete signalService; - } else { - auto &desc2 = CreateDefaultReadSocketDescription(filefd, false); - desc2.service = signalService; - LogInfo("SignalService mounted on " << filefd << " descriptor"); - } + FD_ZERO(&m_readSet); + FD_ZERO(&m_writeSet); + + if (-1 == pipe(m_notifyMe)) { + int err = errno; + ThrowMsg(Exception::InitFailed, "Error in pipe: " << errnoToString(err)); + } + + LogInfo("Pipe: Read desc: " << m_notifyMe[0] << " Write desc: " << m_notifyMe[1]); + auto &desc = CreateDefaultReadSocketDescription(m_notifyMe[0], false); + desc.service = new DummyService; + // std::thread bases on pthread so this should work fine + sigset_t set; + sigemptyset(&set); + sigaddset(&set, SIGPIPE); + pthread_sigmask(SIG_BLOCK, &set, NULL); + // add support for TERM signal (passed from systemd) + auto *signalService = new SignalService; + signalService->SetSocketManager(this); + int filefd = signalService->GetDescriptor(); + + if (-1 == filefd) { + LogError("Error in SignalService.GetDescriptor()"); + delete signalService; + } else { + auto &desc2 = CreateDefaultReadSocketDescription(filefd, false); + desc2.service = signalService; + LogInfo("SignalService mounted on " << filefd << " descriptor"); + } } -SocketManager::~SocketManager() { - std::set serviceMap; - - // Find all services. Set is used to remove duplicates. - // In this implementation, services are not able to react in any way. - for (size_t i=0; i < m_socketDescriptionVector.size(); ++i) - if (m_socketDescriptionVector[i].isOpen) - serviceMap.insert(m_socketDescriptionVector[i].service); - - // Time to destroy all services. - for(auto service : serviceMap) { - LogDebug("delete " << (void*)(service)); - service->Stop(); - delete service; - } - - for (size_t i = 0; i < m_socketDescriptionVector.size(); ++i) - if (m_socketDescriptionVector[i].isOpen) - close(i); - - // All socket except one were closed. Now pipe input must be closed. - close(m_notifyMe[1]); +SocketManager::~SocketManager() +{ + std::set serviceMap; + + // Find all services. Set is used to remove duplicates. + // In this implementation, services are not able to react in any way. + for (size_t i = 0; i < m_socketDescriptionVector.size(); ++i) + if (m_socketDescriptionVector[i].isOpen) + serviceMap.insert(m_socketDescriptionVector[i].service); + + // Time to destroy all services. + for (auto service : serviceMap) { + LogDebug("delete " << (void *)(service)); + service->Stop(); + delete service; + } + + for (size_t i = 0; i < m_socketDescriptionVector.size(); ++i) + if (m_socketDescriptionVector[i].isOpen) + close(i); + + // All socket except one were closed. Now pipe input must be closed. + close(m_notifyMe[1]); } -void SocketManager::ReadyForAccept(int sock) { - struct sockaddr_un clientAddr; - unsigned int clientLen = sizeof(clientAddr); - int client = accept4(sock, (struct sockaddr*) &clientAddr, &clientLen, SOCK_NONBLOCK); -// LogInfo("Accept on sock: " << sock << " Socket opended: " << client); - if (-1 == client) { - int err = errno; - LogDebug("Error in accept: " << errnoToString(err)); - return; - } - - auto &desc = CreateDefaultReadSocketDescription(client, false); - desc.interfaceID = m_socketDescriptionVector[sock].interfaceID; - desc.service = m_socketDescriptionVector[sock].service; - desc.useSendMsg = m_socketDescriptionVector[sock].useSendMsg; - - GenericSocketService::AcceptEvent event; - event.connectionID.sock = client; - event.connectionID.counter = desc.counter; - event.interfaceID = desc.interfaceID; - desc.service->Event(event); +void SocketManager::ReadyForAccept(int sock) +{ + struct sockaddr_un clientAddr; + unsigned int clientLen = sizeof(clientAddr); + int client = accept4(sock, (struct sockaddr *) &clientAddr, &clientLen, SOCK_NONBLOCK); + + // LogInfo("Accept on sock: " << sock << " Socket opended: " << client); + if (-1 == client) { + int err = errno; + LogDebug("Error in accept: " << errnoToString(err)); + return; + } + + auto &desc = CreateDefaultReadSocketDescription(client, false); + desc.interfaceID = m_socketDescriptionVector[sock].interfaceID; + desc.service = m_socketDescriptionVector[sock].service; + desc.useSendMsg = m_socketDescriptionVector[sock].useSendMsg; + GenericSocketService::AcceptEvent event; + event.connectionID.sock = client; + event.connectionID.counter = desc.counter; + event.interfaceID = desc.interfaceID; + desc.service->Event(event); } -void SocketManager::ReadyForRead(int sock) { - if (m_socketDescriptionVector[sock].isListen) { - ReadyForAccept(sock); - return; - } - - auto &desc = m_socketDescriptionVector[sock]; - GenericSocketService::ReadEvent event; - event.connectionID.sock = sock; - event.connectionID.counter = m_socketDescriptionVector[sock].counter; - event.interfaceID = desc.interfaceID; - event.rawBuffer.resize(4096); - - desc.timeout = time(NULL) + SOCKET_TIMEOUT; - - ssize_t size = read(sock, &event.rawBuffer[0], 4096); - - if (size == 0) { - CloseSocket(sock); - } else if (size >= 0) { - event.rawBuffer.resize(size); - desc.service->Event(event); - } else if (size == -1) { - int err = errno; - switch(err) { - case EAGAIN: - case EINTR: - break; - default: - LogDebug("Reading sock error: " << errnoToString(err)); - CloseSocket(sock); - } - } +void SocketManager::ReadyForRead(int sock) +{ + if (m_socketDescriptionVector[sock].isListen) { + ReadyForAccept(sock); + return; + } + + auto &desc = m_socketDescriptionVector[sock]; + GenericSocketService::ReadEvent event; + event.connectionID.sock = sock; + event.connectionID.counter = m_socketDescriptionVector[sock].counter; + event.interfaceID = desc.interfaceID; + event.rawBuffer.resize(4096); + desc.timeout = time(NULL) + SOCKET_TIMEOUT; + ssize_t size = read(sock, &event.rawBuffer[0], 4096); + + if (size == 0) { + CloseSocket(sock); + } else if (size >= 0) { + event.rawBuffer.resize(size); + desc.service->Event(event); + } else if (size == -1) { + int err = errno; + + switch (err) { + case EAGAIN: + case EINTR: + break; + + default: + LogDebug("Reading sock error: " << errnoToString(err)); + CloseSocket(sock); + } + } } -void SocketManager::ReadyForSendMsg(int sock) { - auto &desc = m_socketDescriptionVector[sock]; - - if (desc.sendMsgDataQueue.empty()) { - FD_CLR(sock, &m_writeSet); - return; - } - - auto data = desc.sendMsgDataQueue.front(); - ssize_t result = sendmsg(sock, data.getMsghdr(), data.flags()); - - if (result == -1) { - int err = errno; - switch(err) { - case EAGAIN: - case EINTR: - break; - case EPIPE: - default: - LogDebug("Error during send: " << errnoToString(err)); - CloseSocket(sock); - break; - } - return; - } else { - desc.sendMsgDataQueue.pop(); - } - - if (desc.sendMsgDataQueue.empty()) { - FD_CLR(sock, &m_writeSet); - } - - desc.timeout = time(NULL) + SOCKET_TIMEOUT; - - GenericSocketService::WriteEvent event; - event.connectionID.sock = sock; - event.connectionID.counter = desc.counter; - event.size = result; - event.left = desc.sendMsgDataQueue.size(); - - desc.service->Event(event); +void SocketManager::ReadyForSendMsg(int sock) +{ + auto &desc = m_socketDescriptionVector[sock]; + + if (desc.sendMsgDataQueue.empty()) { + FD_CLR(sock, &m_writeSet); + return; + } + + auto data = desc.sendMsgDataQueue.front(); + ssize_t result = sendmsg(sock, data.getMsghdr(), data.flags()); + + if (result == -1) { + int err = errno; + + switch (err) { + case EAGAIN: + case EINTR: + break; + + case EPIPE: + default: + LogDebug("Error during send: " << errnoToString(err)); + CloseSocket(sock); + break; + } + + return; + } else { + desc.sendMsgDataQueue.pop(); + } + + if (desc.sendMsgDataQueue.empty()) + FD_CLR(sock, &m_writeSet); + + desc.timeout = time(NULL) + SOCKET_TIMEOUT; + GenericSocketService::WriteEvent event; + event.connectionID.sock = sock; + event.connectionID.counter = desc.counter; + event.size = result; + event.left = desc.sendMsgDataQueue.size(); + desc.service->Event(event); } -void SocketManager::ReadyForWriteBuffer(int sock) { - auto &desc = m_socketDescriptionVector[sock]; - size_t size = desc.rawBuffer.size(); - ssize_t result = write(sock, &desc.rawBuffer[0], size); - if (result == -1) { - int err = errno; - switch(err) { - case EAGAIN: - case EINTR: - // select will trigger write once again, nothing to do - break; - case EPIPE: - default: - LogDebug("Error during write: " << errnoToString(err)); - CloseSocket(sock); - break; - } - return; // We do not want to propagate error to next layer - } - - desc.rawBuffer.erase(desc.rawBuffer.begin(), desc.rawBuffer.begin()+result); - - desc.timeout = time(NULL) + SOCKET_TIMEOUT; - - if (desc.rawBuffer.empty()) - FD_CLR(sock, &m_writeSet); - - GenericSocketService::WriteEvent event; - event.connectionID.sock = sock; - event.connectionID.counter = desc.counter; - event.size = result; - event.left = desc.rawBuffer.size(); - - desc.service->Event(event); +void SocketManager::ReadyForWriteBuffer(int sock) +{ + auto &desc = m_socketDescriptionVector[sock]; + size_t size = desc.rawBuffer.size(); + ssize_t result = write(sock, &desc.rawBuffer[0], size); + + if (result == -1) { + int err = errno; + + switch (err) { + case EAGAIN: + case EINTR: + // select will trigger write once again, nothing to do + break; + + case EPIPE: + default: + LogDebug("Error during write: " << errnoToString(err)); + CloseSocket(sock); + break; + } + + return; // We do not want to propagate error to next layer + } + + desc.rawBuffer.erase(desc.rawBuffer.begin(), desc.rawBuffer.begin() + result); + desc.timeout = time(NULL) + SOCKET_TIMEOUT; + + if (desc.rawBuffer.empty()) + FD_CLR(sock, &m_writeSet); + + GenericSocketService::WriteEvent event; + event.connectionID.sock = sock; + event.connectionID.counter = desc.counter; + event.size = result; + event.left = desc.rawBuffer.size(); + desc.service->Event(event); } -void SocketManager::ReadyForWrite(int sock) { - m_socketDescriptionVector[sock].useSendMsg ? - ReadyForSendMsg(sock) : ReadyForWriteBuffer(sock); +void SocketManager::ReadyForWrite(int sock) +{ + m_socketDescriptionVector[sock].useSendMsg ? + ReadyForSendMsg(sock) : ReadyForWriteBuffer(sock); } -void SocketManager::MainLoop() { - // remove evironment values passed by systemd - // uncomment it after removing old authentication password code - // sd_listen_fds(1); - - // Daemon is ready to work. - sd_notify(0, "READY=1"); - - m_working = true; - while(m_working) { - fd_set readSet = m_readSet; - fd_set writeSet = m_writeSet; - - timeval localTempTimeout; - timeval *ptrTimeout = &localTempTimeout; - - // I need to extract timeout from priority_queue. - // Timeout in priority_queue may be deprecated. - // I need to find some actual one. - while(!m_timeoutQueue.empty()) { - auto &top = m_timeoutQueue.top(); - auto &desc = m_socketDescriptionVector[top.sock]; - - if (top.time == desc.timeout) { - // This timeout matches timeout from socket. - // It can be used. - break; - } else { - // This socket was used after timeout in priority queue was set up. - // We need to update timeout and find some useable one. - Timeout tm = { desc.timeout , top.sock}; - m_timeoutQueue.pop(); - m_timeoutQueue.push(tm); - } - } - - if (m_timeoutQueue.empty()) { - LogDebug("No usaable timeout found."); - ptrTimeout = NULL; // select will wait without timeout - } else { - time_t currentTime = time(NULL); - auto &pqTimeout = m_timeoutQueue.top(); - - // 0 means that select won't block and socket will be closed ;-) - ptrTimeout->tv_sec = - currentTime < pqTimeout.time ? pqTimeout.time - currentTime : 0; - ptrTimeout->tv_usec = 0; -// LogDebug("Set up timeout: " << (int)ptrTimeout->tv_sec -// << " seconds. Socket: " << pqTimeout.sock); - } - - int ret = select(m_maxDesc+1, &readSet, &writeSet, NULL, ptrTimeout); - - if (0 == ret) { // timeout - Assert(!m_timeoutQueue.empty()); - - Timeout pqTimeout = m_timeoutQueue.top(); - m_timeoutQueue.pop(); - - auto &desc = m_socketDescriptionVector[pqTimeout.sock]; - - if (!desc.isTimeout || !desc.isOpen) { - // Connection was closed. Timeout is useless... - desc.isTimeout = false; - continue; - } - - if (pqTimeout.time < desc.timeout) { - // Is it possible? - // This socket was used after timeout. We need to update timeout. - pqTimeout.time = desc.timeout; - m_timeoutQueue.push(pqTimeout); - continue; - } - - // timeout from m_timeoutQueue matches with socket.timeout - // and connection is open. Time to close it! - // Putting new timeout in queue here is pointless. - desc.isTimeout = false; - CloseSocket(pqTimeout.sock); - - // All done. Now we should process next select ;-) - continue; - } - - if (-1 == ret) { - switch(errno) { - case EINTR: - LogDebug("EINTR in select"); - break; - default: - int err = errno; - LogError("Error in select: " << errnoToString(err)); - return; - } - continue; - } - for(int i = 0; itv_sec = + currentTime < pqTimeout.time ? pqTimeout.time - currentTime : 0; + ptrTimeout->tv_usec = 0; + // LogDebug("Set up timeout: " << (int)ptrTimeout->tv_sec + // << " seconds. Socket: " << pqTimeout.sock); + } + + int ret = select(m_maxDesc + 1, &readSet, &writeSet, NULL, ptrTimeout); + + if (0 == ret) { // timeout + Assert(!m_timeoutQueue.empty()); + Timeout pqTimeout = m_timeoutQueue.top(); + m_timeoutQueue.pop(); + auto &desc = m_socketDescriptionVector[pqTimeout.sock]; + + if (!desc.isTimeout || !desc.isOpen) { + // Connection was closed. Timeout is useless... + desc.isTimeout = false; + continue; + } + + if (pqTimeout.time < desc.timeout) { + // Is it possible? + // This socket was used after timeout. We need to update timeout. + pqTimeout.time = desc.timeout; + m_timeoutQueue.push(pqTimeout); + continue; + } + + // timeout from m_timeoutQueue matches with socket.timeout + // and connection is open. Time to close it! + // Putting new timeout in queue here is pointless. + desc.isTimeout = false; + CloseSocket(pqTimeout.sock); + // All done. Now we should process next select ;-) + continue; + } + + if (-1 == ret) { + switch (errno) { + case EINTR: + LogDebug("EINTR in select"); + break; + + default: + int err = errno; + LogError("Error in select: " << errnoToString(err)); + return; + } + + continue; + } + + for (int i = 0; i < m_maxDesc + 1 && ret; ++i) { + if (FD_ISSET(i, &readSet)) { + ReadyForRead(i); + --ret; + } + + if (FD_ISSET(i, &writeSet)) { + ReadyForWrite(i); + --ret; + } + } + + ProcessQueue(); + } } void SocketManager::MainLoopStop() { - m_working = false; - NotifyMe(); + m_working = false; + NotifyMe(); } int SocketManager::GetSocketFromSystemD( - const GenericSocketService::ServiceDescription &desc) + const GenericSocketService::ServiceDescription &desc) { - int fd; - - // TODO optimalization - do it once in object constructor - // and remember all information path->sockfd - int n = sd_listen_fds(0); - - LogInfo("sd_listen_fds returns: " << n); - - if (n < 0) { - LogError("Error in sd_listend_fds"); - ThrowMsg(Exception::InitFailed, "Error in sd_listend_fds"); - } - - for(fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START+n; ++fd) { - if (0 < sd_is_socket_unix(fd, SOCK_STREAM, 1, - desc.serviceHandlerPath.c_str(), 0)) - { - LogInfo("Useable socket " << desc.serviceHandlerPath << - " was passed by SystemD under descriptor " << fd); - - return fd; - } - } - LogInfo("No useable sockets were passed by systemd."); - return -1; + int fd; + // TODO optimalization - do it once in object constructor + // and remember all information path->sockfd + int n = sd_listen_fds(0); + LogInfo("sd_listen_fds returns: " << n); + + if (n < 0) { + LogError("Error in sd_listend_fds"); + ThrowMsg(Exception::InitFailed, "Error in sd_listend_fds"); + } + + for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; ++fd) { + if (0 < sd_is_socket_unix(fd, SOCK_STREAM, 1, + desc.serviceHandlerPath.c_str(), 0)) { + LogInfo("Useable socket " << desc.serviceHandlerPath << + " was passed by SystemD under descriptor " << fd); + return fd; + } + } + + LogInfo("No useable sockets were passed by systemd."); + return -1; } int SocketManager::CreateDomainSocketHelp( - const GenericSocketService::ServiceDescription &desc) + const GenericSocketService::ServiceDescription &desc) { - int sockfd; - - GenericSocketService::ServiceHandlerPath::size_type maxlen = - sizeof(static_cast(nullptr)->sun_path) / - sizeof(GenericSocketService::ServiceHandlerPath::value_type); - if(desc.serviceHandlerPath.size() >= maxlen) { - LogError("Service handler path too long: " << desc.serviceHandlerPath.size()); - ThrowMsg(Exception::InitFailed, - "Service handler path too long: " << desc.serviceHandlerPath.size()); - } - - if (-1 == (sockfd = socket(AF_UNIX, SOCK_STREAM, 0))) { - int err = errno; - LogError("Error in socket: " << errnoToString(err)); - ThrowMsg(Exception::InitFailed, "Error in socket: " << errnoToString(err)); - } - - if (smack_check()) { - LogInfo("Set up smack label: " << desc.smackLabel); - - if (0 != smack_fsetlabel(sockfd, desc.smackLabel.c_str(), SMACK_LABEL_IPIN)) { - LogError("Error in smack_fsetlabel"); - ThrowMsg(Exception::InitFailed, "Error in smack_fsetlabel"); - } - } else { - LogInfo("No smack on platform. Socket won't be securied with smack label!"); - } - - int flags; - if (-1 == (flags = fcntl(sockfd, F_GETFL, 0))) - flags = 0; - - if (-1 == fcntl(sockfd, F_SETFL, flags | O_NONBLOCK)) { - int err = errno; - close(sockfd); - LogError("Error in fcntl: " << errnoToString(err)); - ThrowMsg(Exception::InitFailed, "Error in fcntl: " << errnoToString(err)); - } - - sockaddr_un serverAddress; - memset(&serverAddress, 0, sizeof(serverAddress)); - serverAddress.sun_family = AF_UNIX; - strncpy(serverAddress.sun_path, desc.serviceHandlerPath.c_str(), sizeof(serverAddress.sun_path) - 1); - unlink(serverAddress.sun_path); - - mode_t originalUmask; - originalUmask = umask(0); - - if (-1 == bind(sockfd, (struct sockaddr*)&serverAddress, sizeof(serverAddress))) { - int err = errno; - close(sockfd); - LogError("Error in bind: " << errnoToString(err)); - ThrowMsg(Exception::InitFailed, "Error in bind: " << errnoToString(err)); - } - - umask(originalUmask); - - if (-1 == listen(sockfd, 5)) { - int err = errno; - close(sockfd); - LogError("Error in listen: " << errnoToString(err)); - ThrowMsg(Exception::InitFailed, "Error in listen: " << errnoToString(err)); - } - - return sockfd; + int sockfd; + GenericSocketService::ServiceHandlerPath::size_type maxlen = + sizeof(static_cast(nullptr)->sun_path) / + sizeof(GenericSocketService::ServiceHandlerPath::value_type); + + if (desc.serviceHandlerPath.size() >= maxlen) { + LogError("Service handler path too long: " << desc.serviceHandlerPath.size()); + ThrowMsg(Exception::InitFailed, + "Service handler path too long: " << desc.serviceHandlerPath.size()); + } + + if (-1 == (sockfd = socket(AF_UNIX, SOCK_STREAM, 0))) { + int err = errno; + LogError("Error in socket: " << errnoToString(err)); + ThrowMsg(Exception::InitFailed, "Error in socket: " << errnoToString(err)); + } + + if (smack_check()) { + LogInfo("Set up smack label: " << desc.smackLabel); + + if (0 != smack_fsetlabel(sockfd, desc.smackLabel.c_str(), SMACK_LABEL_IPIN)) { + LogError("Error in smack_fsetlabel"); + ThrowMsg(Exception::InitFailed, "Error in smack_fsetlabel"); + } + } else + LogInfo("No smack on platform. Socket won't be securied with smack label!"); + + int flags; + + if (-1 == (flags = fcntl(sockfd, F_GETFL, 0))) + flags = 0; + + if (-1 == fcntl(sockfd, F_SETFL, flags | O_NONBLOCK)) { + int err = errno; + close(sockfd); + LogError("Error in fcntl: " << errnoToString(err)); + ThrowMsg(Exception::InitFailed, "Error in fcntl: " << errnoToString(err)); + } + + sockaddr_un serverAddress; + memset(&serverAddress, 0, sizeof(serverAddress)); + serverAddress.sun_family = AF_UNIX; + strncpy(serverAddress.sun_path, desc.serviceHandlerPath.c_str(), + sizeof(serverAddress.sun_path) - 1); + unlink(serverAddress.sun_path); + mode_t originalUmask; + originalUmask = umask(0); + + if (-1 == bind(sockfd, (struct sockaddr *)&serverAddress, sizeof(serverAddress))) { + int err = errno; + close(sockfd); + LogError("Error in bind: " << errnoToString(err)); + ThrowMsg(Exception::InitFailed, "Error in bind: " << errnoToString(err)); + } + + umask(originalUmask); + + if (-1 == listen(sockfd, 5)) { + int err = errno; + close(sockfd); + LogError("Error in listen: " << errnoToString(err)); + ThrowMsg(Exception::InitFailed, "Error in listen: " << errnoToString(err)); + } + + return sockfd; } void SocketManager::CreateDomainSocket( - GenericSocketService *service, - const GenericSocketService::ServiceDescription &desc) + GenericSocketService *service, + const GenericSocketService::ServiceDescription &desc) { - int sockfd = GetSocketFromSystemD(desc); - if (-1 == sockfd) - sockfd = CreateDomainSocketHelp(desc); + int sockfd = GetSocketFromSystemD(desc); + + if (-1 == sockfd) + sockfd = CreateDomainSocketHelp(desc); + + auto &description = CreateDefaultReadSocketDescription(sockfd, false); + description.isListen = true; + description.interfaceID = desc.interfaceID; + description.useSendMsg = desc.useSendMsg; + description.service = service; + LogDebug("Listen on socket: " << sockfd << + " Handler: " << desc.serviceHandlerPath.c_str()); +} - auto &description = CreateDefaultReadSocketDescription(sockfd, false); +void SocketManager::RegisterSocketService(GenericSocketService *service) +{ + service->SetSocketManager(this); + auto serviceVector = service->GetServiceDescription(); + Try { + for (auto iter = serviceVector.begin(); iter != serviceVector.end(); ++iter) { + switch (iter->type) { + case GenericSocketService::ServiceDescription::SOCKET_SERVICE: + CreateDomainSocket(service, *iter); + break; + + case GenericSocketService::ServiceDescription::FILE_DESC_SERVICE: + CreateDefaultReadSocketDescription(iter->fileDesc, false, iter->interfaceID, service); + break; + + default: + ThrowMsg(Exception::InitFailed, "Wrong service type in service description: " << iter->type); + break; + } + } + } Catch(Exception::Base) { + for (int i = 0; i < (int)m_socketDescriptionVector.size(); ++i) { + auto &desc = m_socketDescriptionVector[i]; + + if (desc.service == service && desc.isOpen) { + close(i); + desc.isOpen = false; + } + } + + ReThrow(Exception::Base); + } +} - description.isListen = true; - description.interfaceID = desc.interfaceID; - description.useSendMsg = desc.useSendMsg; - description.service = service; +void SocketManager::Close(ConnectionID connectionID) +{ + do { + std::lock_guard ulock(m_eventQueueMutex); + m_closeQueue.push(connectionID); + } while (false); - LogDebug("Listen on socket: " << sockfd << - " Handler: " << desc.serviceHandlerPath.c_str()); + NotifyMe(); } -void SocketManager::RegisterSocketService(GenericSocketService *service) { - service->SetSocketManager(this); - auto serviceVector = service->GetServiceDescription(); - Try { - for (auto iter = serviceVector.begin(); iter != serviceVector.end(); ++iter) - { - switch(iter->type) - { - case GenericSocketService::ServiceDescription::SOCKET_SERVICE: - CreateDomainSocket(service, *iter); - break; - case GenericSocketService::ServiceDescription::FILE_DESC_SERVICE: - CreateDefaultReadSocketDescription(iter->fileDesc, false, iter->interfaceID, service); - break; - default: - ThrowMsg(Exception::InitFailed, "Wrong service type in service description: " << iter->type); - break; - } - } - } Catch (Exception::Base) { - for (int i =0; i < (int)m_socketDescriptionVector.size(); ++i) - { - auto &desc = m_socketDescriptionVector[i]; - if (desc.service == service && desc.isOpen) { - close(i); - desc.isOpen = false; - } - } - ReThrow(Exception::Base); - } -} +void SocketManager::Write(ConnectionID connectionID, const RawBuffer &rawBuffer) +{ + WriteBuffer buffer; + buffer.connectionID = connectionID; + buffer.rawBuffer = rawBuffer; -void SocketManager::Close(ConnectionID connectionID) { - { - std::lock_guard ulock(m_eventQueueMutex); - m_closeQueue.push(connectionID); - } - NotifyMe(); -} + do { + std::lock_guard ulock(m_eventQueueMutex); + m_writeBufferQueue.push(buffer); + } while (false); -void SocketManager::Write(ConnectionID connectionID, const RawBuffer &rawBuffer) { - WriteBuffer buffer; - buffer.connectionID = connectionID; - buffer.rawBuffer = rawBuffer; - { - std::lock_guard ulock(m_eventQueueMutex); - m_writeBufferQueue.push(buffer); - } - NotifyMe(); + NotifyMe(); } -void SocketManager::Write(ConnectionID connectionID, const SendMsgData &sendMsgData) { - WriteData data; - data.connectionID = connectionID; - data.sendMsgData = sendMsgData; - { - std::lock_guard ulock(m_eventQueueMutex); - m_writeDataQueue.push(data); - } - NotifyMe(); +void SocketManager::Write(ConnectionID connectionID, const SendMsgData &sendMsgData) +{ + WriteData data; + data.connectionID = connectionID; + data.sendMsgData = sendMsgData; + + do { + std::lock_guard ulock(m_eventQueueMutex); + m_writeDataQueue.push(data); + } while (false); + + NotifyMe(); } -void SocketManager::NotifyMe() { - TEMP_FAILURE_RETRY(write(m_notifyMe[1], "You have message ;-)", 1)); +void SocketManager::NotifyMe() +{ + TEMP_FAILURE_RETRY(write(m_notifyMe[1], "You have message ;-)", 1)); } -void SocketManager::ProcessQueue() { - WriteBuffer buffer; - WriteData data; - { - std::lock_guard ulock(m_eventQueueMutex); - while (!m_writeBufferQueue.empty()) { - buffer = m_writeBufferQueue.front(); - m_writeBufferQueue.pop(); - - auto &desc = m_socketDescriptionVector[buffer.connectionID.sock]; - - if (!desc.isOpen) { - LogDebug("Received packet for write but connection is closed. Packet ignored!"); - continue; - } - - if (desc.counter != buffer.connectionID.counter) - { - LogDebug("Received packet for write but counter is broken. Packet ignored!"); - continue; - } - - if (desc.useSendMsg) { - LogError("Some service tried to push rawdata to socket that usees sendmsg!"); - continue; - } - - std::copy( - buffer.rawBuffer.begin(), - buffer.rawBuffer.end(), - std::back_inserter(desc.rawBuffer)); - - FD_SET(buffer.connectionID.sock, &m_writeSet); - } - - while(!m_writeDataQueue.empty()) { - data = m_writeDataQueue.front(); - m_writeDataQueue.pop(); - - auto &desc = m_socketDescriptionVector[data.connectionID.sock]; - - if (!desc.isOpen) { - LogDebug("Received packet for sendmsg but connection is closed. Packet ignored!"); - continue; - } - - if (desc.counter != data.connectionID.counter) - { - LogDebug("Received packet for write but counter is broken. Packet ignored!"); - continue; - } - - if (!desc.useSendMsg) { - LogError("Some service tries to push SendMsgData to socket that uses write!"); - continue; - } - - desc.sendMsgDataQueue.push(data.sendMsgData); - - FD_SET(data.connectionID.sock, &m_writeSet); - } - } - - while (1) { - ConnectionID connection; - { - std::lock_guard ulock(m_eventQueueMutex); - if (m_closeQueue.empty()) - return; - connection = m_closeQueue.front(); - m_closeQueue.pop(); - } - - if (!m_socketDescriptionVector[connection.sock].isOpen) - continue; - - if (connection.counter != m_socketDescriptionVector[connection.sock].counter) - continue; - - CloseSocket(connection.sock); - } +void SocketManager::ProcessQueue() +{ + do { + std::lock_guard ulock(m_eventQueueMutex); + + WriteBuffer buffer; + WriteData data; + + while (!m_writeBufferQueue.empty()) { + buffer = m_writeBufferQueue.front(); + m_writeBufferQueue.pop(); + auto &desc = m_socketDescriptionVector[buffer.connectionID.sock]; + + if (!desc.isOpen) { + LogDebug("Received packet for write but connection is closed. Packet ignored!"); + continue; + } + + if (desc.counter != buffer.connectionID.counter) { + LogDebug("Received packet for write but counter is broken. Packet ignored!"); + continue; + } + + if (desc.useSendMsg) { + LogError("Some service tried to push rawdata to socket that usees sendmsg!"); + continue; + } + + std::copy( + buffer.rawBuffer.begin(), + buffer.rawBuffer.end(), + std::back_inserter(desc.rawBuffer)); + FD_SET(buffer.connectionID.sock, &m_writeSet); + } + + while (!m_writeDataQueue.empty()) { + data = m_writeDataQueue.front(); + m_writeDataQueue.pop(); + auto &desc = m_socketDescriptionVector[data.connectionID.sock]; + + if (!desc.isOpen) { + LogDebug("Received packet for sendmsg but connection is closed. Packet ignored!"); + continue; + } + + if (desc.counter != data.connectionID.counter) { + LogDebug("Received packet for write but counter is broken. Packet ignored!"); + continue; + } + + if (!desc.useSendMsg) { + LogError("Some service tries to push SendMsgData to socket that uses write!"); + continue; + } + + desc.sendMsgDataQueue.push(data.sendMsgData); + FD_SET(data.connectionID.sock, &m_writeSet); + } + } while (false); + + while (true) { + ConnectionID connection; + do { + std::lock_guard ulock(m_eventQueueMutex); + + if (m_closeQueue.empty()) + return; + + connection = m_closeQueue.front(); + m_closeQueue.pop(); + } while (false); + + if (!m_socketDescriptionVector[connection.sock].isOpen) + continue; + + if (connection.counter != m_socketDescriptionVector[connection.sock].counter) + continue; + + CloseSocket(connection.sock); + } } -void SocketManager::CloseSocket(int sock) { -// LogInfo("Closing socket: " << sock); - auto &desc = m_socketDescriptionVector[sock]; - - if (!(desc.isOpen)) { - // This may happend when some information was waiting for write to the - // socket and in the same time socket was closed by the client. - LogError("Socket " << sock << " is not open. Nothing to do!"); - return; - } - - GenericSocketService::CloseEvent event; - event.connectionID.sock = sock; - event.connectionID.counter = desc.counter; - auto service = desc.service; - - desc.isOpen = false; - desc.service = NULL; - desc.interfaceID = -1; - desc.rawBuffer.clear(); - while(!desc.sendMsgDataQueue.empty()) - desc.sendMsgDataQueue.pop(); - - if (service) - service->Event(event); - else - LogError("Critical! Service is NULL! This should never happen!"); - - TEMP_FAILURE_RETRY(close(sock)); - FD_CLR(sock, &m_readSet); - FD_CLR(sock, &m_writeSet); +void SocketManager::CloseSocket(int sock) +{ + // LogInfo("Closing socket: " << sock); + auto &desc = m_socketDescriptionVector[sock]; + + if (!(desc.isOpen)) { + // This may happend when some information was waiting for write to the + // socket and in the same time socket was closed by the client. + LogError("Socket " << sock << " is not open. Nothing to do!"); + return; + } + + GenericSocketService::CloseEvent event; + event.connectionID.sock = sock; + event.connectionID.counter = desc.counter; + auto service = desc.service; + desc.isOpen = false; + desc.service = NULL; + desc.interfaceID = -1; + desc.rawBuffer.clear(); + + while (!desc.sendMsgDataQueue.empty()) + desc.sendMsgDataQueue.pop(); + + if (service) + service->Event(event); + else + LogError("Critical! Service is NULL! This should never happen!"); + + TEMP_FAILURE_RETRY(close(sock)); + FD_CLR(sock, &m_readSet); + FD_CLR(sock, &m_writeSet); } } // namespace AuthPasswd diff --git a/src/server/main/user-check.cpp b/src/server/main/user-check.cpp index 583e11a..779864b 100644 --- a/src/server/main/user-check.cpp +++ b/src/server/main/user-check.cpp @@ -30,14 +30,16 @@ namespace AuthPasswd { int socket_get_user(int sockfd, unsigned int &user) { - struct ucred cr; - socklen_t len = sizeof(struct ucred); - if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &cr, &len)) { - LogError("getsockopt() failed"); - return 1; - } - user = cr.uid; - return 0; + struct ucred cr; + socklen_t len = sizeof(struct ucred); + + if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &cr, &len)) { + LogError("getsockopt() failed"); + return 1; + } + + user = cr.uid; + return 0; } } // namespace AuthPasswd diff --git a/src/server/service/include/password-exception.h b/src/server/service/include/password-exception.h index 417ce1e..18ea594 100644 --- a/src/server/service/include/password-exception.h +++ b/src/server/service/include/password-exception.h @@ -27,25 +27,23 @@ #include -namespace AuthPasswd -{ - class PasswordException - { - public: - DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) - DECLARE_EXCEPTION_TYPE(Base, OutOfData) - DECLARE_EXCEPTION_TYPE(Base, NoData) - DECLARE_EXCEPTION_TYPE(Base, FStreamOpenError) - DECLARE_EXCEPTION_TYPE(Base, FStreamWriteError) - DECLARE_EXCEPTION_TYPE(Base, FStreamReadError) - DECLARE_EXCEPTION_TYPE(Base, MemoryError) - DECLARE_EXCEPTION_TYPE(Base, NoPasswords) - DECLARE_EXCEPTION_TYPE(Base, PasswordNotActive) - DECLARE_EXCEPTION_TYPE(Base, MakeDirError) - DECLARE_EXCEPTION_TYPE(Base, ChmodError) - DECLARE_EXCEPTION_TYPE(Base, RemoveError) - DECLARE_EXCEPTION_TYPE(Base, TimerError) - }; +namespace AuthPasswd { +class PasswordException { +public: + DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, OutOfData) + DECLARE_EXCEPTION_TYPE(Base, NoData) + DECLARE_EXCEPTION_TYPE(Base, FStreamOpenError) + DECLARE_EXCEPTION_TYPE(Base, FStreamWriteError) + DECLARE_EXCEPTION_TYPE(Base, FStreamReadError) + DECLARE_EXCEPTION_TYPE(Base, MemoryError) + DECLARE_EXCEPTION_TYPE(Base, NoPasswords) + DECLARE_EXCEPTION_TYPE(Base, PasswordNotActive) + DECLARE_EXCEPTION_TYPE(Base, MakeDirError) + DECLARE_EXCEPTION_TYPE(Base, ChmodError) + DECLARE_EXCEPTION_TYPE(Base, RemoveError) + DECLARE_EXCEPTION_TYPE(Base, TimerError) +}; } //namespace AuthPasswd #endif //_PASSWORD_EXCEPTION_H_ diff --git a/src/server/service/include/password-file-buffer.h b/src/server/service/include/password-file-buffer.h index 10375b3..2e87cef 100644 --- a/src/server/service/include/password-file-buffer.h +++ b/src/server/service/include/password-file-buffer.h @@ -32,25 +32,23 @@ #include -namespace AuthPasswd -{ - class PasswordFileBuffer: public IStream - { - public: - PasswordFileBuffer(); +namespace AuthPasswd { +class PasswordFileBuffer: public IStream { +public: + PasswordFileBuffer(); - virtual void Read(size_t num, void *bytes); - virtual void Write(size_t num, const void *bytes); + virtual void Read(size_t num, void *bytes); + virtual void Write(size_t num, const void *bytes); - void Save(const std::string &path); - void Load(const std::string &path); + void Save(const std::string &path); + void Load(const std::string &path); - private: - typedef std::vector DataBuffer; +private: + typedef std::vector DataBuffer; - DataBuffer m_buffer; - size_t m_bufferReadBytes; - }; + DataBuffer m_buffer; + size_t m_bufferReadBytes; +}; } //namespace AuthPasswd #endif diff --git a/src/server/service/include/password-file.h b/src/server/service/include/password-file.h index 992e500..7370e92 100644 --- a/src/server/service/include/password-file.h +++ b/src/server/service/include/password-file.h @@ -37,102 +37,98 @@ #include -namespace AuthPasswd -{ - extern const time_t PASSWORD_INFINITE_EXPIRATION_TIME; +namespace AuthPasswd { +extern const time_t PASSWORD_INFINITE_EXPIRATION_TIME; - struct IPassword: public ISerializable - { - typedef std::vector RawHash; +struct IPassword: public ISerializable { + typedef std::vector RawHash; - enum class PasswordType : unsigned int - { - NONE = 0, - SHA256 = 1, - }; + enum class PasswordType : unsigned int { + NONE = 0, + SHA256 = 1, + }; - virtual bool match(const std::string &password) const = 0; - }; + virtual bool match(const std::string &password) const = 0; +}; - typedef std::shared_ptr IPasswordPtr; - typedef std::list PasswordList; +typedef std::shared_ptr IPasswordPtr; +typedef std::list PasswordList; - class PasswordFile - { - public: - PasswordFile(unsigned int user); +class PasswordFile { +public: + PasswordFile(unsigned int user); - void writeMemoryToFile() const; - void writeAttemptToFile() const; + void writeMemoryToFile() const; + void writeAttemptToFile() const; - void setPassword(unsigned int passwdType, const std::string &password); - bool checkPassword(unsigned int passwdType, const std::string &password) const; + void setPassword(unsigned int passwdType, const std::string &password); + bool checkPassword(unsigned int passwdType, const std::string &password) const; - bool isPasswordActive(unsigned int passwdType) const; + bool isPasswordActive(unsigned int passwdType) const; - void setMaxHistorySize(unsigned int history); - unsigned int getMaxHistorySize() const; + void setMaxHistorySize(unsigned int history); + unsigned int getMaxHistorySize() const; - unsigned int getExpireTime() const; - void setExpireTime(unsigned int expireTime); + unsigned int getExpireTime() const; + void setExpireTime(unsigned int expireTime); - unsigned int getExpireTimeLeft() const; - void setExpireTimeLeft(time_t expireTimeLeft); + unsigned int getExpireTimeLeft() const; + void setExpireTimeLeft(time_t expireTimeLeft); - //attempt manipulating functions - unsigned int getAttempt() const; - void resetAttempt(); - void incrementAttempt(); - int getMaxAttempt() const; - void setMaxAttempt(unsigned int maxAttempt); + //attempt manipulating functions + unsigned int getAttempt() const; + void resetAttempt(); + void incrementAttempt(); + int getMaxAttempt() const; + void setMaxAttempt(unsigned int maxAttempt); - bool isPasswordReused(const std::string &password) const; + bool isPasswordReused(const std::string &password) const; - bool checkExpiration() const; - bool checkIfAttemptsExceeded() const; - bool isIgnorePeriod() const; + bool checkExpiration() const; + bool checkIfAttemptsExceeded() const; + bool isIgnorePeriod() const; - bool isHistoryActive() const; + bool isHistoryActive() const; - private: +private: #if (__GNUC__ > 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ >= 7)) - typedef std::chrono::steady_clock ClockType; + typedef std::chrono::steady_clock ClockType; #else - typedef std::chrono::monotonic_clock ClockType; + typedef std::chrono::monotonic_clock ClockType; #endif - typedef std::chrono::duration TimeDiff; - typedef std::chrono::time_point TimePoint; - - void loadMemoryFromFile(); - bool tryLoadMemoryFromOldFormatFile(); - - void resetTimer(); - void preparePwdFile(); - void prepareAttemptFile(); - void resetState(); - bool fileExists(const std::string &filename) const; - bool dirExists(const std::string &dirpath) const; - std::string createDir(const std::string &dir, unsigned int user) const; - - mutable TimePoint m_retryTimerStart; - - //user name - const unsigned int m_user; - - //password file data - IPasswordPtr m_passwordCurrent; - IPasswordPtr m_passwordRecovery; - PasswordList m_passwordHistory; - unsigned int m_maxAttempt; - unsigned int m_maxHistorySize; - unsigned int m_expireTime; - time_t m_expireTimeLeft; - bool m_passwordActive; - bool m_passwordRcvActive; - - //attempt file data - unsigned int m_attempt; - }; + typedef std::chrono::duration TimeDiff; + typedef std::chrono::time_point TimePoint; + + void loadMemoryFromFile(); + bool tryLoadMemoryFromOldFormatFile(); + + void resetTimer(); + void preparePwdFile(); + void prepareAttemptFile(); + void resetState(); + bool fileExists(const std::string &filename) const; + bool dirExists(const std::string &dirpath) const; + std::string createDir(const std::string &dir, unsigned int user) const; + + mutable TimePoint m_retryTimerStart; + + //user name + const unsigned int m_user; + + //password file data + IPasswordPtr m_passwordCurrent; + IPasswordPtr m_passwordRecovery; + PasswordList m_passwordHistory; + unsigned int m_maxAttempt; + unsigned int m_maxHistorySize; + unsigned int m_expireTime; + time_t m_expireTimeLeft; + bool m_passwordActive; + bool m_passwordRcvActive; + + //attempt file data + unsigned int m_attempt; +}; } //namespace AuthPasswd #endif diff --git a/src/server/service/include/password-manager.h b/src/server/service/include/password-manager.h index 36dfc84..6cef082 100644 --- a/src/server/service/include/password-manager.h +++ b/src/server/service/include/password-manager.h @@ -32,48 +32,46 @@ #include -namespace AuthPasswd -{ - class PasswordManager - { - public: - typedef std::map PasswordFileMap; +namespace AuthPasswd { +class PasswordManager { +public: + typedef std::map PasswordFileMap; - //checking functions - //no const in checkPassword, attempts are update - int checkPassword(unsigned int passwdType, const std::string &challenge, - unsigned int currentUser, unsigned int ¤tAttempt, - unsigned int &maxAttempt, unsigned int &expirationTime); - int isPwdValid(unsigned int passwdType, unsigned int currentUser, - unsigned int ¤tAttempt, unsigned int &maxAttempt, - unsigned int &expirationTime); - int isPwdReused(unsigned int passwdType, const std::string &passwd, - unsigned int currentUser, bool &isReused); + //checking functions + //no const in checkPassword, attempts are update + int checkPassword(unsigned int passwdType, const std::string &challenge, + unsigned int currentUser, unsigned int ¤tAttempt, + unsigned int &maxAttempt, unsigned int &expirationTime); + int isPwdValid(unsigned int passwdType, unsigned int currentUser, + unsigned int ¤tAttempt, unsigned int &maxAttempt, + unsigned int &expirationTime); + int isPwdReused(unsigned int passwdType, const std::string &passwd, + unsigned int currentUser, bool &isReused); - //setting functions - int setPassword(unsigned int passwdType, const std::string ¤tPassword, - const std::string &newPassword, unsigned int currentUser); - int setPasswordRecovery(const std::string &curRcvPassword, const std::string &newPassword, - unsigned int currentUser); + //setting functions + int setPassword(unsigned int passwdType, const std::string ¤tPassword, + const std::string &newPassword, unsigned int currentUser); + int setPasswordRecovery(const std::string &curRcvPassword, const std::string &newPassword, + unsigned int currentUser); - //resetting functions - int resetPassword(unsigned int passwdType, const std::string &newPassword, - unsigned int receivedUser); + //resetting functions + int resetPassword(unsigned int passwdType, const std::string &newPassword, + unsigned int receivedUser); - //setting policy on the current passwd - void setPasswordMaxAttempts(unsigned int receivedUser, - unsigned int receivedAttempts); - void setPasswordValidity(unsigned int receivedUser, unsigned int receivedDays); - void setPasswordHistory(unsigned int receivedUser, unsigned int receivedHistory); + //setting policy on the current passwd + void setPasswordMaxAttempts(unsigned int receivedUser, + unsigned int receivedAttempts); + void setPasswordValidity(unsigned int receivedUser, unsigned int receivedDays); + void setPasswordHistory(unsigned int receivedUser, unsigned int receivedHistory); - private: - //managing functions - void addPassword(unsigned int user); - void removePassword(unsigned int user); - void existPassword(unsigned int user); +private: + //managing functions + void addPassword(unsigned int user); + void removePassword(unsigned int user); + void existPassword(unsigned int user); - PasswordFileMap m_pwdFile; - }; + PasswordFileMap m_pwdFile; +}; } //namespace AuthPasswd #endif diff --git a/src/server/service/include/password.h b/src/server/service/include/password.h index 1abccb9..4b9085d 100644 --- a/src/server/service/include/password.h +++ b/src/server/service/include/password.h @@ -38,52 +38,49 @@ #include #include -namespace AuthPasswd -{ - class PasswordService - : public AuthPasswd::GenericSocketService - , public AuthPasswd::ServiceThread - { - public: - class Exception - { - public: - DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) - DECLARE_EXCEPTION_TYPE(Base, IncorrectHeader) - }; +namespace AuthPasswd { +class PasswordService + : public AuthPasswd::GenericSocketService + , public AuthPasswd::ServiceThread { +public: + class Exception { + public: + DECLARE_EXCEPTION_TYPE(AuthPasswd::Exception, Base) + DECLARE_EXCEPTION_TYPE(Base, IncorrectHeader) + }; - //service functions - ServiceDescriptionVector GetServiceDescription(); + //service functions + ServiceDescriptionVector GetServiceDescription(); - void Start(); - void Stop(); + void Start(); + void Stop(); - DECLARE_THREAD_EVENT(AcceptEvent, accept) - DECLARE_THREAD_EVENT(WriteEvent, write) - DECLARE_THREAD_EVENT(ReadEvent, process) - DECLARE_THREAD_EVENT(CloseEvent, close) + DECLARE_THREAD_EVENT(AcceptEvent, accept) + DECLARE_THREAD_EVENT(WriteEvent, write) + DECLARE_THREAD_EVENT(ReadEvent, process) + DECLARE_THREAD_EVENT(CloseEvent, close) - void accept(const AcceptEvent &event); - void write(const WriteEvent &event); - void process(const ReadEvent &event); - void close(const CloseEvent &event); + void accept(const AcceptEvent &event); + void write(const WriteEvent &event); + void process(const ReadEvent &event); + void close(const CloseEvent &event); - private: - //internal service functions - bool processOne(const ConnectionID &conn, MessageBuffer &buffer, InterfaceID interfaceID); - int processCheckFunctions(PasswordHdrs hdr, MessageBuffer& buffer, - unsigned int cur_user, unsigned int &cur_att, - unsigned int &max_att, unsigned int &exp_time); - int processSetFunctions(PasswordHdrs hdr, MessageBuffer& buffer, - unsigned int cur_user, bool &isPwdReused); - int processResetFunctions(PasswordHdrs hdr, MessageBuffer& buffer); - int processPolicyFunctions(PasswordHdrs hdr, MessageBuffer& buffer); +private: + //internal service functions + bool processOne(const ConnectionID &conn, MessageBuffer &buffer, InterfaceID interfaceID); + int processCheckFunctions(PasswordHdrs hdr, MessageBuffer &buffer, + unsigned int cur_user, unsigned int &cur_att, + unsigned int &max_att, unsigned int &exp_time); + int processSetFunctions(PasswordHdrs hdr, MessageBuffer &buffer, + unsigned int cur_user, bool &isPwdReused); + int processResetFunctions(PasswordHdrs hdr, MessageBuffer &buffer); + int processPolicyFunctions(PasswordHdrs hdr, MessageBuffer &buffer); - // service attributes - PasswordManager m_pwdManager; - PolicyManager m_policyManager; - ConnectionInfoMap m_connectionInfoMap; - }; + // service attributes + PasswordManager m_pwdManager; + PolicyManager m_policyManager; + ConnectionInfoMap m_connectionInfoMap; +}; } // namespace AuthPasswd #endif // _PASSWORD_H_ diff --git a/src/server/service/include/policy-file.h b/src/server/service/include/policy-file.h index fb408b6..74aaaf1 100644 --- a/src/server/service/include/policy-file.h +++ b/src/server/service/include/policy-file.h @@ -29,58 +29,56 @@ #include -namespace AuthPasswd -{ - class PolicyFile - { - public: - PolicyFile(unsigned int user); +namespace AuthPasswd { +class PolicyFile { +public: + PolicyFile(unsigned int user); - void enable(); - void disable(); + void enable(); + void disable(); - bool isPolicyActive() const; + bool isPolicyActive() const; - void writeMemoryToFile() const; + void writeMemoryToFile() const; - bool checkMinLength(const std::string &password) const; - void setMinLength(unsigned int minLength); + bool checkMinLength(const std::string &password) const; + void setMinLength(unsigned int minLength); - bool checkMinComplexCharNumber(const std::string &password) const; - void setMinComplexCharNumber(unsigned int minComplexCharNumber); + bool checkMinComplexCharNumber(const std::string &password) const; + void setMinComplexCharNumber(unsigned int minComplexCharNumber); - bool checkMaxCharOccurrences(const std::string &password) const; - void setMaxCharOccurrences(unsigned int maxCharOccurrences); + bool checkMaxCharOccurrences(const std::string &password) const; + void setMaxCharOccurrences(unsigned int maxCharOccurrences); - bool checkMaxNumSeqLength(const std::string &password) const; - void setMaxNumSeqLength(unsigned int maxNumSeqLength); + bool checkMaxNumSeqLength(const std::string &password) const; + void setMaxNumSeqLength(unsigned int maxNumSeqLength); - bool checkQualityType(const std::string &password) const; - void setQualityType(unsigned int qualityType); + bool checkQualityType(const std::string &password) const; + void setQualityType(unsigned int qualityType); - bool isValidPattern(const std::string &pattern) const; - bool checkPattern(const std::string &password) const; - void setPattern(const std::string &pattern); + bool isValidPattern(const std::string &pattern) const; + bool checkPattern(const std::string &password) const; + void setPattern(const std::string &pattern); - bool checkForbiddenPasswds(const std::string &password) const; - void setForbiddenPasswds(std::set forbiddenPasswds); + bool checkForbiddenPasswds(const std::string &password) const; + void setForbiddenPasswds(std::set forbiddenPasswds); - private: - void loadMemoryFromFile(); - void preparePolicyFile(); - void resetState(); - bool fileExists(const std::string &filename) const; - bool dirExists(const std::string &dirpath) const; - std::string createDir(const std::string &dir, unsigned int user) const; +private: + void loadMemoryFromFile(); + void preparePolicyFile(); + void resetState(); + bool fileExists(const std::string &filename) const; + bool dirExists(const std::string &dirpath) const; + std::string createDir(const std::string &dir, unsigned int user) const; - //user name - unsigned int m_user; + //user name + unsigned int m_user; - bool m_enable; + bool m_enable; - //policy file data - Policy m_policy; - }; + //policy file data + Policy m_policy; +}; } //namespace AuthPasswd #endif diff --git a/src/server/service/include/policy-manager.h b/src/server/service/include/policy-manager.h index 43a46cb..4e81938 100644 --- a/src/server/service/include/policy-manager.h +++ b/src/server/service/include/policy-manager.h @@ -32,33 +32,31 @@ #include -namespace AuthPasswd -{ - class PolicyManager - { - public: - typedef std::map PolicyFileMap; - - // policy checking functions - int checkPolicy(unsigned int passwdType, - const std::string ¤tPassword, - const std::string &newPassword, - unsigned int user); - - // policy setting functions - int setPolicy(Policy policy); - - // policy disabling functions - int disablePolicy(unsigned int user); - - private: - // managing functions - void addPolicy(unsigned int user); - void removePolicy(unsigned int user); - void existPolicy(unsigned int user); - - PolicyFileMap m_policyFile; - }; +namespace AuthPasswd { +class PolicyManager { +public: + typedef std::map PolicyFileMap; + + // policy checking functions + int checkPolicy(unsigned int passwdType, + const std::string ¤tPassword, + const std::string &newPassword, + unsigned int user); + + // policy setting functions + int setPolicy(Policy policy); + + // policy disabling functions + int disablePolicy(unsigned int user); + +private: + // managing functions + void addPolicy(unsigned int user); + void removePolicy(unsigned int user); + void existPolicy(unsigned int user); + + PolicyFileMap m_policyFile; +}; } //namespace AuthPasswd #endif diff --git a/src/server/service/password-file-buffer.cpp b/src/server/service/password-file-buffer.cpp index feefec2..698adc3 100644 --- a/src/server/service/password-file-buffer.cpp +++ b/src/server/service/password-file-buffer.cpp @@ -37,77 +37,76 @@ #include #include -namespace AuthPasswd +namespace AuthPasswd { +PasswordFileBuffer::PasswordFileBuffer(): m_bufferReadBytes(0) {} + +void PasswordFileBuffer::Read(size_t num, void *bytes) +{ + if (m_buffer.empty()) { + LogError("Buffer doesn't contain any data."); + Throw(PasswordException::NoData); + } + + if ((m_bufferReadBytes + num) > m_buffer.size()) { + LogError("Not enough buffer to read " << num << " data."); + Throw(PasswordException::OutOfData); + } + + void *ret = memcpy(bytes, &m_buffer[m_bufferReadBytes], num); + + if (ret == 0) { + LogError("Failed to read " << num << " bytes."); + Throw(PasswordException::MemoryError); + } + + m_bufferReadBytes += num; +} + +void PasswordFileBuffer::Write(size_t num, const void *bytes) +{ + const char *buffer = static_cast(bytes); + std::copy(buffer, buffer + num, std::back_inserter(m_buffer)); +} + +void PasswordFileBuffer::Save(const std::string &path) +{ + std::ofstream file(path, std::ofstream::trunc); + + if (!file.good()) { + LogError("Error while opening file stream."); + Throw(PasswordException::FStreamOpenError); + } + + file.write(m_buffer.data(), m_buffer.size()); + + if (!file) { + LogError("Failed to write data."); + Throw(PasswordException::FStreamWriteError); + } + + file.flush(); + fsync(DPL::FstreamAccessors::GetFd(file)); // flush kernel space buffer + file.close(); +} + +void PasswordFileBuffer::Load(const std::string &path) { - PasswordFileBuffer::PasswordFileBuffer(): m_bufferReadBytes(0) {} - - void PasswordFileBuffer::Read(size_t num, void *bytes) - { - if(m_buffer.empty()) { - LogError("Buffer doesn't contain any data."); - Throw(PasswordException::NoData); - } - - if((m_bufferReadBytes + num) > m_buffer.size()) { - LogError("Not enough buffer to read " << num << " data."); - Throw(PasswordException::OutOfData); - } - - void* ret = memcpy(bytes, &m_buffer[m_bufferReadBytes], num); - - if(ret == 0) { - LogError("Failed to read " << num << " bytes."); - Throw(PasswordException::MemoryError); - } - - m_bufferReadBytes += num; - } - - void PasswordFileBuffer::Write(size_t num, const void *bytes) - { - const char* buffer = static_cast(bytes); - std::copy(buffer, buffer+num, std::back_inserter(m_buffer)); - } - - void PasswordFileBuffer::Save(const std::string &path) - { - std::ofstream file(path, std::ofstream::trunc); - - if(!file.good()) { - LogError("Error while opening file stream."); - Throw(PasswordException::FStreamOpenError); - } - - file.write(m_buffer.data(), m_buffer.size()); - if(!file) { - LogError("Failed to write data."); - Throw(PasswordException::FStreamWriteError); - } - - file.flush(); - fsync(DPL::FstreamAccessors::GetFd(file)); // flush kernel space buffer - file.close(); - } - - void PasswordFileBuffer::Load(const std::string &path) - { - std::ifstream file(path, std::ifstream::binary); - - if(!file.good()) { - LogError("Error while opening file stream."); - Throw(PasswordException::FStreamOpenError); - } - - //reset read bytes counter - m_bufferReadBytes = 0; - - m_buffer.assign(std::istreambuf_iterator(file), - std::istreambuf_iterator()); - - if(!file) { - LogError("Failed to read data. Failbit: " << file.fail() << ", Badbit: " << file.bad()); - Throw(PasswordException::FStreamReadError); - } - } + std::ifstream file(path, std::ifstream::binary); + + if (!file.good()) { + LogError("Error while opening file stream."); + Throw(PasswordException::FStreamOpenError); + } + + //reset read bytes counter + m_bufferReadBytes = 0; + m_buffer.assign(std::istreambuf_iterator(file), + std::istreambuf_iterator()); + + if (!file) { + LogError("Failed to read data. Failbit: " << file.fail() << ", Badbit: " << file.bad()); + Throw(PasswordException::FStreamReadError); + } +} } //namespace AuthPasswd diff --git a/src/server/service/password-file.cpp b/src/server/service/password-file.cpp index 62d8dde..2b015b2 100644 --- a/src/server/service/password-file.cpp +++ b/src/server/service/password-file.cpp @@ -49,540 +49,528 @@ #include namespace { - const std::string PASSWORD_FILE = "/password"; - const std::string OLD_VERSION_PASSWORD_FILE = "/password.old"; - const std::string ATTEMPT_FILE = "/attempt"; - const double RETRY_TIMEOUT = 0.5; - const mode_t FILE_MODE = S_IRUSR | S_IWUSR; - const unsigned int CURRENT_FILE_VERSION = 1; +const std::string PASSWORD_FILE = "/password"; +const std::string OLD_VERSION_PASSWORD_FILE = "/password.old"; +const std::string ATTEMPT_FILE = "/attempt"; +const double RETRY_TIMEOUT = 0.5; +const mode_t FILE_MODE = S_IRUSR | S_IWUSR; +const unsigned int CURRENT_FILE_VERSION = 1; } // namespace anonymous -namespace AuthPasswd -{ - const time_t PASSWORD_INFINITE_EXPIRATION_TIME = std::numeric_limits::max(); - - class NoPassword: public IPassword - { - public: - NoPassword(IStream&) {} - NoPassword() {} - - void Serialize(IStream &stream) const - { - Serialization::Serialize(stream, static_cast(PasswordType::NONE)); - } - - bool match(const std::string &pass) const - { - return pass.empty(); - } - }; - - class SHA256Password: public IPassword - { - public: - SHA256Password(IStream& stream) - { - Deserialization::Deserialize(stream, m_hash); - } - - SHA256Password(const std::string &password) - : m_hash(hash(password)) {} - - SHA256Password(const RawHash& paramHash) - : m_hash(paramHash) {} - - void Serialize(IStream &stream) const - { - Serialization::Serialize(stream, static_cast(PasswordType::SHA256)); - Serialization::Serialize(stream, m_hash); - } - - bool match(const std::string &password) const - { - return m_hash == hash(password); - } - private: - RawHash m_hash; - - static RawHash hash(const std::string &password) - { - RawHash result(SHA256_DIGEST_LENGTH); - - SHA256_CTX context; - SHA256_Init(&context); - SHA256_Update(&context, reinterpret_cast(password.c_str()), - password.size()); - SHA256_Final(result.data(), &context); - - return result; - } - }; - - // deserialization of new password format - template <> - void Deserialization::Deserialize(IStream& stream, IPasswordPtr& ptr) - { - unsigned int algorithm; - Deserialization::Deserialize(stream, algorithm); - switch (algorithm) { - case (unsigned int)IPassword::PasswordType::NONE: - ptr.reset(new NoPassword()); - break; - case (unsigned int)IPassword::PasswordType::SHA256: - ptr.reset(new SHA256Password(stream)); - break; - default: - Throw(PasswordException::FStreamReadError); - } - } - - PasswordFile::PasswordFile(unsigned int user): m_user(user), - m_passwordCurrent(new NoPassword()), - m_passwordRecovery(new NoPassword()), - m_maxAttempt(PASSWORD_INFINITE_ATTEMPT_COUNT), - m_maxHistorySize(0), - m_expireTime(PASSWORD_INFINITE_EXPIRATION_DAYS), - m_expireTimeLeft(PASSWORD_INFINITE_EXPIRATION_TIME), - m_passwordActive(false), - m_passwordRcvActive(false), - m_attempt(0) - { - // check if data directory exists - // if not create it - std::string userDir = createDir(RW_DATA_DIR, m_user); - - if (!dirExists(RW_DATA_DIR)) { - if(mkdir(RW_DATA_DIR, 0700)) { - LogError("Failed to create directory for files. Error: " << errnoToString()); - Throw(PasswordException::MakeDirError); - } - } - - if (!dirExists(userDir.c_str())) { - if(mkdir(userDir.c_str(), 0700)) { - LogError("Failed to create directory for files. Error: " << errnoToString()); - Throw(PasswordException::MakeDirError); - } - } - - preparePwdFile(); - prepareAttemptFile(); - resetTimer(); - } - - void PasswordFile::resetState() - { - m_maxAttempt = PASSWORD_INFINITE_ATTEMPT_COUNT; - m_maxHistorySize = 0; - m_expireTime = PASSWORD_INFINITE_EXPIRATION_DAYS; - m_expireTimeLeft = PASSWORD_INFINITE_EXPIRATION_TIME; - m_passwordRcvActive = false; - m_passwordRecovery.reset(new NoPassword()); - m_passwordActive = false; - m_passwordCurrent.reset(new NoPassword()); - } - - void PasswordFile::resetTimer() - { - m_retryTimerStart = ClockType::now(); - m_retryTimerStart -= TimeDiff(RETRY_TIMEOUT); - } - - void PasswordFile::preparePwdFile() - { - std::string pwdFile = createDir(RW_DATA_DIR, m_user) + PASSWORD_FILE; - std::string oldVersionPwdFile = createDir(RW_DATA_DIR, m_user) + OLD_VERSION_PASSWORD_FILE; - - // check if password file exists - if (!fileExists(pwdFile)) { - // if old format file exist - load it - if (tryLoadMemoryFromOldFormatFile()) { - // save in new format - writeMemoryToFile(); - // and remove old file - if (remove(oldVersionPwdFile.c_str())) { - LogError("Failed to remove file" << oldVersionPwdFile << - " Error: " << errnoToString()); - Throw(PasswordException::RemoveError); - } - return; - } - LogSecureDebug("PWD_DBG not found " << m_user << " password file. Creating."); - - //create file - writeMemoryToFile(); - } else { //if file exists, load data - LogSecureDebug("PWD_DBG found " << m_user << " password file. Opening."); - try { - loadMemoryFromFile(); - } catch (...) { - LogError("Invalid " << pwdFile << " file format"); - resetState(); - writeMemoryToFile(); - } - } - } - - void PasswordFile::prepareAttemptFile() - { - std::string attemptFile = createDir(RW_DATA_DIR, m_user) + ATTEMPT_FILE; - - // check if attempt file exists - // if not create it - if (!fileExists(attemptFile)) { - LogSecureDebug("PWD_DBG not found " << m_user << " attempt file. Creating."); - writeAttemptToFile(); - } else { - LogSecureDebug("PWD_DBG found " << m_user << " attempt file. Opening."); - std::ifstream AttemptFile(attemptFile); - if(!AttemptFile) { - LogError("Failed to open " << m_user << " attempt file."); - // ignore error - return; - } - - AttemptFile.read(reinterpret_cast(&m_attempt), sizeof(unsigned int)); - if(!AttemptFile) { - LogError("Failed to read " << m_user <<" attempt count."); - // ignore error - resetAttempt(); - } - } - } - - bool PasswordFile::fileExists(const std::string &filename) const - { - struct stat buf; - - return ((stat(filename.c_str(), &buf) == 0)); - } - - bool PasswordFile::dirExists(const std::string &dirpath) const - { - struct stat buf; - - return ((stat(dirpath.c_str(), &buf) == 0) && (((buf.st_mode) & S_IFMT) == S_IFDIR)); - } - - std::string PasswordFile::createDir(const std::string &dir, unsigned int user) const - { - std::string User = std::to_string(user); - return dir + "/" + User; - } - - void PasswordFile::writeMemoryToFile() const - { - PasswordFileBuffer pwdBuffer; - - LogSecureDebug("User: " << m_user << ", saving max_att: " << m_maxAttempt << - ", history_size: " << m_maxHistorySize << ", m_expireTime: " << - m_expireTime << ", m_expireTimeLeft: " << m_expireTimeLeft << - ", isActive: " << m_passwordActive << ", isRcvActive: " << - m_passwordRcvActive); - - //serialize password attributes - Serialization::Serialize(pwdBuffer, CURRENT_FILE_VERSION); - Serialization::Serialize(pwdBuffer, m_maxAttempt); - Serialization::Serialize(pwdBuffer, m_maxHistorySize); - Serialization::Serialize(pwdBuffer, m_expireTime); - Serialization::Serialize(pwdBuffer, m_expireTimeLeft); - Serialization::Serialize(pwdBuffer, m_passwordRcvActive); - Serialization::Serialize(pwdBuffer, m_passwordRecovery); - Serialization::Serialize(pwdBuffer, m_passwordActive); - Serialization::Serialize(pwdBuffer, m_passwordCurrent); - Serialization::Serialize(pwdBuffer, m_passwordHistory); - - std::string pwdFile = createDir(RW_DATA_DIR, m_user) + PASSWORD_FILE; - pwdBuffer.Save(pwdFile); - - if (chmod(pwdFile.c_str(), FILE_MODE)) { - LogError("Failed to chmod for " << pwdFile << " Error: " << errnoToString()); - Throw(PasswordException::ChmodError); - } - } - - void PasswordFile::loadMemoryFromFile() - { - PasswordFileBuffer pwdBuffer; - std::string pwdFile = createDir(RW_DATA_DIR, m_user) + PASSWORD_FILE; - - pwdBuffer.Load(pwdFile); - - unsigned int fileVersion = 0; - Deserialization::Deserialize(pwdBuffer, fileVersion); - if (fileVersion != CURRENT_FILE_VERSION) - Throw(PasswordException::FStreamReadError); - - m_passwordHistory.clear(); - - Deserialization::Deserialize(pwdBuffer, m_maxAttempt); - Deserialization::Deserialize(pwdBuffer, m_maxHistorySize); - Deserialization::Deserialize(pwdBuffer, m_expireTime); - Deserialization::Deserialize(pwdBuffer, m_expireTimeLeft); - Deserialization::Deserialize(pwdBuffer, m_passwordRcvActive); - Deserialization::Deserialize(pwdBuffer, m_passwordRecovery); - Deserialization::Deserialize(pwdBuffer, m_passwordActive); - Deserialization::Deserialize(pwdBuffer, m_passwordCurrent); - Deserialization::Deserialize(pwdBuffer, m_passwordHistory); - - LogSecureDebug("User: " << m_user << ", loaded max_att: " << m_maxAttempt << - ", history_size: " << m_maxHistorySize << ", m_expireTime: " << - m_expireTime << ", m_expireTimeLeft: " << m_expireTimeLeft << - ", isActive: " << m_passwordActive << ", isRcvActive: " << - m_passwordRcvActive); - } - - bool PasswordFile::tryLoadMemoryFromOldFormatFile() - { - struct stat oldFileStat; - std::string oldVersionPwdFile = createDir(RW_DATA_DIR, m_user) + OLD_VERSION_PASSWORD_FILE; - - if (stat(oldVersionPwdFile.c_str(), &oldFileStat) != 0) - return false; - - static const int ELEMENT_SIZE = sizeof(unsigned) + SHA256_DIGEST_LENGTH; - static const int VERSION_1_REMAINING = sizeof(unsigned) * 4; - static const int VERSION_2_REMAINING = VERSION_1_REMAINING + sizeof(bool); - int remaining = oldFileStat.st_size % ELEMENT_SIZE; - - if (remaining != VERSION_1_REMAINING && remaining != VERSION_2_REMAINING) - return false; - - try { - PasswordFileBuffer pwdBuffer; - pwdBuffer.Load(oldVersionPwdFile); - - Deserialization::Deserialize(pwdBuffer, m_maxAttempt); - Deserialization::Deserialize(pwdBuffer, m_maxHistorySize); - Deserialization::Deserialize(pwdBuffer, m_expireTimeLeft); - if (m_expireTimeLeft == 0) - m_expireTimeLeft = PASSWORD_INFINITE_EXPIRATION_TIME; - - if (remaining == VERSION_2_REMAINING) - Deserialization::Deserialize(pwdBuffer, m_passwordActive); - else - m_passwordActive = true; - - // deserialize passwords in old format - struct OldPassword { - OldPassword() {} - OldPassword(IStream &stream) - { - Deserialization::Deserialize(stream, m_hash); - } - IPassword::RawHash m_hash; - }; - std::list oldFormatPasswords; - Deserialization::Deserialize(pwdBuffer, oldFormatPasswords); - - // convert passwords to new format - m_passwordHistory.clear(); - if (oldFormatPasswords.empty()) { - m_passwordCurrent.reset(new NoPassword()); - m_passwordActive = false; - } else { - m_passwordCurrent.reset(new SHA256Password(oldFormatPasswords.front().m_hash)); - std::for_each(++oldFormatPasswords.begin(), oldFormatPasswords.end(), - [&] (const OldPassword& pwd) - {m_passwordHistory.push_back(IPasswordPtr(new SHA256Password(pwd.m_hash)));} - ); - } - - m_expireTime = PASSWORD_INFINITE_EXPIRATION_DAYS; - m_passwordRcvActive = false; - m_passwordRecovery.reset(new NoPassword()); - - } catch (...) { - LogWarning("Invalid " << oldVersionPwdFile << " file format"); - resetState(); - return false; - } - - return true; - } - - void PasswordFile::writeAttemptToFile() const - { - std::string attemptFile = createDir(RW_DATA_DIR, m_user) + ATTEMPT_FILE; - - std::ofstream AttemptFile(attemptFile, std::ofstream::trunc); - - if(!AttemptFile.good()) { - LogError("Failed to open " << m_user << " attempt file."); - Throw(PasswordException::FStreamOpenError); - } - - AttemptFile.write(reinterpret_cast(&m_attempt), sizeof(unsigned int)); - if(!AttemptFile) { - LogError("Failed to write " << m_user << " attempt count."); - Throw(PasswordException::FStreamWriteError); - } - - AttemptFile.flush(); - fsync(DPL::FstreamAccessors::GetFd(AttemptFile)); // flush kernel space buffer - AttemptFile.close(); - } - - bool PasswordFile::isPasswordActive(unsigned int passwdType) const - { - bool ret = false; - - if (passwdType == AUTH_PWD_NORMAL) - ret = m_passwordActive; - else if (passwdType == AUTH_PWD_RECOVERY) - ret = m_passwordRcvActive; - return ret; - } - - void PasswordFile::setMaxHistorySize(unsigned int history) - { - // put current password in history - if (m_maxHistorySize == 0 && history > 0) - m_passwordHistory.push_front(m_passwordCurrent); - - //setting history should be independent from password being set - m_maxHistorySize = history; - - while(m_passwordHistory.size() > history) - m_passwordHistory.pop_back(); - } - - unsigned int PasswordFile::getMaxHistorySize() const - { - return m_maxHistorySize; - } - - unsigned int PasswordFile::getAttempt() const - { - return m_attempt; - } - - void PasswordFile::resetAttempt() - { - m_attempt = 0; - } - - void PasswordFile::incrementAttempt() - { - m_attempt++; - } - - int PasswordFile::getMaxAttempt() const - { - return m_maxAttempt; - } - - void PasswordFile::setMaxAttempt(unsigned int maxAttempt) - { - m_maxAttempt = maxAttempt; - } - - bool PasswordFile::isPasswordReused(const std::string &password) const - { - LogSecureDebug("Checking if " << m_user << " pwd is reused. HistorySize: " << - m_passwordHistory.size() << ", MaxHistorySize: " << getMaxHistorySize()); - - //go through history and check if password existed earlier - if(std::any_of(m_passwordHistory.begin(), m_passwordHistory.end(), - [&password](const IPasswordPtr& pwd) { return pwd->match(password); })) { - LogSecureDebug(m_user << " passwords match!"); - return true; - } - - LogSecureDebug("isPasswordReused: No passwords match, " << m_user << - " password not reused."); - return false; - } - - void PasswordFile::setPassword(unsigned int passwdType, const std::string &password) - { - if (passwdType == AUTH_PWD_NORMAL) { - //replace current password with new one - if (password.empty()) { - m_passwordCurrent.reset(new NoPassword()); - m_passwordActive = false; - } else { - m_passwordCurrent.reset(new SHA256Password(password)); - - //put current password to history - m_passwordHistory.push_front(m_passwordCurrent); - - //erase last password if we exceed max history size - if(m_passwordHistory.size() > getMaxHistorySize()) - m_passwordHistory.pop_back(); - m_passwordActive = true; - } - } else if (passwdType == AUTH_PWD_RECOVERY) { - //replace current password with new one - if (password.empty()) { - m_passwordRecovery.reset(new NoPassword()); - m_passwordRcvActive = false; - } else { - m_passwordRecovery.reset(new SHA256Password(password)); - m_passwordRcvActive = true; - } - } - } - - bool PasswordFile::checkPassword(unsigned int passwdType, const std::string &password) const - { - bool ret = false; - if (passwdType == AUTH_PWD_NORMAL) - ret = m_passwordCurrent->match(password); - else if (passwdType == AUTH_PWD_RECOVERY) - ret = m_passwordRecovery->match(password); - return ret; - } - - void PasswordFile::setExpireTime(unsigned int expireTime) - { - m_expireTime = expireTime; - } - - unsigned int PasswordFile::getExpireTime() const - { - return m_expireTime; - } - - void PasswordFile::setExpireTimeLeft(time_t expireTimeLeft) - { - m_expireTimeLeft = expireTimeLeft; - } - - unsigned int PasswordFile::getExpireTimeLeft() const - { - if(m_expireTimeLeft != PASSWORD_INFINITE_EXPIRATION_TIME) { - time_t timeLeft = m_expireTimeLeft - time(NULL); - return (timeLeft < 0) ? 0 : static_cast(timeLeft); - } else - return PASSWORD_API_NO_EXPIRATION; - } - - bool PasswordFile::checkExpiration() const - { - //return true if expired, else false - return ((m_expireTimeLeft != PASSWORD_INFINITE_EXPIRATION_TIME) && (time(NULL) > m_expireTimeLeft)); - } - - bool PasswordFile::checkIfAttemptsExceeded() const - { - return ((m_maxAttempt != PASSWORD_INFINITE_ATTEMPT_COUNT) && (m_attempt > m_maxAttempt)); - } - - bool PasswordFile::isIgnorePeriod() const - { - TimePoint retryTimerStop = ClockType::now(); - TimeDiff diff = retryTimerStop - m_retryTimerStart; - - m_retryTimerStart = retryTimerStop; - - return (diff.count() < RETRY_TIMEOUT); - } - - bool PasswordFile::isHistoryActive() const - { - return (m_maxHistorySize != 0); - } -} //namespace AuthPasswd +namespace AuthPasswd { +const time_t PASSWORD_INFINITE_EXPIRATION_TIME = std::numeric_limits::max(); + +class NoPassword: public IPassword { +public: + NoPassword(IStream &) {} + NoPassword() {} + + void Serialize(IStream &stream) const { + Serialization::Serialize(stream, static_cast(PasswordType::NONE)); + } + + bool match(const std::string &pass) const { + return pass.empty(); + } +}; + +class SHA256Password: public IPassword { +public: + SHA256Password(IStream &stream) { + Deserialization::Deserialize(stream, m_hash); + } + + SHA256Password(const std::string &password) : m_hash(hash(password)) {} + + SHA256Password(const RawHash ¶mHash) : m_hash(paramHash) {} + + void Serialize(IStream &stream) const { + Serialization::Serialize(stream, static_cast(PasswordType::SHA256)); + Serialization::Serialize(stream, m_hash); + } + + bool match(const std::string &password) const { + return m_hash == hash(password); + } + +private: + RawHash m_hash; + + static RawHash hash(const std::string &password) { + RawHash result(SHA256_DIGEST_LENGTH); + SHA256_CTX context; + SHA256_Init(&context); + SHA256_Update(&context, reinterpret_cast(password.c_str()), + password.size()); + SHA256_Final(result.data(), &context); + return result; + } +}; + +// deserialization of new password format +template <> +void Deserialization::Deserialize(IStream &stream, IPasswordPtr &ptr) +{ + unsigned int algorithm; + Deserialization::Deserialize(stream, algorithm); + + switch (algorithm) { + case (unsigned int)IPassword::PasswordType::NONE: + ptr.reset(new NoPassword()); + break; + + case (unsigned int)IPassword::PasswordType::SHA256: + ptr.reset(new SHA256Password(stream)); + break; + + default: + Throw(PasswordException::FStreamReadError); + } +} + +PasswordFile::PasswordFile(unsigned int user) : + m_user(user), + m_passwordCurrent(new NoPassword()), + m_passwordRecovery(new NoPassword()), + m_maxAttempt(PASSWORD_INFINITE_ATTEMPT_COUNT), + m_maxHistorySize(0), + m_expireTime(PASSWORD_INFINITE_EXPIRATION_DAYS), + m_expireTimeLeft(PASSWORD_INFINITE_EXPIRATION_TIME), + m_passwordActive(false), + m_passwordRcvActive(false), + m_attempt(0) +{ + // check if data directory exists + // if not create it + std::string userDir = createDir(RW_DATA_DIR, m_user); + + if (!dirExists(RW_DATA_DIR)) { + if (mkdir(RW_DATA_DIR, 0700)) { + LogError("Failed to create directory for files. Error: " << errnoToString()); + Throw(PasswordException::MakeDirError); + } + } + + if (!dirExists(userDir.c_str())) { + if (mkdir(userDir.c_str(), 0700)) { + LogError("Failed to create directory for files. Error: " << errnoToString()); + Throw(PasswordException::MakeDirError); + } + } + + preparePwdFile(); + prepareAttemptFile(); + resetTimer(); +} + +void PasswordFile::resetState() +{ + m_maxAttempt = PASSWORD_INFINITE_ATTEMPT_COUNT; + m_maxHistorySize = 0; + m_expireTime = PASSWORD_INFINITE_EXPIRATION_DAYS; + m_expireTimeLeft = PASSWORD_INFINITE_EXPIRATION_TIME; + m_passwordRcvActive = false; + m_passwordRecovery.reset(new NoPassword()); + m_passwordActive = false; + m_passwordCurrent.reset(new NoPassword()); +} + +void PasswordFile::resetTimer() +{ + m_retryTimerStart = ClockType::now(); + m_retryTimerStart -= TimeDiff(RETRY_TIMEOUT); +} + +void PasswordFile::preparePwdFile() +{ + std::string pwdFile = createDir(RW_DATA_DIR, m_user) + PASSWORD_FILE; + std::string oldVersionPwdFile = createDir(RW_DATA_DIR, m_user) + OLD_VERSION_PASSWORD_FILE; + + // check if password file exists + if (!fileExists(pwdFile)) { + // if old format file exist - load it + if (tryLoadMemoryFromOldFormatFile()) { + // save in new format + writeMemoryToFile(); + + // and remove old file + if (remove(oldVersionPwdFile.c_str())) { + LogError("Failed to remove file" << oldVersionPwdFile << + " Error: " << errnoToString()); + Throw(PasswordException::RemoveError); + } + + return; + } + + LogSecureDebug("PWD_DBG not found " << m_user << " password file. Creating."); + //create file + writeMemoryToFile(); + } else { //if file exists, load data + LogSecureDebug("PWD_DBG found " << m_user << " password file. Opening."); + + try { + loadMemoryFromFile(); + } catch (...) { + LogError("Invalid " << pwdFile << " file format"); + resetState(); + writeMemoryToFile(); + } + } +} + +void PasswordFile::prepareAttemptFile() +{ + std::string attemptFile = createDir(RW_DATA_DIR, m_user) + ATTEMPT_FILE; + + // check if attempt file exists + // if not create it + if (!fileExists(attemptFile)) { + LogSecureDebug("PWD_DBG not found " << m_user << " attempt file. Creating."); + writeAttemptToFile(); + } else { + LogSecureDebug("PWD_DBG found " << m_user << " attempt file. Opening."); + std::ifstream AttemptFile(attemptFile); + + if (!AttemptFile) { + LogError("Failed to open " << m_user << " attempt file."); + // ignore error + return; + } + + AttemptFile.read(reinterpret_cast(&m_attempt), sizeof(unsigned int)); + + if (!AttemptFile) { + LogError("Failed to read " << m_user << " attempt count."); + // ignore error + resetAttempt(); + } + } +} + +bool PasswordFile::fileExists(const std::string &filename) const +{ + struct stat buf; + return ((stat(filename.c_str(), &buf) == 0)); +} + +bool PasswordFile::dirExists(const std::string &dirpath) const +{ + struct stat buf; + return ((stat(dirpath.c_str(), &buf) == 0) && (((buf.st_mode) & S_IFMT) == S_IFDIR)); +} + +std::string PasswordFile::createDir(const std::string &dir, unsigned int user) const +{ + std::string User = std::to_string(user); + return dir + "/" + User; +} + +void PasswordFile::writeMemoryToFile() const +{ + PasswordFileBuffer pwdBuffer; + LogSecureDebug("User: " << m_user << ", saving max_att: " << m_maxAttempt << + ", history_size: " << m_maxHistorySize << ", m_expireTime: " << + m_expireTime << ", m_expireTimeLeft: " << m_expireTimeLeft << + ", isActive: " << m_passwordActive << ", isRcvActive: " << + m_passwordRcvActive); + //serialize password attributes + Serialization::Serialize(pwdBuffer, CURRENT_FILE_VERSION); + Serialization::Serialize(pwdBuffer, m_maxAttempt); + Serialization::Serialize(pwdBuffer, m_maxHistorySize); + Serialization::Serialize(pwdBuffer, m_expireTime); + Serialization::Serialize(pwdBuffer, m_expireTimeLeft); + Serialization::Serialize(pwdBuffer, m_passwordRcvActive); + Serialization::Serialize(pwdBuffer, m_passwordRecovery); + Serialization::Serialize(pwdBuffer, m_passwordActive); + Serialization::Serialize(pwdBuffer, m_passwordCurrent); + Serialization::Serialize(pwdBuffer, m_passwordHistory); + std::string pwdFile = createDir(RW_DATA_DIR, m_user) + PASSWORD_FILE; + pwdBuffer.Save(pwdFile); + + if (chmod(pwdFile.c_str(), FILE_MODE)) { + LogError("Failed to chmod for " << pwdFile << " Error: " << errnoToString()); + Throw(PasswordException::ChmodError); + } +} + +void PasswordFile::loadMemoryFromFile() +{ + PasswordFileBuffer pwdBuffer; + std::string pwdFile = createDir(RW_DATA_DIR, m_user) + PASSWORD_FILE; + pwdBuffer.Load(pwdFile); + unsigned int fileVersion = 0; + Deserialization::Deserialize(pwdBuffer, fileVersion); + + if (fileVersion != CURRENT_FILE_VERSION) + Throw(PasswordException::FStreamReadError); + + m_passwordHistory.clear(); + Deserialization::Deserialize(pwdBuffer, m_maxAttempt); + Deserialization::Deserialize(pwdBuffer, m_maxHistorySize); + Deserialization::Deserialize(pwdBuffer, m_expireTime); + Deserialization::Deserialize(pwdBuffer, m_expireTimeLeft); + Deserialization::Deserialize(pwdBuffer, m_passwordRcvActive); + Deserialization::Deserialize(pwdBuffer, m_passwordRecovery); + Deserialization::Deserialize(pwdBuffer, m_passwordActive); + Deserialization::Deserialize(pwdBuffer, m_passwordCurrent); + Deserialization::Deserialize(pwdBuffer, m_passwordHistory); + LogSecureDebug("User: " << m_user << ", loaded max_att: " << m_maxAttempt << + ", history_size: " << m_maxHistorySize << ", m_expireTime: " << + m_expireTime << ", m_expireTimeLeft: " << m_expireTimeLeft << + ", isActive: " << m_passwordActive << ", isRcvActive: " << + m_passwordRcvActive); +} + +bool PasswordFile::tryLoadMemoryFromOldFormatFile() +{ + struct stat oldFileStat; + std::string oldVersionPwdFile = createDir(RW_DATA_DIR, m_user) + OLD_VERSION_PASSWORD_FILE; + + if (stat(oldVersionPwdFile.c_str(), &oldFileStat) != 0) + return false; + + static const int ELEMENT_SIZE = sizeof(unsigned) + SHA256_DIGEST_LENGTH; + static const int VERSION_1_REMAINING = sizeof(unsigned) * 4; + static const int VERSION_2_REMAINING = VERSION_1_REMAINING + sizeof(bool); + int remaining = oldFileStat.st_size % ELEMENT_SIZE; + + if (remaining != VERSION_1_REMAINING && remaining != VERSION_2_REMAINING) + return false; + + try { + PasswordFileBuffer pwdBuffer; + pwdBuffer.Load(oldVersionPwdFile); + Deserialization::Deserialize(pwdBuffer, m_maxAttempt); + Deserialization::Deserialize(pwdBuffer, m_maxHistorySize); + Deserialization::Deserialize(pwdBuffer, m_expireTimeLeft); + + if (m_expireTimeLeft == 0) + m_expireTimeLeft = PASSWORD_INFINITE_EXPIRATION_TIME; + + if (remaining == VERSION_2_REMAINING) + Deserialization::Deserialize(pwdBuffer, m_passwordActive); + else + m_passwordActive = true; + + // deserialize passwords in old format + struct OldPassword { + OldPassword() {} + OldPassword(IStream &stream) { + Deserialization::Deserialize(stream, m_hash); + } + IPassword::RawHash m_hash; + }; + std::list oldFormatPasswords; + Deserialization::Deserialize(pwdBuffer, oldFormatPasswords); + // convert passwords to new format + m_passwordHistory.clear(); + + if (oldFormatPasswords.empty()) { + m_passwordCurrent.reset(new NoPassword()); + m_passwordActive = false; + } else { + m_passwordCurrent.reset(new SHA256Password(oldFormatPasswords.front().m_hash)); + std::for_each( + ++oldFormatPasswords.begin(), + oldFormatPasswords.end(), + [&](const OldPassword & pwd) { + m_passwordHistory.push_back(IPasswordPtr(new SHA256Password(pwd.m_hash))); + }); + } + + m_expireTime = PASSWORD_INFINITE_EXPIRATION_DAYS; + m_passwordRcvActive = false; + m_passwordRecovery.reset(new NoPassword()); + } catch (...) { + LogWarning("Invalid " << oldVersionPwdFile << " file format"); + resetState(); + return false; + } + + return true; +} + +void PasswordFile::writeAttemptToFile() const +{ + std::string attemptFile = createDir(RW_DATA_DIR, m_user) + ATTEMPT_FILE; + std::ofstream AttemptFile(attemptFile, std::ofstream::trunc); + + if (!AttemptFile.good()) { + LogError("Failed to open " << m_user << " attempt file."); + Throw(PasswordException::FStreamOpenError); + } + + AttemptFile.write(reinterpret_cast(&m_attempt), sizeof(unsigned int)); + + if (!AttemptFile) { + LogError("Failed to write " << m_user << " attempt count."); + Throw(PasswordException::FStreamWriteError); + } + + AttemptFile.flush(); + fsync(DPL::FstreamAccessors::GetFd(AttemptFile)); // flush kernel space buffer + AttemptFile.close(); +} + +bool PasswordFile::isPasswordActive(unsigned int passwdType) const +{ + switch (passwdType) { + case AUTH_PWD_NORMAL: return m_passwordActive; + case AUTH_PWD_RECOVERY: return m_passwordRcvActive; + default: return false; + } +} + +void PasswordFile::setMaxHistorySize(unsigned int history) +{ + // put current password in history + if (m_maxHistorySize == 0 && history > 0) + m_passwordHistory.push_front(m_passwordCurrent); + + //setting history should be independent from password being set + m_maxHistorySize = history; + + while (m_passwordHistory.size() > history) + m_passwordHistory.pop_back(); +} + +unsigned int PasswordFile::getMaxHistorySize() const +{ + return m_maxHistorySize; +} +unsigned int PasswordFile::getAttempt() const +{ + return m_attempt; +} + +void PasswordFile::resetAttempt() +{ + m_attempt = 0; +} + +void PasswordFile::incrementAttempt() +{ + m_attempt++; +} + +int PasswordFile::getMaxAttempt() const +{ + return m_maxAttempt; +} + +void PasswordFile::setMaxAttempt(unsigned int maxAttempt) +{ + m_maxAttempt = maxAttempt; +} + +bool PasswordFile::isPasswordReused(const std::string &password) const +{ + LogSecureDebug("Checking if " << m_user << " pwd is reused. HistorySize: " << + m_passwordHistory.size() << ", MaxHistorySize: " << getMaxHistorySize()); + + // go through history and check if password existed earlier + if (std::any_of( + m_passwordHistory.begin(), + m_passwordHistory.end(), + [&password](const IPasswordPtr & pwd) { + return pwd->match(password); + })) { + LogSecureDebug(m_user << " passwords match!"); + return true; + } + + LogSecureDebug("isPasswordReused: No passwords match, " << m_user << + " password not reused."); + return false; +} + +void PasswordFile::setPassword(unsigned int passwdType, const std::string &password) +{ + if (passwdType == AUTH_PWD_NORMAL) { + //replace current password with new one + if (password.empty()) { + m_passwordCurrent.reset(new NoPassword()); + m_passwordActive = false; + } else { + m_passwordCurrent.reset(new SHA256Password(password)); + //put current password to history + m_passwordHistory.push_front(m_passwordCurrent); + + //erase last password if we exceed max history size + if (m_passwordHistory.size() > getMaxHistorySize()) + m_passwordHistory.pop_back(); + + m_passwordActive = true; + } + } else if (passwdType == AUTH_PWD_RECOVERY) { + //replace current password with new one + if (password.empty()) { + m_passwordRecovery.reset(new NoPassword()); + m_passwordRcvActive = false; + } else { + m_passwordRecovery.reset(new SHA256Password(password)); + m_passwordRcvActive = true; + } + } +} + +bool PasswordFile::checkPassword(unsigned int passwdType, const std::string &password) const +{ + switch (passwdType) { + case AUTH_PWD_NORMAL: return m_passwordCurrent->match(password); + case AUTH_PWD_RECOVERY: return m_passwordRecovery->match(password); + default: return false; + } +} + +void PasswordFile::setExpireTime(unsigned int expireTime) +{ + m_expireTime = expireTime; +} + +unsigned int PasswordFile::getExpireTime() const +{ + return m_expireTime; +} + +void PasswordFile::setExpireTimeLeft(time_t expireTimeLeft) +{ + m_expireTimeLeft = expireTimeLeft; +} + +unsigned int PasswordFile::getExpireTimeLeft() const +{ + if (m_expireTimeLeft != PASSWORD_INFINITE_EXPIRATION_TIME) { + time_t timeLeft = m_expireTimeLeft - time(NULL); + return (timeLeft < 0) ? 0 : static_cast(timeLeft); + } else { + return PASSWORD_API_NO_EXPIRATION; + } +} + +bool PasswordFile::checkExpiration() const +{ + //return true if expired, else false + return ((m_expireTimeLeft != PASSWORD_INFINITE_EXPIRATION_TIME) && (time(NULL) > m_expireTimeLeft)); +} + +bool PasswordFile::checkIfAttemptsExceeded() const +{ + return ((m_maxAttempt != PASSWORD_INFINITE_ATTEMPT_COUNT) && (m_attempt > m_maxAttempt)); +} + +bool PasswordFile::isIgnorePeriod() const +{ + TimePoint retryTimerStop = ClockType::now(); + TimeDiff diff = retryTimerStop - m_retryTimerStart; + m_retryTimerStart = retryTimerStop; + return (diff.count() < RETRY_TIMEOUT); +} + +bool PasswordFile::isHistoryActive() const +{ + return (m_maxHistorySize != 0); +} +} //namespace AuthPasswd diff --git a/src/server/service/password-manager.cpp b/src/server/service/password-manager.cpp index 9d528dc..2bf2df4 100644 --- a/src/server/service/password-manager.cpp +++ b/src/server/service/password-manager.cpp @@ -40,390 +40,377 @@ #include namespace { - void calculateExpiredTime(unsigned int receivedDays, time_t &validSecs) - { - validSecs = AuthPasswd::PASSWORD_INFINITE_EXPIRATION_TIME; - - //when receivedDays means infinite expiration, return default validSecs value. - if(receivedDays == AuthPasswd::PASSWORD_INFINITE_EXPIRATION_DAYS) - return; - - time_t curTime = time(NULL); - validSecs = (curTime + (receivedDays * 86400)); - return; - } +void calculateExpiredTime(unsigned int receivedDays, time_t &validSecs) +{ + validSecs = AuthPasswd::PASSWORD_INFINITE_EXPIRATION_TIME; + + //when receivedDays means infinite expiration, return default validSecs value. + if (receivedDays == AuthPasswd::PASSWORD_INFINITE_EXPIRATION_DAYS) + return; + + time_t curTime = time(NULL); + validSecs = (curTime + (receivedDays * 86400)); + return; +} } //namespace -namespace AuthPasswd +namespace AuthPasswd { +void PasswordManager::addPassword(unsigned int user) +{ + m_pwdFile.insert(PasswordFileMap::value_type(user, PasswordFile(user))); +} + +void PasswordManager::removePassword(unsigned int user) +{ + m_pwdFile.erase(user); +} + +void PasswordManager::existPassword(unsigned int user) { - void PasswordManager::addPassword(unsigned int user) - { - m_pwdFile.insert(PasswordFileMap::value_type(user, PasswordFile(user))); - } - - void PasswordManager::removePassword(unsigned int user) - { - m_pwdFile.erase(user); - } - - void PasswordManager::existPassword(unsigned int user) - { - PasswordFileMap::iterator itPwd = m_pwdFile.find(user); - if (itPwd != m_pwdFile.end()) - return; - - addPassword(user); - return; - } - - int PasswordManager::checkPassword(unsigned int passwdType, - const std::string &challenge, - unsigned int currentUser, - unsigned int ¤tAttempt, - unsigned int &maxAttempt, - unsigned int &expirationTime) - { - LogSecureDebug("Inside checkPassword function."); - - existPassword(currentUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); - - if (itPwd->second.isIgnorePeriod()) { - LogError("Retry timeout occurred."); - return AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER; - } - if (!itPwd->second.isPasswordActive(passwdType) && !challenge.empty()) { - LogError("Password not active."); - return AUTH_PASSWD_API_ERROR_NO_PASSWORD; - } - - switch(passwdType) { - case AUTH_PWD_NORMAL: - - itPwd->second.incrementAttempt(); - itPwd->second.writeAttemptToFile(); - - currentAttempt = itPwd->second.getAttempt(); - maxAttempt = itPwd->second.getMaxAttempt(); - expirationTime = itPwd->second.getExpireTimeLeft(); - - if (itPwd->second.checkIfAttemptsExceeded()) { - LogError("Too many tries."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED; - } - if (!itPwd->second.checkPassword(AUTH_PWD_NORMAL, challenge)) { - LogError("Wrong password."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; - } - - // Password maches and attempt number is fine - time to reset counter. - itPwd->second.resetAttempt(); - itPwd->second.writeAttemptToFile(); - - // Password is too old. You must change it before login. - if (itPwd->second.checkExpiration()) { - LogError("Password expired."); - return AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED; - } - break; - - case AUTH_PWD_RECOVERY: - if (!itPwd->second.checkPassword(AUTH_PWD_RECOVERY, challenge)) { - LogError("Wrong password."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; - } - break; - - default: - LogError("Not supported password type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - return AUTH_PASSWD_API_SUCCESS; - } - - int PasswordManager::isPwdValid(unsigned int passwdType, unsigned int currentUser, - unsigned int ¤tAttempt, unsigned int &maxAttempt, - unsigned int &expirationTime) - { - existPassword(currentUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); - - if (!itPwd->second.isPasswordActive(passwdType)) { - LogError("Current password not active."); - return AUTH_PASSWD_API_ERROR_NO_PASSWORD; - } - - switch(passwdType) { - case AUTH_PWD_NORMAL: - currentAttempt = itPwd->second.getAttempt(); - maxAttempt = itPwd->second.getMaxAttempt(); - expirationTime = itPwd->second.getExpireTimeLeft(); - break; - - case AUTH_PWD_RECOVERY: - // there are no maxAttempt and expirationTime for recovery password - currentAttempt = PASSWORD_INFINITE_ATTEMPT_COUNT; - maxAttempt = PASSWORD_INFINITE_ATTEMPT_COUNT; - expirationTime = PASSWORD_API_NO_EXPIRATION; - break; - - default: - LogError("Not supported password type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - return AUTH_PASSWD_API_SUCCESS; - } - - int PasswordManager::isPwdReused(unsigned int passwdType, const std::string &passwd, - unsigned int currentUser, bool &isReused) - { - existPassword(currentUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); - - isReused = false; - - switch(passwdType) { - case AUTH_PWD_NORMAL: - // check history, however only if history is active and password is not empty - if (itPwd->second.isHistoryActive() && !passwd.empty()) - isReused = itPwd->second.isPasswordReused(passwd); - break; - - case AUTH_PWD_RECOVERY: - break; - - default: - LogError("Not supported password type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - return AUTH_PASSWD_API_SUCCESS; - } - - int PasswordManager::setPassword(unsigned int passwdType, - const std::string ¤tPassword, - const std::string &newPassword, - unsigned int currentUser) - { - LogSecureDebug("curUser = " << currentUser << ", pwdType = " << passwdType << - ", curPwd = " << currentPassword << ", newPwd = " << newPassword); - - unsigned int receivedDays = PASSWORD_INFINITE_EXPIRATION_DAYS; - time_t valid_secs = 0; - - existPassword(currentUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); - - if (itPwd->second.isIgnorePeriod()) { - LogError("Retry timeout occured."); - return AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER; - } - - // check delivered currentPassword - // when m_passwordActive flag is false, current password should be empty - if (!currentPassword.empty() && !itPwd->second.isPasswordActive(passwdType)) { - LogError("Password not active."); - return AUTH_PASSWD_API_ERROR_NO_PASSWORD; - } - - switch(passwdType) { - case AUTH_PWD_NORMAL: - - //increment attempt count before checking it against max attempt count - itPwd->second.incrementAttempt(); - itPwd->second.writeAttemptToFile(); - - if (itPwd->second.checkIfAttemptsExceeded()) { - LogError("Too many tries."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED; - } - - if (!itPwd->second.checkPassword(AUTH_PWD_NORMAL, currentPassword)) { - LogError("Wrong password."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; - } - - //here we are sure that user knows current password - we can reset attempt counter - itPwd->second.resetAttempt(); - itPwd->second.writeAttemptToFile(); - - // check history, however only if history is active and new password is not empty - if (itPwd->second.isHistoryActive() && !newPassword.empty()) { - if (itPwd->second.isPasswordReused(newPassword)) { - LogError("Password reused."); - return AUTH_PASSWD_API_ERROR_PASSWORD_REUSED; - } - } - - if (!newPassword.empty()) - receivedDays = itPwd->second.getExpireTime(); - - calculateExpiredTime(receivedDays, valid_secs); - - //setting password - itPwd->second.setPassword(AUTH_PWD_NORMAL, newPassword); - itPwd->second.setExpireTimeLeft(valid_secs); - itPwd->second.writeMemoryToFile(); - break; - - case AUTH_PWD_RECOVERY: - if (!itPwd->second.checkPassword(AUTH_PWD_RECOVERY, currentPassword)) { - LogError("Wrong password."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; - } - itPwd->second.setPassword(AUTH_PWD_RECOVERY, newPassword); - itPwd->second.writeMemoryToFile(); - break; - - default: - LogError("Not supported password type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - return AUTH_PASSWD_API_SUCCESS; - } - - int PasswordManager::setPasswordRecovery(const std::string &curRcvPassword, - const std::string &newPassword, - unsigned int currentUser) - { - LogSecureDebug("curUser = " << currentUser << ", curPwd = " << curRcvPassword << - ", newPwd = " << newPassword); - - unsigned int receivedDays = PASSWORD_INFINITE_EXPIRATION_DAYS; - time_t valid_secs = 0; - - existPassword(currentUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); - - if (itPwd->second.isIgnorePeriod()) { - LogError("Retry timeout occured."); - return AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER; - } - - //check if passwords are correct - if (curRcvPassword.empty() || newPassword.empty()) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - - // current recovery password should be existed. - if (!itPwd->second.isPasswordActive(AUTH_PWD_RECOVERY)) { - LogError("Password not active."); - return AUTH_PASSWD_API_ERROR_NO_PASSWORD; - } - - receivedDays = itPwd->second.getExpireTime(); - - // don't recovery password if MaxAttempt value is not infinite. - if (receivedDays != PASSWORD_INFINITE_EXPIRATION_DAYS) - return AUTH_PASSWD_API_ERROR_RECOVERY_PASSWORD_RESTRICTED; - - if (!itPwd->second.checkPassword(AUTH_PWD_RECOVERY, curRcvPassword)) { - LogError("Wrong password."); - return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; - } - - // check history, however only if history is active and new password is not empty - if (itPwd->second.isHistoryActive()) { - if (itPwd->second.isPasswordReused(newPassword)) { - LogError("Password reused."); - return AUTH_PASSWD_API_ERROR_PASSWORD_REUSED; - } - } - - calculateExpiredTime(receivedDays, valid_secs); - - itPwd->second.resetAttempt(); - itPwd->second.writeAttemptToFile(); - - //setting password - itPwd->second.setPassword(AUTH_PWD_NORMAL, newPassword); - itPwd->second.setExpireTimeLeft(valid_secs); - itPwd->second.writeMemoryToFile(); - - return AUTH_PASSWD_API_SUCCESS; - } - - int PasswordManager::resetPassword(unsigned int passwdType, - const std::string &newPassword, - unsigned int receivedUser) - { - unsigned int receivedDays = PASSWORD_INFINITE_EXPIRATION_DAYS; - time_t valid_secs = 0; - - existPassword(receivedUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); - - switch(passwdType) { - case AUTH_PWD_NORMAL: - - if (!newPassword.empty()) - receivedDays = itPwd->second.getExpireTime(); - - calculateExpiredTime(receivedDays, valid_secs); - - itPwd->second.resetAttempt(); - itPwd->second.writeAttemptToFile(); - - itPwd->second.setPassword(AUTH_PWD_NORMAL, newPassword); - itPwd->second.setExpireTimeLeft(valid_secs); - itPwd->second.writeMemoryToFile(); - break; - - case AUTH_PWD_RECOVERY: - itPwd->second.setPassword(AUTH_PWD_RECOVERY, newPassword); - itPwd->second.writeMemoryToFile(); - break; - - default: - LogError("Not supported password type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - return AUTH_PASSWD_API_SUCCESS; - } + PasswordFileMap::iterator itPwd = m_pwdFile.find(user); - void PasswordManager::setPasswordMaxAttempts(unsigned int receivedUser, - unsigned int receivedAttempts) - { - LogSecureDebug("received_attempts: " << receivedAttempts); + if (itPwd != m_pwdFile.end()) + return; - existPassword(receivedUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + addPassword(user); + return; +} - itPwd->second.setMaxAttempt(receivedAttempts); - itPwd->second.writeMemoryToFile(); +int PasswordManager::checkPassword(unsigned int passwdType, + const std::string &challenge, + unsigned int currentUser, + unsigned int ¤tAttempt, + unsigned int &maxAttempt, + unsigned int &expirationTime) +{ + LogSecureDebug("Inside checkPassword function."); + existPassword(currentUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); + + if (itPwd->second.isIgnorePeriod()) { + LogError("Retry timeout occurred."); + return AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER; + } + + if (!itPwd->second.isPasswordActive(passwdType) && !challenge.empty()) { + LogError("Password not active."); + return AUTH_PASSWD_API_ERROR_NO_PASSWORD; + } + + switch (passwdType) { + case AUTH_PWD_NORMAL: + itPwd->second.incrementAttempt(); + itPwd->second.writeAttemptToFile(); + currentAttempt = itPwd->second.getAttempt(); + maxAttempt = itPwd->second.getMaxAttempt(); + expirationTime = itPwd->second.getExpireTimeLeft(); + + if (itPwd->second.checkIfAttemptsExceeded()) { + LogError("Too many tries."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED; + } + + if (!itPwd->second.checkPassword(AUTH_PWD_NORMAL, challenge)) { + LogError("Wrong password."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; + } + + // Password maches and attempt number is fine - time to reset counter. + itPwd->second.resetAttempt(); + itPwd->second.writeAttemptToFile(); + + // Password is too old. You must change it before login. + if (itPwd->second.checkExpiration()) { + LogError("Password expired."); + return AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED; + } + + break; + + case AUTH_PWD_RECOVERY: + if (!itPwd->second.checkPassword(AUTH_PWD_RECOVERY, challenge)) { + LogError("Wrong password."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; + } + + break; + + default: + LogError("Not supported password type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + return AUTH_PASSWD_API_SUCCESS; +} + +int PasswordManager::isPwdValid(unsigned int passwdType, unsigned int currentUser, + unsigned int ¤tAttempt, unsigned int &maxAttempt, + unsigned int &expirationTime) +{ + existPassword(currentUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); + + if (!itPwd->second.isPasswordActive(passwdType)) { + LogError("Current password not active."); + return AUTH_PASSWD_API_ERROR_NO_PASSWORD; + } + + switch (passwdType) { + case AUTH_PWD_NORMAL: + currentAttempt = itPwd->second.getAttempt(); + maxAttempt = itPwd->second.getMaxAttempt(); + expirationTime = itPwd->second.getExpireTimeLeft(); + break; + + case AUTH_PWD_RECOVERY: + // there are no maxAttempt and expirationTime for recovery password + currentAttempt = PASSWORD_INFINITE_ATTEMPT_COUNT; + maxAttempt = PASSWORD_INFINITE_ATTEMPT_COUNT; + expirationTime = PASSWORD_API_NO_EXPIRATION; + break; + + default: + LogError("Not supported password type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + return AUTH_PASSWD_API_SUCCESS; +} + +int PasswordManager::isPwdReused(unsigned int passwdType, const std::string &passwd, + unsigned int currentUser, bool &isReused) +{ + existPassword(currentUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); + isReused = false; - itPwd->second.resetAttempt(); - itPwd->second.writeAttemptToFile(); - } + switch (passwdType) { + case AUTH_PWD_NORMAL: - void PasswordManager::setPasswordValidity(unsigned int receivedUser, - unsigned int receivedDays) - { - LogSecureDebug("received_days: " << receivedDays); + // check history, however only if history is active and password is not empty + if (itPwd->second.isHistoryActive() && !passwd.empty()) + isReused = itPwd->second.isPasswordReused(passwd); - time_t valid_secs = 0; + break; - existPassword(receivedUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + case AUTH_PWD_RECOVERY: + break; - calculateExpiredTime(receivedDays, valid_secs); + default: + LogError("Not supported password type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } - if (itPwd->second.isPasswordActive(AUTH_PWD_NORMAL)) - itPwd->second.setExpireTimeLeft(valid_secs); + return AUTH_PASSWD_API_SUCCESS; +} - itPwd->second.setExpireTime(receivedDays); - itPwd->second.writeMemoryToFile(); - } +int PasswordManager::setPassword(unsigned int passwdType, + const std::string ¤tPassword, + const std::string &newPassword, + unsigned int currentUser) +{ + LogSecureDebug("curUser = " << currentUser << ", pwdType = " << passwdType << + ", curPwd = " << currentPassword << ", newPwd = " << newPassword); + unsigned int receivedDays = PASSWORD_INFINITE_EXPIRATION_DAYS; + time_t valid_secs = 0; + existPassword(currentUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); + + if (itPwd->second.isIgnorePeriod()) { + LogError("Retry timeout occured."); + return AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER; + } + + // check delivered currentPassword + // when m_passwordActive flag is false, current password should be empty + if (!currentPassword.empty() && !itPwd->second.isPasswordActive(passwdType)) { + LogError("Password not active."); + return AUTH_PASSWD_API_ERROR_NO_PASSWORD; + } + + switch (passwdType) { + case AUTH_PWD_NORMAL: + //increment attempt count before checking it against max attempt count + itPwd->second.incrementAttempt(); + itPwd->second.writeAttemptToFile(); + + if (itPwd->second.checkIfAttemptsExceeded()) { + LogError("Too many tries."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED; + } + + if (!itPwd->second.checkPassword(AUTH_PWD_NORMAL, currentPassword)) { + LogError("Wrong password."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; + } + + //here we are sure that user knows current password - we can reset attempt counter + itPwd->second.resetAttempt(); + itPwd->second.writeAttemptToFile(); + + // check history, however only if history is active and new password is not empty + if (itPwd->second.isHistoryActive() && !newPassword.empty()) { + if (itPwd->second.isPasswordReused(newPassword)) { + LogError("Password reused."); + return AUTH_PASSWD_API_ERROR_PASSWORD_REUSED; + } + } + + if (!newPassword.empty()) + receivedDays = itPwd->second.getExpireTime(); + + calculateExpiredTime(receivedDays, valid_secs); + //setting password + itPwd->second.setPassword(AUTH_PWD_NORMAL, newPassword); + itPwd->second.setExpireTimeLeft(valid_secs); + itPwd->second.writeMemoryToFile(); + break; + + case AUTH_PWD_RECOVERY: + if (!itPwd->second.checkPassword(AUTH_PWD_RECOVERY, currentPassword)) { + LogError("Wrong password."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; + } + + itPwd->second.setPassword(AUTH_PWD_RECOVERY, newPassword); + itPwd->second.writeMemoryToFile(); + break; + + default: + LogError("Not supported password type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + return AUTH_PASSWD_API_SUCCESS; +} + +int PasswordManager::setPasswordRecovery(const std::string &curRcvPassword, + const std::string &newPassword, + unsigned int currentUser) +{ + LogSecureDebug("curUser = " << currentUser << ", curPwd = " << curRcvPassword << + ", newPwd = " << newPassword); + unsigned int receivedDays = PASSWORD_INFINITE_EXPIRATION_DAYS; + time_t valid_secs = 0; + existPassword(currentUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(currentUser); + + if (itPwd->second.isIgnorePeriod()) { + LogError("Retry timeout occured."); + return AUTH_PASSWD_API_ERROR_PASSWORD_RETRY_TIMER; + } + + //check if passwords are correct + if (curRcvPassword.empty() || newPassword.empty()) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + // current recovery password should be existed. + if (!itPwd->second.isPasswordActive(AUTH_PWD_RECOVERY)) { + LogError("Password not active."); + return AUTH_PASSWD_API_ERROR_NO_PASSWORD; + } + + receivedDays = itPwd->second.getExpireTime(); + + // don't recovery password if MaxAttempt value is not infinite. + if (receivedDays != PASSWORD_INFINITE_EXPIRATION_DAYS) + return AUTH_PASSWD_API_ERROR_RECOVERY_PASSWORD_RESTRICTED; + + if (!itPwd->second.checkPassword(AUTH_PWD_RECOVERY, curRcvPassword)) { + LogError("Wrong password."); + return AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH; + } + + // check history, however only if history is active and new password is not empty + if (itPwd->second.isHistoryActive()) { + if (itPwd->second.isPasswordReused(newPassword)) { + LogError("Password reused."); + return AUTH_PASSWD_API_ERROR_PASSWORD_REUSED; + } + } + + calculateExpiredTime(receivedDays, valid_secs); + itPwd->second.resetAttempt(); + itPwd->second.writeAttemptToFile(); + //setting password + itPwd->second.setPassword(AUTH_PWD_NORMAL, newPassword); + itPwd->second.setExpireTimeLeft(valid_secs); + itPwd->second.writeMemoryToFile(); + return AUTH_PASSWD_API_SUCCESS; +} + +int PasswordManager::resetPassword(unsigned int passwdType, + const std::string &newPassword, + unsigned int receivedUser) +{ + unsigned int receivedDays = PASSWORD_INFINITE_EXPIRATION_DAYS; + time_t valid_secs = 0; + existPassword(receivedUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + + switch (passwdType) { + case AUTH_PWD_NORMAL: + if (!newPassword.empty()) + receivedDays = itPwd->second.getExpireTime(); + + calculateExpiredTime(receivedDays, valid_secs); + itPwd->second.resetAttempt(); + itPwd->second.writeAttemptToFile(); + itPwd->second.setPassword(AUTH_PWD_NORMAL, newPassword); + itPwd->second.setExpireTimeLeft(valid_secs); + itPwd->second.writeMemoryToFile(); + break; + + case AUTH_PWD_RECOVERY: + itPwd->second.setPassword(AUTH_PWD_RECOVERY, newPassword); + itPwd->second.writeMemoryToFile(); + break; + + default: + LogError("Not supported password type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + return AUTH_PASSWD_API_SUCCESS; +} + +void PasswordManager::setPasswordMaxAttempts(unsigned int receivedUser, + unsigned int receivedAttempts) +{ + LogSecureDebug("received_attempts: " << receivedAttempts); + existPassword(receivedUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + itPwd->second.setMaxAttempt(receivedAttempts); + itPwd->second.writeMemoryToFile(); + itPwd->second.resetAttempt(); + itPwd->second.writeAttemptToFile(); +} + +void PasswordManager::setPasswordValidity(unsigned int receivedUser, + unsigned int receivedDays) +{ + LogSecureDebug("received_days: " << receivedDays); + time_t valid_secs = 0; + existPassword(receivedUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + calculateExpiredTime(receivedDays, valid_secs); - void PasswordManager::setPasswordHistory(unsigned int receivedUser, - unsigned int receivedHistory) - { - LogSecureDebug("received_historySize: " << receivedHistory); + if (itPwd->second.isPasswordActive(AUTH_PWD_NORMAL)) + itPwd->second.setExpireTimeLeft(valid_secs); - existPassword(receivedUser); - PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + itPwd->second.setExpireTime(receivedDays); + itPwd->second.writeMemoryToFile(); +} - itPwd->second.setMaxHistorySize(receivedHistory); - itPwd->second.writeMemoryToFile(); - } +void PasswordManager::setPasswordHistory(unsigned int receivedUser, + unsigned int receivedHistory) +{ + LogSecureDebug("received_historySize: " << receivedHistory); + existPassword(receivedUser); + PasswordFileMap::iterator itPwd = m_pwdFile.find(receivedUser); + itPwd->second.setMaxHistorySize(receivedHistory); + itPwd->second.writeMemoryToFile(); +} } //namespace AuthPasswd diff --git a/src/server/service/password.cpp b/src/server/service/password.cpp index e58f833..a44c3a9 100644 --- a/src/server/service/password.cpp +++ b/src/server/service/password.cpp @@ -63,302 +63,310 @@ const InterfaceID SOCKET_ID_POLICY = 3; GenericSocketService::ServiceDescriptionVector PasswordService::GetServiceDescription() { - return ServiceDescriptionVector { - {SERVICE_SOCKET_PASSWD_CHECK, "*", SOCKET_ID_CHECK}, - {SERVICE_SOCKET_PASSWD_SET, "*", SOCKET_ID_SET}, - {SERVICE_SOCKET_PASSWD_RESET, "*", SOCKET_ID_RESET}, - {SERVICE_SOCKET_PASSWD_POLICY, "*", SOCKET_ID_POLICY} - }; + return ServiceDescriptionVector { + {SERVICE_SOCKET_PASSWD_CHECK, "*", SOCKET_ID_CHECK}, + {SERVICE_SOCKET_PASSWD_SET, "*", SOCKET_ID_SET}, + {SERVICE_SOCKET_PASSWD_RESET, "*", SOCKET_ID_RESET}, + {SERVICE_SOCKET_PASSWD_POLICY, "*", SOCKET_ID_POLICY} + }; } -void PasswordService::Start() { - Create(); +void PasswordService::Start() +{ + Create(); } -void PasswordService::Stop() { - Join(); +void PasswordService::Stop() +{ + Join(); } void PasswordService::accept(const AcceptEvent &event) { - LogSecureDebug("Accept event. ConnectionID.sock: " << event.connectionID.sock - << " ConnectionID.counter: " << event.connectionID.counter - << " ServiceID: " << event.interfaceID); - - auto &info = m_connectionInfoMap[event.connectionID.counter]; - info.interfaceID = event.interfaceID; + LogSecureDebug("Accept event. ConnectionID.sock: " << event.connectionID.sock + << " ConnectionID.counter: " << event.connectionID.counter + << " ServiceID: " << event.interfaceID); + auto &info = m_connectionInfoMap[event.connectionID.counter]; + info.interfaceID = event.interfaceID; } void PasswordService::write(const WriteEvent &event) { - LogSecureDebug("WriteEvent. ConnectionID: " << event.connectionID.sock << - " Size: " << event.size << " Left: " << event.left); - if (event.left == 0) - m_serviceManager->Close(event.connectionID); + LogSecureDebug("WriteEvent. ConnectionID: " << event.connectionID.sock << + " Size: " << event.size << " Left: " << event.left); + + if (event.left == 0) + m_serviceManager->Close(event.connectionID); } void PasswordService::process(const ReadEvent &event) { - LogSecureDebug("Read event for counter: " << event.connectionID.counter); - auto &info = m_connectionInfoMap[event.connectionID.counter]; - info.buffer.Push(event.rawBuffer); + LogSecureDebug("Read event for counter: " << event.connectionID.counter); + auto &info = m_connectionInfoMap[event.connectionID.counter]; + info.buffer.Push(event.rawBuffer); - // We can get several requests in one package. - // Extract and process them all - while(processOne(event.connectionID, info.buffer, info.interfaceID)); + // We can get several requests in one package. + // Extract and process them all + while (processOne(event.connectionID, info.buffer, info.interfaceID)); } void PasswordService::close(const CloseEvent &event) { - LogSecureDebug("CloseEvent. ConnectionID: " << event.connectionID.sock); - m_connectionInfoMap.erase(event.connectionID.counter); + LogSecureDebug("CloseEvent. ConnectionID: " << event.connectionID.sock); + m_connectionInfoMap.erase(event.connectionID.counter); } -int PasswordService::processCheckFunctions(PasswordHdrs hdr, MessageBuffer& buffer, - unsigned int cur_user, unsigned int &cur_att, - unsigned int &max_att, unsigned int &exp_time) +int PasswordService::processCheckFunctions(PasswordHdrs hdr, MessageBuffer &buffer, + unsigned int cur_user, unsigned int &cur_att, + unsigned int &max_att, unsigned int &exp_time) { - int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - - switch (hdr) { - case PasswordHdrs::HDR_CHK_PASSWD: { - unsigned int passwdType = 0; - std::string challenge; - Deserialization::Deserialize(buffer, passwdType); - Deserialization::Deserialize(buffer, challenge); - result = m_pwdManager.checkPassword(passwdType, challenge, cur_user, cur_att, max_att, - exp_time); - break; - } - - case PasswordHdrs::HDR_CHK_PASSWD_STATE: { - unsigned int passwdType = 0; - Deserialization::Deserialize(buffer, passwdType); - result = m_pwdManager.isPwdValid(passwdType, cur_user, cur_att, max_att, exp_time); - break; - } - - default: - LogError("Unknown msg header."); - Throw(Exception::IncorrectHeader); - } - return result; + int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + + switch (hdr) { + case PasswordHdrs::HDR_CHK_PASSWD: { + unsigned int passwdType = 0; + std::string challenge; + Deserialization::Deserialize(buffer, passwdType); + Deserialization::Deserialize(buffer, challenge); + result = m_pwdManager.checkPassword(passwdType, challenge, cur_user, cur_att, max_att, + exp_time); + break; + } + + case PasswordHdrs::HDR_CHK_PASSWD_STATE: { + unsigned int passwdType = 0; + Deserialization::Deserialize(buffer, passwdType); + result = m_pwdManager.isPwdValid(passwdType, cur_user, cur_att, max_att, exp_time); + break; + } + + default: + LogError("Unknown msg header."); + Throw(Exception::IncorrectHeader); + } + + return result; } -int PasswordService::processSetFunctions(PasswordHdrs hdr, MessageBuffer& buffer, - unsigned int cur_user, bool &isPwdReused) +int PasswordService::processSetFunctions(PasswordHdrs hdr, MessageBuffer &buffer, + unsigned int cur_user, bool &isPwdReused) { - int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - - switch (hdr) { - case PasswordHdrs::HDR_SET_PASSWD: { - std::string curPasswd, newPasswd; - unsigned int passwdType = 0; - Deserialization::Deserialize(buffer, passwdType); - Deserialization::Deserialize(buffer, curPasswd); - Deserialization::Deserialize(buffer, newPasswd); - result = m_policyManager.checkPolicy(passwdType, curPasswd, newPasswd, cur_user); - if (result == AUTH_PASSWD_API_SUCCESS) - result = m_pwdManager.setPassword(passwdType, curPasswd, newPasswd, cur_user); - break; - } - - case PasswordHdrs::HDR_SET_PASSWD_RECOVERY: { - std::string curRcvPasswd, newPasswd; - Deserialization::Deserialize(buffer, curRcvPasswd); - Deserialization::Deserialize(buffer, newPasswd); - result = m_policyManager.checkPolicy(AUTH_PWD_NORMAL, curRcvPasswd, newPasswd, cur_user); - if (result == AUTH_PASSWD_API_SUCCESS) - result = m_pwdManager.setPasswordRecovery(curRcvPasswd, newPasswd, cur_user); - break; - } - - case PasswordHdrs::HDR_CHK_PASSWD_REUSED: { - unsigned int passwdType = 0; - std::string passwd; - Deserialization::Deserialize(buffer, passwdType); - Deserialization::Deserialize(buffer, passwd); - result = m_pwdManager.isPwdReused(passwdType, passwd, cur_user, isPwdReused); - break; - } - - default: - LogError("Unknown msg header."); - Throw(Exception::IncorrectHeader); - } - return result; + int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + + switch (hdr) { + case PasswordHdrs::HDR_SET_PASSWD: { + std::string curPasswd, newPasswd; + unsigned int passwdType = 0; + Deserialization::Deserialize(buffer, passwdType); + Deserialization::Deserialize(buffer, curPasswd); + Deserialization::Deserialize(buffer, newPasswd); + result = m_policyManager.checkPolicy(passwdType, curPasswd, newPasswd, cur_user); + + if (result == AUTH_PASSWD_API_SUCCESS) + result = m_pwdManager.setPassword(passwdType, curPasswd, newPasswd, cur_user); + + break; + } + + case PasswordHdrs::HDR_SET_PASSWD_RECOVERY: { + std::string curRcvPasswd, newPasswd; + Deserialization::Deserialize(buffer, curRcvPasswd); + Deserialization::Deserialize(buffer, newPasswd); + result = m_policyManager.checkPolicy(AUTH_PWD_NORMAL, curRcvPasswd, newPasswd, cur_user); + + if (result == AUTH_PASSWD_API_SUCCESS) + result = m_pwdManager.setPasswordRecovery(curRcvPasswd, newPasswd, cur_user); + + break; + } + + case PasswordHdrs::HDR_CHK_PASSWD_REUSED: { + unsigned int passwdType = 0; + std::string passwd; + Deserialization::Deserialize(buffer, passwdType); + Deserialization::Deserialize(buffer, passwd); + result = m_pwdManager.isPwdReused(passwdType, passwd, cur_user, isPwdReused); + break; + } + + default: + LogError("Unknown msg header."); + Throw(Exception::IncorrectHeader); + } + + return result; } -int PasswordService::processResetFunctions(PasswordHdrs hdr, MessageBuffer& buffer) +int PasswordService::processResetFunctions(PasswordHdrs hdr, MessageBuffer &buffer) { - int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - - std::string newPasswd, emptyStr=""; - unsigned int passwdType = 0; - uid_t rec_user = 0; - - switch (hdr) { - case PasswordHdrs::HDR_RST_PASSWD: - Deserialization::Deserialize(buffer, passwdType); - Deserialization::Deserialize(buffer, rec_user); - Deserialization::Deserialize(buffer, newPasswd); - result = m_pwdManager.resetPassword(passwdType, newPasswd, rec_user); - break; - - default: - LogError("Unknown msg header."); - Throw(Exception::IncorrectHeader); - } - return result; + int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + std::string newPasswd, emptyStr = ""; + unsigned int passwdType = 0; + uid_t rec_user = 0; + + switch (hdr) { + case PasswordHdrs::HDR_RST_PASSWD: + Deserialization::Deserialize(buffer, passwdType); + Deserialization::Deserialize(buffer, rec_user); + Deserialization::Deserialize(buffer, newPasswd); + result = m_pwdManager.resetPassword(passwdType, newPasswd, rec_user); + break; + + default: + LogError("Unknown msg header."); + Throw(Exception::IncorrectHeader); + } + + return result; } -int PasswordService::processPolicyFunctions(PasswordHdrs hdr, MessageBuffer& buffer) +int PasswordService::processPolicyFunctions(PasswordHdrs hdr, MessageBuffer &buffer) { - int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - - switch (hdr) { - case PasswordHdrs::HDR_SET_PASSWD_POLICY: { - Policy policy; - - Deserialization::Deserialize(buffer, policy.flag); - Deserialization::Deserialize(buffer, policy.uid); - Deserialization::Deserialize(buffer, policy.maxAttempts); - Deserialization::Deserialize(buffer, policy.validPeriod); - Deserialization::Deserialize(buffer, policy.historySize); - Deserialization::Deserialize(buffer, policy.minLength); - Deserialization::Deserialize(buffer, policy.minComplexCharNumber); - Deserialization::Deserialize(buffer, policy.maxCharOccurrences); - Deserialization::Deserialize(buffer, policy.maxNumSeqLength); - Deserialization::Deserialize(buffer, policy.qualityType); - Deserialization::Deserialize(buffer, policy.pattern); - Deserialization::Deserialize(buffer, policy.forbiddenPasswds); - - result = m_policyManager.setPolicy(policy); - - if (result == AUTH_PASSWD_API_SUCCESS) { - if (policy.isFlagOn(POLICY_MAX_ATTEMPTS)) - m_pwdManager.setPasswordMaxAttempts(policy.uid, policy.maxAttempts); - if (policy.isFlagOn(POLICY_VALID_PERIOD)) - m_pwdManager.setPasswordValidity(policy.uid, policy.validPeriod); - if (policy.isFlagOn(POLICY_HISTORY_SIZE)) - m_pwdManager.setPasswordHistory(policy.uid, policy.historySize); - } - break; - } - - case PasswordHdrs::HDR_DIS_PASSWD_POLICY: { - uid_t rec_user = 0; - Deserialization::Deserialize(buffer, rec_user); - result = m_policyManager.disablePolicy(rec_user); - if (result == AUTH_PASSWD_API_SUCCESS) { - m_pwdManager.setPasswordMaxAttempts(rec_user, PASSWORD_INFINITE_ATTEMPT_COUNT); - m_pwdManager.setPasswordValidity(rec_user, PASSWORD_INFINITE_EXPIRATION_DAYS); - m_pwdManager.setPasswordHistory(rec_user, 0); - } - break; - } - - default: - LogError("Unknown msg header."); - Throw(Exception::IncorrectHeader); - } - - return result; + int result = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + + switch (hdr) { + case PasswordHdrs::HDR_SET_PASSWD_POLICY: { + Policy policy; + Deserialization::Deserialize(buffer, policy.flag); + Deserialization::Deserialize(buffer, policy.uid); + Deserialization::Deserialize(buffer, policy.maxAttempts); + Deserialization::Deserialize(buffer, policy.validPeriod); + Deserialization::Deserialize(buffer, policy.historySize); + Deserialization::Deserialize(buffer, policy.minLength); + Deserialization::Deserialize(buffer, policy.minComplexCharNumber); + Deserialization::Deserialize(buffer, policy.maxCharOccurrences); + Deserialization::Deserialize(buffer, policy.maxNumSeqLength); + Deserialization::Deserialize(buffer, policy.qualityType); + Deserialization::Deserialize(buffer, policy.pattern); + Deserialization::Deserialize(buffer, policy.forbiddenPasswds); + result = m_policyManager.setPolicy(policy); + + if (result == AUTH_PASSWD_API_SUCCESS) { + if (policy.isFlagOn(POLICY_MAX_ATTEMPTS)) + m_pwdManager.setPasswordMaxAttempts(policy.uid, policy.maxAttempts); + + if (policy.isFlagOn(POLICY_VALID_PERIOD)) + m_pwdManager.setPasswordValidity(policy.uid, policy.validPeriod); + + if (policy.isFlagOn(POLICY_HISTORY_SIZE)) + m_pwdManager.setPasswordHistory(policy.uid, policy.historySize); + } + + break; + } + + case PasswordHdrs::HDR_DIS_PASSWD_POLICY: { + uid_t rec_user = 0; + Deserialization::Deserialize(buffer, rec_user); + result = m_policyManager.disablePolicy(rec_user); + + if (result == AUTH_PASSWD_API_SUCCESS) { + m_pwdManager.setPasswordMaxAttempts(rec_user, PASSWORD_INFINITE_ATTEMPT_COUNT); + m_pwdManager.setPasswordValidity(rec_user, PASSWORD_INFINITE_EXPIRATION_DAYS); + m_pwdManager.setPasswordHistory(rec_user, 0); + } + + break; + } + + default: + LogError("Unknown msg header."); + Throw(Exception::IncorrectHeader); + } + + return result; } bool PasswordService::processOne(const ConnectionID &conn, MessageBuffer &buffer, - InterfaceID interfaceID) + InterfaceID interfaceID) { - LogSecureDebug("Iteration begin"); - - MessageBuffer sendBuffer; - - int retCode = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - unsigned int cur_user = 0, cur_att = 0, max_att = 0, exp_time = 0; - bool isPwdReused; - - if (!buffer.Ready()) - return false; - - Try { //try..catch for MessageBuffer errors, closes connection when exception is thrown - int tempHdr; - Deserialization::Deserialize(buffer, tempHdr); - PasswordHdrs hdr = static_cast(tempHdr); - - try { //try..catch for internal service errors, assigns error code for returning. - switch (interfaceID) { - case SOCKET_ID_CHECK: - if(socket_get_user(conn.sock, cur_user)) - retCode = AUTH_PASSWD_API_ERROR_NO_USER; - else - retCode = processCheckFunctions(hdr, buffer, cur_user, cur_att, max_att, exp_time); - break; - - case SOCKET_ID_SET: - if(socket_get_user(conn.sock, cur_user)) - retCode = AUTH_PASSWD_API_ERROR_NO_USER; - else - retCode = processSetFunctions(hdr, buffer, cur_user, isPwdReused); - break; - - case SOCKET_ID_RESET: - retCode = processResetFunctions(hdr, buffer); - break; - - case SOCKET_ID_POLICY: - retCode = processPolicyFunctions(hdr, buffer); - break; - - default: - LogError("Wrong interfaceID."); - Throw(Exception::IncorrectHeader); - } - } catch (PasswordException::Base &e) { - LogError("Password error: " << e.DumpToString()); - retCode = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - } catch (std::exception &e) { - LogError("STD error: " << e.what()); - retCode = AUTH_PASSWD_API_ERROR_SERVER_ERROR; - } - - //everything is OK, send return code and extra data - Serialization::Serialize(sendBuffer, retCode); - - //Returning additional information should occur only when checking functions - //are called, and under certain return values - if (interfaceID == SOCKET_ID_CHECK) - { - switch(retCode) - { - case AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH: - case AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED: - case AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED: - case AUTH_PASSWD_API_SUCCESS: - Serialization::Serialize(sendBuffer, cur_att); - Serialization::Serialize(sendBuffer, max_att); - Serialization::Serialize(sendBuffer, exp_time); - break; - default: - break; - } - } else if (interfaceID == SOCKET_ID_SET) { - if (hdr == PasswordHdrs::HDR_CHK_PASSWD_REUSED && retCode == AUTH_PASSWD_API_SUCCESS) { - Serialization::Serialize(sendBuffer, (int)isPwdReused); - } - } - - m_serviceManager->Write(conn, sendBuffer.Pop()); - } Catch (MessageBuffer::Exception::Base) { - LogError("Broken protocol. Closing socket."); - m_serviceManager->Close(conn); - return false; - } Catch (PasswordService::Exception::Base) { - LogError("Incorrect message header. Closing socket."); - m_serviceManager->Close(conn); - return false; - } - - return true; + LogSecureDebug("Iteration begin"); + MessageBuffer sendBuffer; + int retCode = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + unsigned int cur_user = 0, cur_att = 0, max_att = 0, exp_time = 0; + bool isPwdReused; + + if (!buffer.Ready()) + return false; + + Try { //try..catch for MessageBuffer errors, closes connection when exception is thrown + int tempHdr; + Deserialization::Deserialize(buffer, tempHdr); + PasswordHdrs hdr = static_cast(tempHdr); + + try { //try..catch for internal service errors, assigns error code for returning. + switch (interfaceID) { + case SOCKET_ID_CHECK: + if (socket_get_user(conn.sock, cur_user)) + retCode = AUTH_PASSWD_API_ERROR_NO_USER; + else + retCode = processCheckFunctions(hdr, buffer, cur_user, cur_att, max_att, exp_time); + + break; + + case SOCKET_ID_SET: + if (socket_get_user(conn.sock, cur_user)) + retCode = AUTH_PASSWD_API_ERROR_NO_USER; + else + retCode = processSetFunctions(hdr, buffer, cur_user, isPwdReused); + + break; + + case SOCKET_ID_RESET: + retCode = processResetFunctions(hdr, buffer); + break; + + case SOCKET_ID_POLICY: + retCode = processPolicyFunctions(hdr, buffer); + break; + + default: + LogError("Wrong interfaceID."); + Throw(Exception::IncorrectHeader); + } + } catch (PasswordException::Base &e) { + LogError("Password error: " << e.DumpToString()); + retCode = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + } catch (std::exception &e) { + LogError("STD error: " << e.what()); + retCode = AUTH_PASSWD_API_ERROR_SERVER_ERROR; + } + + //everything is OK, send return code and extra data + Serialization::Serialize(sendBuffer, retCode); + + //Returning additional information should occur only when checking functions + //are called, and under certain return values + if (interfaceID == SOCKET_ID_CHECK) { + switch (retCode) { + case AUTH_PASSWD_API_ERROR_PASSWORD_MISMATCH: + case AUTH_PASSWD_API_ERROR_PASSWORD_MAX_ATTEMPTS_EXCEEDED: + case AUTH_PASSWD_API_ERROR_PASSWORD_EXPIRED: + case AUTH_PASSWD_API_SUCCESS: + Serialization::Serialize(sendBuffer, cur_att); + Serialization::Serialize(sendBuffer, max_att); + Serialization::Serialize(sendBuffer, exp_time); + break; + + default: + break; + } + } else if (interfaceID == SOCKET_ID_SET) { + if (hdr == PasswordHdrs::HDR_CHK_PASSWD_REUSED && retCode == AUTH_PASSWD_API_SUCCESS) + Serialization::Serialize(sendBuffer, (int)isPwdReused); + } + + m_serviceManager->Write(conn, sendBuffer.Pop()); + } Catch(MessageBuffer::Exception::Base) { + LogError("Broken protocol. Closing socket."); + m_serviceManager->Close(conn); + return false; + } Catch(PasswordService::Exception::Base) { + LogError("Incorrect message header. Closing socket."); + m_serviceManager->Close(conn); + return false; + } + return true; } } // namespace AuthPasswd diff --git a/src/server/service/policy-file.cpp b/src/server/service/policy-file.cpp index f06a7e8..b7266e7 100644 --- a/src/server/service/policy-file.cpp +++ b/src/server/service/policy-file.cpp @@ -44,336 +44,337 @@ #include namespace { - const std::string POLICY_FILE = "/policy"; - const mode_t FILE_MODE = S_IRUSR | S_IWUSR; - const unsigned int CURRENT_FILE_VERSION = 1; +const std::string POLICY_FILE = "/policy"; +const mode_t FILE_MODE = S_IRUSR | S_IWUSR; +const unsigned int CURRENT_FILE_VERSION = 1; } // namespace anonymous -namespace AuthPasswd +namespace AuthPasswd { +PolicyFile::PolicyFile(unsigned int user): m_user(user), m_enable(false) { - PolicyFile::PolicyFile(unsigned int user): m_user(user), m_enable(false) - { - // check if data directory exists - // if not create it - std::string userDir = createDir(RW_DATA_DIR, m_user); - - if (!dirExists(RW_DATA_DIR)) { - if(mkdir(RW_DATA_DIR, 0700)) { - LogError("Failed to create directory for files. Error: " << errnoToString()); - Throw(PasswordException::MakeDirError); - } - } - - if (!dirExists(userDir.c_str())) { - if(mkdir(userDir.c_str(), 0700)) { - LogError("Failed to create directory for files. Error: " << errnoToString()); - Throw(PasswordException::MakeDirError); - } - } - - preparePolicyFile(); - } - - void PolicyFile::resetState() - { - m_enable = false; - m_policy = Policy(); - } - - void PolicyFile::preparePolicyFile() - { - std::string policyFile = createDir(RW_DATA_DIR, m_user) + POLICY_FILE; - - // check if policy file exists - if (!fileExists(policyFile)) { - LogSecureDebug("POLICY_DBG not found " << m_user << " policy file. Creating."); - - //create file - writeMemoryToFile(); - } else { //if file exists, load data - LogSecureDebug("POLICY_DBG found " << m_user << " policy file. Opening."); - try { - loadMemoryFromFile(); - } catch (...) { - LogError("Invalid " << policyFile << " file format"); - resetState(); - writeMemoryToFile(); - } - } - } - - bool PolicyFile::fileExists(const std::string &filename) const - { - struct stat buf; - - return ((stat(filename.c_str(), &buf) == 0)); - } - - bool PolicyFile::dirExists(const std::string &dirpath) const - { - struct stat buf; - - return ((stat(dirpath.c_str(), &buf) == 0) && (((buf.st_mode) & S_IFMT) == S_IFDIR)); - } - - std::string PolicyFile::createDir(const std::string &dir, unsigned int user) const - { - std::string User = std::to_string(user); - return dir + "/" + User; - } - - void PolicyFile::writeMemoryToFile() const - { - PasswordFileBuffer policyBuffer; - - LogSecureDebug("User: " << m_user << "Policy: " << m_policy.info()); - - // serialize policy attributes - Serialization::Serialize(policyBuffer, CURRENT_FILE_VERSION); - Serialization::Serialize(policyBuffer, m_enable); - - PolicySerializable policys(m_policy); - policys.Serialize(policyBuffer); - - std::string policyFile = createDir(RW_DATA_DIR, m_user) + POLICY_FILE; - policyBuffer.Save(policyFile); - - if (chmod(policyFile.c_str(), FILE_MODE)) { - LogError("Failed to chmod for " << policyFile << " Error: " << errnoToString()); - Throw(PasswordException::ChmodError); - } - } - - void PolicyFile::loadMemoryFromFile() - { - PasswordFileBuffer policyBuffer; - std::string policyFile = createDir(RW_DATA_DIR, m_user) + POLICY_FILE; - - policyBuffer.Load(policyFile); - - // deserialize policy attributes - unsigned int fileVersion = 0; - Deserialization::Deserialize(policyBuffer, fileVersion); - if (fileVersion != CURRENT_FILE_VERSION) - Throw(PasswordException::FStreamReadError); - - Deserialization::Deserialize(policyBuffer, m_enable); - PolicySerializable policys(policyBuffer); - m_policy = *(dynamic_cast(&policys)); - - LogSecureDebug("User: " << m_user << "Policy: " << m_policy.info()); - } - - void PolicyFile::enable() - { - m_enable = true; - } - - void PolicyFile::disable() - { - m_enable = false; - resetState(); - } - - bool PolicyFile::isPolicyActive() const - { - return m_enable; - } - - // policy minLength - bool PolicyFile::checkMinLength(const std::string &password) const - { - return (password.size() >= m_policy.minLength); - } - - void PolicyFile::setMinLength(unsigned int minLength) - { - m_policy.minLength = minLength; - } - - // policy minComplexCharNumber - bool PolicyFile::checkMinComplexCharNumber(const std::string &password) const - { - unsigned int i = 0, cnt = 0; - char ch; - - if (m_policy.minComplexCharNumber == 0) - return true; - - for (i = 0; i < password.size(); i++) { - ch = password[i]; - if( ch < 'A' || ( 'Z' < ch && ch < 'a') || 'z' < ch) - cnt++; - } - return (cnt >= m_policy.minComplexCharNumber); - } - - void PolicyFile::setMinComplexCharNumber(unsigned int minComplexCharNumber) - { - m_policy.minComplexCharNumber = minComplexCharNumber; - } - - bool PolicyFile::checkMaxCharOccurrences(const std::string &password) const - { - std::vector occurrence(256, 0); - - if (m_policy.maxCharOccurrences == 0) - return true; - - for (auto ch : password) - occurrence[static_cast(ch)]++; - - for (auto item : occurrence) - if (item > m_policy.maxCharOccurrences) - return false; - - return true; - } - - void PolicyFile::setMaxCharOccurrences(unsigned int maxCharOccurrences) - { - m_policy.maxCharOccurrences = maxCharOccurrences; - } - - // policy maxNumSeqLength - bool PolicyFile::checkMaxNumSeqLength(const std::string &password) const - { - char curr_ch = 0, prev_num = 0; - unsigned int i, num_cnt=0, max_num_seq_len = 0, curr_num_seq_len = 0; - unsigned int len = password.size(); - int order = -2; // -2: not set, -1 : decreasing, 0 : same, +1: increasing - - if (m_policy.maxNumSeqLength == 0) - return true; - - for (i = 0; i < len; i++) { - curr_ch = password[i]; - if ('0' <= curr_ch && curr_ch <= '9') { - num_cnt++; - if (order == -2) { // not set, fist or second char of a sequence - if (prev_num == 0) { // fist second char - curr_num_seq_len = 1; - } else if (curr_ch == prev_num - 1) { // decreasing order - order = -1; - curr_num_seq_len = 2; - } else if (curr_ch == prev_num + 0) { // same order - order = 0; - curr_num_seq_len = 2; - } else if (curr_ch == prev_num + 1) { // increasing order - order = 1; - curr_num_seq_len = 2; - } else { // order restarts again - if (max_num_seq_len < curr_num_seq_len) - max_num_seq_len = curr_num_seq_len; - - order = -2; - curr_num_seq_len = 1; - } - } else if (curr_ch == prev_num + order) { // order is still working - curr_num_seq_len++; - } else { // order changed - if (max_num_seq_len < curr_num_seq_len) - max_num_seq_len = curr_num_seq_len; - order = -2; - curr_num_seq_len = 1; - } - prev_num = curr_ch; - } else { // order reset - if (max_num_seq_len < curr_num_seq_len) - max_num_seq_len = curr_num_seq_len; - - order = -2; - curr_num_seq_len = 0; - prev_num = 0; - } - } - return max_num_seq_len <= m_policy.maxNumSeqLength; - } - - void PolicyFile::setMaxNumSeqLength(unsigned int maxNumSeqLength) - { - m_policy.maxNumSeqLength = maxNumSeqLength; - } - - // policy qalityType - bool PolicyFile::checkQualityType(const std::string &password) const - { - std::string pattern; - - switch (m_policy.qualityType) { - case AUTH_PWD_QUALITY_UNSPECIFIED: - pattern = REGEX_QUALITY_UNSPECIFIED; - break; - - case AUTH_PWD_QUALITY_SOMETHING: - pattern = REGEX_QUALITY_SOMETHING; - break; - - case AUTH_PWD_QUALITY_NUMERIC: - pattern = REGEX_QUALITY_NUMERIC; - break; - - case AUTH_PWD_QUALITY_ALPHABETIC: - pattern = REGEX_QUALITY_ALPHABETIC; - break; - - case AUTH_PWD_QUALITY_ALPHANUMERIC: - pattern = REGEX_QUALITY_ALPHANUMERIC; - break; - - default: - return false; - } - - regex_t re; - if (regcomp(&re, pattern.c_str(), REG_EXTENDED|REG_NEWLINE) != 0) - return false; - return (regexec(&re, password.c_str(), 0, NULL, 0) == 0); - } - - void PolicyFile::setQualityType(unsigned int qualityType) - { - m_policy.qualityType = qualityType; - } - - // policy pattern - bool PolicyFile::isValidPattern(const std::string &pattern) const - { - if (pattern.empty()) - return true; - - regex_t re; - return (regcomp(&re, pattern.c_str(), REG_EXTENDED|REG_NEWLINE) == 0); - } - - bool PolicyFile::checkPattern(const std::string &password) const - { - if (m_policy.pattern.empty()) - return true; - - regex_t re; - if (regcomp(&re, m_policy.pattern.c_str(), REG_EXTENDED|REG_NEWLINE) != 0) - return false; - - return (regexec(&re, password.c_str(), 0, NULL, 0) == 0); - } - - void PolicyFile::setPattern(const std::string &pattern) - { - m_policy.pattern = pattern; - } - - // policy forbiddenPasswds - bool PolicyFile::checkForbiddenPasswds(const std::string &password) const - { - return password.empty() || m_policy.forbiddenPasswds.count(password) == 0; - } - - void PolicyFile::setForbiddenPasswds(std::set forbiddenPasswds) - { - for (auto &passwd : forbiddenPasswds) { - if (!passwd.empty()) - m_policy.forbiddenPasswds.insert(passwd); - } - } + // check if data directory exists + // if not create it + std::string userDir = createDir(RW_DATA_DIR, m_user); + + if (!dirExists(RW_DATA_DIR)) { + if (mkdir(RW_DATA_DIR, 0700)) { + LogError("Failed to create directory for files. Error: " << errnoToString()); + Throw(PasswordException::MakeDirError); + } + } + + if (!dirExists(userDir.c_str())) { + if (mkdir(userDir.c_str(), 0700)) { + LogError("Failed to create directory for files. Error: " << errnoToString()); + Throw(PasswordException::MakeDirError); + } + } + + preparePolicyFile(); +} + +void PolicyFile::resetState() +{ + m_enable = false; + m_policy = Policy(); +} + +void PolicyFile::preparePolicyFile() +{ + std::string policyFile = createDir(RW_DATA_DIR, m_user) + POLICY_FILE; + + // check if policy file exists + if (!fileExists(policyFile)) { + LogSecureDebug("POLICY_DBG not found " << m_user << " policy file. Creating."); + //create file + writeMemoryToFile(); + } else { //if file exists, load data + LogSecureDebug("POLICY_DBG found " << m_user << " policy file. Opening."); + + try { + loadMemoryFromFile(); + } catch (...) { + LogError("Invalid " << policyFile << " file format"); + resetState(); + writeMemoryToFile(); + } + } +} + +bool PolicyFile::fileExists(const std::string &filename) const +{ + struct stat buf; + return ((stat(filename.c_str(), &buf) == 0)); +} + +bool PolicyFile::dirExists(const std::string &dirpath) const +{ + struct stat buf; + return ((stat(dirpath.c_str(), &buf) == 0) && (((buf.st_mode) & S_IFMT) == S_IFDIR)); +} + +std::string PolicyFile::createDir(const std::string &dir, unsigned int user) const +{ + std::string User = std::to_string(user); + return dir + "/" + User; +} + +void PolicyFile::writeMemoryToFile() const +{ + PasswordFileBuffer policyBuffer; + LogSecureDebug("User: " << m_user << "Policy: " << m_policy.info()); + // serialize policy attributes + Serialization::Serialize(policyBuffer, CURRENT_FILE_VERSION); + Serialization::Serialize(policyBuffer, m_enable); + PolicySerializable policys(m_policy); + policys.Serialize(policyBuffer); + std::string policyFile = createDir(RW_DATA_DIR, m_user) + POLICY_FILE; + policyBuffer.Save(policyFile); + + if (chmod(policyFile.c_str(), FILE_MODE)) { + LogError("Failed to chmod for " << policyFile << " Error: " << errnoToString()); + Throw(PasswordException::ChmodError); + } +} + +void PolicyFile::loadMemoryFromFile() +{ + PasswordFileBuffer policyBuffer; + std::string policyFile = createDir(RW_DATA_DIR, m_user) + POLICY_FILE; + policyBuffer.Load(policyFile); + // deserialize policy attributes + unsigned int fileVersion = 0; + Deserialization::Deserialize(policyBuffer, fileVersion); + + if (fileVersion != CURRENT_FILE_VERSION) + Throw(PasswordException::FStreamReadError); + + Deserialization::Deserialize(policyBuffer, m_enable); + PolicySerializable policys(policyBuffer); + m_policy = *(dynamic_cast(&policys)); + LogSecureDebug("User: " << m_user << "Policy: " << m_policy.info()); +} + +void PolicyFile::enable() +{ + m_enable = true; +} + +void PolicyFile::disable() +{ + m_enable = false; + resetState(); +} + +bool PolicyFile::isPolicyActive() const +{ + return m_enable; +} + +// policy minLength +bool PolicyFile::checkMinLength(const std::string &password) const +{ + return (password.size() >= m_policy.minLength); +} + +void PolicyFile::setMinLength(unsigned int minLength) +{ + m_policy.minLength = minLength; +} + +// policy minComplexCharNumber +bool PolicyFile::checkMinComplexCharNumber(const std::string &password) const +{ + unsigned int i = 0, cnt = 0; + char ch; + + if (m_policy.minComplexCharNumber == 0) + return true; + + for (i = 0; i < password.size(); i++) { + ch = password[i]; + + if (ch < 'A' || ('Z' < ch && ch < 'a') || 'z' < ch) + cnt++; + } + + return (cnt >= m_policy.minComplexCharNumber); +} + +void PolicyFile::setMinComplexCharNumber(unsigned int minComplexCharNumber) +{ + m_policy.minComplexCharNumber = minComplexCharNumber; +} + +bool PolicyFile::checkMaxCharOccurrences(const std::string &password) const +{ + std::vector occurrence(256, 0); + + if (m_policy.maxCharOccurrences == 0) + return true; + + for (auto ch : password) + occurrence[static_cast(ch)]++; + + for (auto item : occurrence) + if (item > m_policy.maxCharOccurrences) + return false; + + return true; +} + +void PolicyFile::setMaxCharOccurrences(unsigned int maxCharOccurrences) +{ + m_policy.maxCharOccurrences = maxCharOccurrences; +} + +// policy maxNumSeqLength +bool PolicyFile::checkMaxNumSeqLength(const std::string &password) const +{ + char curr_ch = 0, prev_num = 0; + unsigned int i, num_cnt = 0, max_num_seq_len = 0, curr_num_seq_len = 0; + unsigned int len = password.size(); + int order = -2; // -2: not set, -1 : decreasing, 0 : same, +1: increasing + + if (m_policy.maxNumSeqLength == 0) + return true; + + for (i = 0; i < len; i++) { + curr_ch = password[i]; + + if ('0' <= curr_ch && curr_ch <= '9') { + num_cnt++; + + if (order == -2) { // not set, fist or second char of a sequence + if (prev_num == 0) // fist second char + curr_num_seq_len = 1; + else if (curr_ch == prev_num - 1) { // decreasing order + order = -1; + curr_num_seq_len = 2; + } else if (curr_ch == prev_num + 0) { // same order + order = 0; + curr_num_seq_len = 2; + } else if (curr_ch == prev_num + 1) { // increasing order + order = 1; + curr_num_seq_len = 2; + } else { // order restarts again + if (max_num_seq_len < curr_num_seq_len) + max_num_seq_len = curr_num_seq_len; + + order = -2; + curr_num_seq_len = 1; + } + } else if (curr_ch == prev_num + order) // order is still working + curr_num_seq_len++; + else { // order changed + if (max_num_seq_len < curr_num_seq_len) + max_num_seq_len = curr_num_seq_len; + + order = -2; + curr_num_seq_len = 1; + } + + prev_num = curr_ch; + } else { // order reset + if (max_num_seq_len < curr_num_seq_len) + max_num_seq_len = curr_num_seq_len; + + order = -2; + curr_num_seq_len = 0; + prev_num = 0; + } + } + + return max_num_seq_len <= m_policy.maxNumSeqLength; +} + +void PolicyFile::setMaxNumSeqLength(unsigned int maxNumSeqLength) +{ + m_policy.maxNumSeqLength = maxNumSeqLength; +} + +// policy qalityType +bool PolicyFile::checkQualityType(const std::string &password) const +{ + std::string pattern; + + switch (m_policy.qualityType) { + case AUTH_PWD_QUALITY_UNSPECIFIED: + pattern = REGEX_QUALITY_UNSPECIFIED; + break; + + case AUTH_PWD_QUALITY_SOMETHING: + pattern = REGEX_QUALITY_SOMETHING; + break; + + case AUTH_PWD_QUALITY_NUMERIC: + pattern = REGEX_QUALITY_NUMERIC; + break; + + case AUTH_PWD_QUALITY_ALPHABETIC: + pattern = REGEX_QUALITY_ALPHABETIC; + break; + + case AUTH_PWD_QUALITY_ALPHANUMERIC: + pattern = REGEX_QUALITY_ALPHANUMERIC; + break; + + default: + return false; + } + + regex_t re; + + if (regcomp(&re, pattern.c_str(), REG_EXTENDED | REG_NEWLINE) != 0) + return false; + + return (regexec(&re, password.c_str(), 0, NULL, 0) == 0); +} + +void PolicyFile::setQualityType(unsigned int qualityType) +{ + m_policy.qualityType = qualityType; +} + +// policy pattern +bool PolicyFile::isValidPattern(const std::string &pattern) const +{ + if (pattern.empty()) + return true; + + regex_t re; + return (regcomp(&re, pattern.c_str(), REG_EXTENDED | REG_NEWLINE) == 0); +} + +bool PolicyFile::checkPattern(const std::string &password) const +{ + if (m_policy.pattern.empty()) + return true; + + regex_t re; + + if (regcomp(&re, m_policy.pattern.c_str(), REG_EXTENDED | REG_NEWLINE) != 0) + return false; + + return (regexec(&re, password.c_str(), 0, NULL, 0) == 0); +} + +void PolicyFile::setPattern(const std::string &pattern) +{ + m_policy.pattern = pattern; +} + +// policy forbiddenPasswds +bool PolicyFile::checkForbiddenPasswds(const std::string &password) const +{ + return password.empty() || m_policy.forbiddenPasswds.count(password) == 0; +} + +void PolicyFile::setForbiddenPasswds(std::set forbiddenPasswds) +{ + for (auto &passwd : forbiddenPasswds) { + if (!passwd.empty()) + m_policy.forbiddenPasswds.insert(passwd); + } +} } //namespace AuthPasswd diff --git a/src/server/service/policy-manager.cpp b/src/server/service/policy-manager.cpp index 78f1771..f999496 100644 --- a/src/server/service/policy-manager.cpp +++ b/src/server/service/policy-manager.cpp @@ -35,241 +35,252 @@ #include #include -namespace AuthPasswd +namespace AuthPasswd { +void PolicyManager::addPolicy(unsigned int user) { - void PolicyManager::addPolicy(unsigned int user) - { - m_policyFile.insert(PolicyFileMap::value_type(user, PolicyFile(user))); - } - - void PolicyManager::removePolicy(unsigned int user) - { - m_policyFile.erase(user); - } - - void PolicyManager::existPolicy(unsigned int user) - { - PolicyFileMap::iterator itPwd = m_policyFile.find(user); - if (itPwd != m_policyFile.end()) - return; - - addPolicy(user); - return; - } - - int PolicyManager::checkPolicy(unsigned int passwdType, - const std::string ¤tPassword, - const std::string &newPassword, - unsigned int user) - { - LogSecureDebug("Inside checkPolicy function."); - - // check if passwords are correct - if (currentPassword.size() > MAX_PASSWORD_LEN) { - LogError("Current password length failed."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - if (newPassword.size() > MAX_PASSWORD_LEN) { - LogError("New password length failed."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - - existPolicy(user); - PolicyFileMap::iterator itPolicy = m_policyFile.find(user); - - if (!itPolicy->second.isPolicyActive() || (passwdType != AUTH_PWD_NORMAL)) - return AUTH_PASSWD_API_SUCCESS; - - if (!itPolicy->second.checkMinLength(newPassword)) { - LogError("new passwd's minLength is invalid"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - if (!itPolicy->second.checkMinComplexCharNumber(newPassword)) { - LogError("new passwd's minComplexCharNumber is invalid"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - if (!itPolicy->second.checkMaxCharOccurrences(newPassword)) { - LogError("new passwd's maxCharOccurrences is invalid"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - if (!itPolicy->second.checkMaxNumSeqLength(newPassword)) { - LogError("new passwd's maxNumSeqLength is invalid"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - if (!itPolicy->second.checkQualityType(newPassword)) { - LogError("new passwd's qualityType is invalid"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - if (!itPolicy->second.checkPattern(newPassword)) { - LogError("new passwd's pattern is invalid"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - if (!itPolicy->second.checkForbiddenPasswds(newPassword)) { - LogError("new passwd is forbiddenPasswd"); - return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; - } - - return AUTH_PASSWD_API_SUCCESS; - } - - int PolicyManager::setPolicy(Policy policy) - { - LogSecureDebug("Inside setPolicy function."); - - existPolicy(policy.uid); - PolicyFileMap::iterator itPolicy = m_policyFile.find(policy.uid); - - // check if policies are correct - for (int i = POLICY_TYPE_FIRST ; i < POLICY_TYPE_LAST+1 ; i++) { - if (!policy.isFlagOn(static_cast(i))) - continue; - - switch (i) { - case POLICY_MAX_ATTEMPTS: - break; - - case POLICY_VALID_PERIOD: { - time_t curTime = time(NULL); - if (policy.validPeriod > ((UINT_MAX - curTime) / 86400)) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - } - - case POLICY_HISTORY_SIZE: - if (policy.historySize > MAX_PASSWORD_HISTORY) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_MIN_LENGTH: - if (policy.minLength > MAX_PASSWORD_LEN) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_MIN_COMPLEX_CHAR_NUMBER: - if (policy.minComplexCharNumber > MAX_PASSWORD_LEN) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_MAX_CHAR_OCCURRENCES: - if (policy.maxCharOccurrences > MAX_PASSWORD_LEN) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_MAX_NUMERIC_SEQ_LENGTH: - if (policy.maxNumSeqLength > MAX_PASSWORD_LEN) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_QUALITY_TYPE: - if (policy.qualityType > AUTH_PWD_QUALITY_LAST) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_PATTERN: - if (!itPolicy->second.isValidPattern(policy.pattern)) { - LogError("Incorrect input param."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - break; - - case POLICY_FORBIDDEN_PASSWDS: - break; - - default: - LogError("Not supported policy type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - } - - // update policies - for (int i = POLICY_TYPE_FIRST ; i < POLICY_TYPE_LAST+1 ; i++) { - if (!policy.isFlagOn(static_cast(i))) - continue; - - switch (i) { - case POLICY_MAX_ATTEMPTS: - LogSecureDebug("maxAttempts: " << policy.maxAttempts); - break; - - case POLICY_VALID_PERIOD: - LogSecureDebug("validPeriod: " << policy.validPeriod); - break; - - case POLICY_HISTORY_SIZE: - LogSecureDebug("historySize: " << policy.historySize); - break; - - case POLICY_MIN_LENGTH: - LogSecureDebug("minLength: " << policy.minLength); - itPolicy->second.setMinLength(policy.minLength); - break; - - case POLICY_MIN_COMPLEX_CHAR_NUMBER: - LogSecureDebug("minComplexCharNumber: " << policy.minComplexCharNumber); - itPolicy->second.setMinComplexCharNumber(policy.minComplexCharNumber); - break; - - case POLICY_MAX_CHAR_OCCURRENCES: - LogSecureDebug("maxCharOccurrences: " << policy.maxCharOccurrences); - itPolicy->second.setMaxCharOccurrences(policy.maxCharOccurrences); - break; - - case POLICY_MAX_NUMERIC_SEQ_LENGTH: - LogSecureDebug("maxNumSeqLength: " << policy.maxNumSeqLength); - itPolicy->second.setMaxNumSeqLength(policy.maxNumSeqLength); - break; - - case POLICY_QUALITY_TYPE: - LogSecureDebug("qualityType: " << policy.qualityType); - itPolicy->second.setQualityType(policy.qualityType); - break; - - case POLICY_PATTERN: - LogSecureDebug("pattern: " << policy.pattern); - itPolicy->second.setPattern(policy.pattern); - break; - - case POLICY_FORBIDDEN_PASSWDS: - LogSecureDebug("forbiddenPasswds number: " << policy.forbiddenPasswds.size()); - itPolicy->second.setForbiddenPasswds(policy.forbiddenPasswds); - break; - - default: - LogError("Not supported policy type."); - return AUTH_PASSWD_API_ERROR_INPUT_PARAM; - } - } - - itPolicy->second.enable(); - itPolicy->second.writeMemoryToFile(); - - return AUTH_PASSWD_API_SUCCESS; - } - - int PolicyManager::disablePolicy(unsigned int user) - { - LogSecureDebug("Inside disablePolicy function."); - - existPolicy(user); - PolicyFileMap::iterator itPolicy = m_policyFile.find(user); - - itPolicy->second.disable(); - itPolicy->second.writeMemoryToFile(); - - return AUTH_PASSWD_API_SUCCESS; - } + m_policyFile.insert(PolicyFileMap::value_type(user, PolicyFile(user))); +} + +void PolicyManager::removePolicy(unsigned int user) +{ + m_policyFile.erase(user); +} + +void PolicyManager::existPolicy(unsigned int user) +{ + PolicyFileMap::iterator itPwd = m_policyFile.find(user); + + if (itPwd != m_policyFile.end()) + return; + + addPolicy(user); + return; +} + +int PolicyManager::checkPolicy(unsigned int passwdType, + const std::string ¤tPassword, + const std::string &newPassword, + unsigned int user) +{ + LogSecureDebug("Inside checkPolicy function."); + + // check if passwords are correct + if (currentPassword.size() > MAX_PASSWORD_LEN) { + LogError("Current password length failed."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + if (newPassword.size() > MAX_PASSWORD_LEN) { + LogError("New password length failed."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + existPolicy(user); + PolicyFileMap::iterator itPolicy = m_policyFile.find(user); + + if (!itPolicy->second.isPolicyActive() || (passwdType != AUTH_PWD_NORMAL)) + return AUTH_PASSWD_API_SUCCESS; + + if (!itPolicy->second.checkMinLength(newPassword)) { + LogError("new passwd's minLength is invalid"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + if (!itPolicy->second.checkMinComplexCharNumber(newPassword)) { + LogError("new passwd's minComplexCharNumber is invalid"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + if (!itPolicy->second.checkMaxCharOccurrences(newPassword)) { + LogError("new passwd's maxCharOccurrences is invalid"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + if (!itPolicy->second.checkMaxNumSeqLength(newPassword)) { + LogError("new passwd's maxNumSeqLength is invalid"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + if (!itPolicy->second.checkQualityType(newPassword)) { + LogError("new passwd's qualityType is invalid"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + if (!itPolicy->second.checkPattern(newPassword)) { + LogError("new passwd's pattern is invalid"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + if (!itPolicy->second.checkForbiddenPasswds(newPassword)) { + LogError("new passwd is forbiddenPasswd"); + return AUTH_PASSWD_API_ERROR_PASSWORD_INVALID; + } + + return AUTH_PASSWD_API_SUCCESS; +} + +int PolicyManager::setPolicy(Policy policy) +{ + LogSecureDebug("Inside setPolicy function."); + existPolicy(policy.uid); + PolicyFileMap::iterator itPolicy = m_policyFile.find(policy.uid); + + // check if policies are correct + for (int i = POLICY_TYPE_FIRST ; i < POLICY_TYPE_LAST + 1 ; i++) { + if (!policy.isFlagOn(static_cast(i))) + continue; + + switch (i) { + case POLICY_MAX_ATTEMPTS: + break; + + case POLICY_VALID_PERIOD: { + time_t curTime = time(NULL); + + if (policy.validPeriod > ((UINT_MAX - curTime) / 86400)) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + } + + case POLICY_HISTORY_SIZE: + if (policy.historySize > MAX_PASSWORD_HISTORY) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_MIN_LENGTH: + if (policy.minLength > MAX_PASSWORD_LEN) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_MIN_COMPLEX_CHAR_NUMBER: + if (policy.minComplexCharNumber > MAX_PASSWORD_LEN) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_MAX_CHAR_OCCURRENCES: + if (policy.maxCharOccurrences > MAX_PASSWORD_LEN) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_MAX_NUMERIC_SEQ_LENGTH: + if (policy.maxNumSeqLength > MAX_PASSWORD_LEN) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_QUALITY_TYPE: + if (policy.qualityType > AUTH_PWD_QUALITY_LAST) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_PATTERN: + if (!itPolicy->second.isValidPattern(policy.pattern)) { + LogError("Incorrect input param."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + + break; + + case POLICY_FORBIDDEN_PASSWDS: + break; + + default: + LogError("Not supported policy type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + } + + // update policies + for (int i = POLICY_TYPE_FIRST ; i < POLICY_TYPE_LAST + 1 ; i++) { + if (!policy.isFlagOn(static_cast(i))) + continue; + + switch (i) { + case POLICY_MAX_ATTEMPTS: + LogSecureDebug("maxAttempts: " << policy.maxAttempts); + break; + + case POLICY_VALID_PERIOD: + LogSecureDebug("validPeriod: " << policy.validPeriod); + break; + + case POLICY_HISTORY_SIZE: + LogSecureDebug("historySize: " << policy.historySize); + break; + + case POLICY_MIN_LENGTH: + LogSecureDebug("minLength: " << policy.minLength); + itPolicy->second.setMinLength(policy.minLength); + break; + + case POLICY_MIN_COMPLEX_CHAR_NUMBER: + LogSecureDebug("minComplexCharNumber: " << policy.minComplexCharNumber); + itPolicy->second.setMinComplexCharNumber(policy.minComplexCharNumber); + break; + + case POLICY_MAX_CHAR_OCCURRENCES: + LogSecureDebug("maxCharOccurrences: " << policy.maxCharOccurrences); + itPolicy->second.setMaxCharOccurrences(policy.maxCharOccurrences); + break; + + case POLICY_MAX_NUMERIC_SEQ_LENGTH: + LogSecureDebug("maxNumSeqLength: " << policy.maxNumSeqLength); + itPolicy->second.setMaxNumSeqLength(policy.maxNumSeqLength); + break; + + case POLICY_QUALITY_TYPE: + LogSecureDebug("qualityType: " << policy.qualityType); + itPolicy->second.setQualityType(policy.qualityType); + break; + + case POLICY_PATTERN: + LogSecureDebug("pattern: " << policy.pattern); + itPolicy->second.setPattern(policy.pattern); + break; + + case POLICY_FORBIDDEN_PASSWDS: + LogSecureDebug("forbiddenPasswds number: " << policy.forbiddenPasswds.size()); + itPolicy->second.setForbiddenPasswds(policy.forbiddenPasswds); + break; + + default: + LogError("Not supported policy type."); + return AUTH_PASSWD_API_ERROR_INPUT_PARAM; + } + } + + itPolicy->second.enable(); + itPolicy->second.writeMemoryToFile(); + return AUTH_PASSWD_API_SUCCESS; +} + +int PolicyManager::disablePolicy(unsigned int user) +{ + LogSecureDebug("Inside disablePolicy function."); + existPolicy(user); + PolicyFileMap::iterator itPolicy = m_policyFile.find(user); + itPolicy->second.disable(); + itPolicy->second.writeMemoryToFile(); + return AUTH_PASSWD_API_SUCCESS; +} } //namespace AuthPasswd