sensord: [Svace] change strerror to strerror_r

- make macro for strerror_r
- strerror_r returns error message that it is from buf or static string
  according to a man page

* details
"This may be either a pointer to a string that the function stores in
buf, or a pointer to some (immutable)  static  string  (ini which  case
buf is unused)."

Change-Id: Ifbca885a211e53d74e29268a25b597ff4d2897af
Signed-off-by: kibak.yoon <kibak.yoon@samsung.com>

diff --git a/src/server/sensor_loader.cpp b/src/server/sensor_loader.cpp
index c65915e..9066d95 100644 (file)
--- a/src/server/sensor_loader.cpp
+++ b/src/server/sensor_loader.cpp
@@ -239,7 +239,7 @@ sensor_base* sensor_loader::create_sensor(void)
                _E("Failed to create sensor, exception: %s", e.what());
                return NULL;
        } catch (int err) {
-               _E("Failed to create sensor err: %d, cause: %s", err, strerror(err));
+               _ERRNO(errno);
                return NULL;
        }
 

diff --git a/src/shared/csocket.cpp b/src/shared/csocket.cpp
index c6e7998..16cb296 100644 (file)
--- a/src/shared/csocket.cpp
+++ b/src/shared/csocket.cpp
@@ -69,8 +69,8 @@ bool csocket::create(int sock_type)
        m_sock_fd = socket(AF_UNIX, sock_type, 0);
 
        if (!is_valid()) {
-               _E("Failed to create socket for %s, errno : %d , errstr : %s ",
-                       get_client_name(), errno, strerror(errno));
+               _E("Failed to create socket for %s", get_client_name());
+               _ERRNO(errno);
                return false;
        }
 
@@ -100,14 +100,16 @@ bool csocket::bind (const char *sock_path)
        length = strlen(m_addr.sun_path) + sizeof(m_addr.sun_family);
 
        if (::bind(m_sock_fd, (struct sockaddr *)&m_addr, length) < 0) {
-               _E("Binding failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+               _E("Binding failed for socket(%d)", m_sock_fd);
+               _ERRNO(errno);
                close();
                return false;
        }
 
        socket_mode = ( S_IRWXU | S_IRWXG | S_IRWXO );
        if (chmod(sock_path, socket_mode) < 0) {
-               _E("chmod failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+               _E("chmod failed for socket(%d)", m_sock_fd);
+               _ERRNO(errno);
                close();
                return false;
        }
@@ -123,7 +125,8 @@ bool csocket::listen(const int max_connections)
        }
 
        if (::listen(m_sock_fd, max_connections) < 0) {
-               _E("Listening failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+               _E("Listening failed for socket(%d)", m_sock_fd);
+               _ERRNO(errno);
                close();
                return false;
        }
@@ -145,7 +148,8 @@ bool csocket::accept(csocket& client_socket) const
        } while (err == EINTR);
 
        if (!client_socket.is_valid()) {
-               _E("Accept failed for socket(%d), errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+               _E("Accept failed for socket(%d)", m_sock_fd);
+               _ERRNO(errno);
                return false;
        }
 
@@ -162,8 +166,9 @@ ssize_t csocket::send_for_seqpacket(const void *buffer, size_t size) const
        } while (err == EINTR);
 
        if (err) {
-               _E("send(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
-                       m_sock_fd, buffer, size, m_send_flags, len, strerror(errno), errno);
+               _E("send(%d, 0x%x, %d, 0x%x) = %d",
+                       m_sock_fd, buffer, size, m_send_flags, len);
+               _ERRNO(errno);
        }
 
        return err == 0 ? len : -err;
@@ -188,14 +193,16 @@ ssize_t csocket::recv_for_seqpacket(void* buffer, size_t size) const
     } while (err == EINTR);
 
        if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
-               _D("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
-                       m_sock_fd, buffer, size, m_recv_flags, len, strerror(errno), errno);
+               _D("recv(%d, 0x%x, %d, 0x%x) = %d",
+                       m_sock_fd, buffer, size, m_recv_flags, len);
+               _ERRNO(errno);
                return 0;
        }
 
        if (err) {
-               _E("recv(%d, 0x%x, %d, 0x%x) = %d cause = %s(%d)",
-                       m_sock_fd, buffer, size, m_recv_flags, len, strerror(errno), errno);
+               _E("recv(%d, 0x%x, %d, 0x%x) = %d",
+                       m_sock_fd, buffer, size, m_recv_flags, len);
+               _ERRNO(errno);
        }
 
     return err == 0 ? len : -err;
@@ -215,9 +222,10 @@ ssize_t csocket::send_for_stream(const void *buffer, size_t size) const
                        total_sent_size += len;
                        err = 0;
                } else {
-                       _E("send(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s",
+                       _E("send(%d, 0x%p + %d, %d - %d) = %d for %s",
                                m_sock_fd, buffer, total_sent_size, size, total_sent_size,
-                               len, strerror(errno), errno, get_client_name());
+                               len, get_client_name());
+                       _ERRNO(errno);
 
                        if (errno != EINTR) {
                                err = errno;
@@ -246,9 +254,10 @@ ssize_t csocket::recv_for_stream(void* buffer, size_t size) const
                        err = 1;
                        break;
                } else {
-                       _E("recv(%d, 0x%p + %d, %d - %d) = %d, error: %s(%d) for %s",
+                       _E("recv(%d, 0x%p + %d, %d - %d) = %d for %s",
                                m_sock_fd, buffer, total_recv_size, size, total_recv_size,
-                               len, strerror(errno), errno, get_client_name());
+                               len, get_client_name());
+                       _ERRNO(errno);
 
                        if (errno != EINTR) {
                                err = errno;
@@ -301,7 +310,8 @@ bool csocket::connect(const char *sock_path)
        addr_len = strlen(m_addr.sun_path) + sizeof(m_addr.sun_family);
 
        if (::connect(m_sock_fd,(sockaddr *) &m_addr, addr_len) < 0) {
-               _E("connect error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name());
+               _E("connect error: sock_fd: %d\n for %s", m_sock_fd, get_client_name());
+               _ERRNO(errno);
                return false;
        }
 
@@ -315,7 +325,8 @@ bool csocket::connect(const char *sock_path)
        ret = select(m_sock_fd + 1, NULL, &write_fds, NULL, &tv);
 
        if (ret == -1) {
-               _E("select error: %s sock_fd: %d\n for %s", strerror(errno), m_sock_fd, get_client_name());
+               _E("select error: sock_fd: %d\n for %s", m_sock_fd, get_client_name());
+               _ERRNO(errno);
                close();
                return false;
        } else if (!ret) {
@@ -334,8 +345,8 @@ bool csocket::connect(const char *sock_path)
        socklen_t len = sizeof(so_error);
 
        if (getsockopt(m_sock_fd, SOL_SOCKET, SO_ERROR, &so_error, &len) == -1) {
-               _E("getsockopt failed for %s, m_sock_fd : %d, errno : %d , errstr : %s",
-                       get_client_name(), m_sock_fd, errno, strerror(errno));
+               _E("getsockopt failed for %s, m_sock_fd : %d", get_client_name(), m_sock_fd);
+               _ERRNO(errno);
                close();
                return false;
        }
@@ -360,7 +371,8 @@ bool csocket::set_blocking_mode(bool blocking)
        flags = fcntl(m_sock_fd, F_GETFL);
 
        if (flags == -1) {
-               _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+               _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d", get_client_name(), m_sock_fd);
+               _ERRNO(errno);
                return false;
        }
 
@@ -369,7 +381,8 @@ bool csocket::set_blocking_mode(bool blocking)
        flags = fcntl(m_sock_fd, F_SETFL, flags);
 
        if (flags == -1) {
-               _E("fcntl(F_SETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+               _E("fcntl(F_SETFL) failed for %s, m_sock_fd: %d", get_client_name(), m_sock_fd);
+               _ERRNO(errno);
                return false;
        }
 
@@ -385,7 +398,9 @@ bool csocket::set_sock_type(void)
        opt_len = sizeof(sock_type);
 
        if (getsockopt(m_sock_fd, SOL_SOCKET, SO_TYPE, &sock_type, &opt_len) < 0) {
-          _E("getsockopt(SOL_SOCKET, SO_TYPE) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+          _E("getsockopt(SOL_SOCKET, SO_TYPE) failed for %s, m_sock_fd: %d",
+                 get_client_name(), m_sock_fd);
+          _ERRNO(errno);
           return false;
        }
 
@@ -404,8 +419,8 @@ bool csocket::set_connection_mode(void)
        tv.tv_usec = 0;
 
        if(setsockopt(m_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
-               _E("Set SO_RCVTIMEO failed for %s, m_sock_fd : %d, errno : %d , errstr : %s",
-                       get_client_name(), m_sock_fd, errno, strerror(errno));
+               _E("Set SO_RCVTIMEO failed for %s, m_sock_fd : %d", get_client_name(), m_sock_fd);
+               _ERRNO(errno);
                close();
                return false;
        }
@@ -434,7 +449,8 @@ bool csocket::is_blocking_mode(void)
        flags = fcntl(m_sock_fd, F_GETFL);
 
        if (flags == -1) {
-               _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d, errno : %d , errstr : %s", get_client_name(), m_sock_fd, errno, strerror(errno));
+               _E("fcntl(F_GETFL) failed for %s, m_sock_fd: %d", get_client_name(), m_sock_fd);
+               _ERRNO(errno);
                return false;
        }
 
@@ -456,7 +472,8 @@ bool csocket::close(void)
 {
        if (m_sock_fd >= 0) {
                if (::close(m_sock_fd) < 0) {
-                       _E("Socket(%d) close failed, errno : %d , errstr : %s", m_sock_fd, errno, strerror(errno));
+                       _E("Socket(%d) close failed", m_sock_fd);
+                       _ERRNO(errno);
                        return false;
                }
                m_sock_fd = -1;

diff --git a/src/shared/poller.cpp b/src/shared/poller.cpp
index 6676632..ae01c8b 100644 (file)
--- a/src/shared/poller.cpp
+++ b/src/shared/poller.cpp
@@ -55,7 +55,7 @@ bool poller::add_fd(int fd)
        event.events = EPOLLIN | EPOLLERR | EPOLLHUP;
 
        if (epoll_ctl(m_epfd, EPOLL_CTL_ADD, fd, &event)) {
-               _E("errno : %d , errstr : %s", errno, strerror(errno));
+               _ERRNO(errno);
                return false;
        }
 
@@ -73,7 +73,7 @@ bool poller::fill_event_queue(void)
                if (errno == EINTR)
                        return true;
 
-               _E("Epoll failed errrno : %d , errstr : %s", errno, strerror(errno));
+               _ERRNO(errno);
                return false;
        }
 

diff --git a/src/shared/sensor_log.h b/src/shared/sensor_log.h
index be30df0..d4d7a06 100644 (file)
--- a/src/shared/sensor_log.h
+++ b/src/shared/sensor_log.h
@@ -49,6 +49,16 @@
 #define _I INFO
 #define _D DBG
 
+#define _ERRNO(errno) do { \
+               char buf[1024]; \
+               char *error = strerror_r(errno, buf, 1024); \
+               if (!error) { \
+                       _E("Failed to strerror_r()"); \
+                       break; \
+               } \
+               _E("%s : [errno: %d]", error, errno); \
+       } while (0)
+
 #if defined(_DEBUG)
 #  define warn_if(expr, fmt, arg...) do { \
                if(expr) { \