src/client/client-common.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Rafal Krypa <r.krypa@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18 /*
  19  * @file        client-common.cpp
  20  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  21  * @version     1.0
  22  * @brief       This file is implementation of client-common functions.
  23  */
  24
  25 #include <fcntl.h>
  26 #include <poll.h>
  27 #include <sys/types.h>
  28 #include <sys/socket.h>
  29 #include <sys/un.h>
  30 #include <sys/smack.h>
  31 #include <sys/xattr.h>
  32 #include <linux/xattr.h>
  33 #include <unistd.h>
  34
  35 #include <dpl/log/log.h>
  36 #include <dpl/serialization.h>
  37 #include <dpl/singleton.h>
  38 #include <dpl/singleton_safe_impl.h>
  39
  40 #include <message-buffer.h>
  41 #include <smack-common.h>
  42
  43 #include <protocols.h>
  44
  45 IMPLEMENT_SAFE_SINGLETON(SecurityManager::Log::LogSystem);
  46
  47 namespace {
  48
  49 const int POLL_TIMEOUT = 2000;
  50
  51 void securityClientEnableLogSystem(void) {
  52     SecurityManager::Singleton<SecurityManager::Log::LogSystem>::Instance().SetTag("SECURITY_MANAGER_CLIENT");
  53 }
  54
  55 int waitForSocket(int sock, int event, int timeout) {
  56     int retval;
  57     pollfd desc[1];
  58     desc[0].fd = sock;
  59     desc[0].events = event;
  60
  61     while((-1 == (retval = poll(desc, 1, timeout))) && (errno == EINTR)) {
  62         timeout >>= 1;
  63         errno = 0;
  64     }
  65
  66     if (0 == retval) {
  67         LogDebug("Poll timeout");
  68     } else if (-1 == retval) {
  69         int err = errno;
  70         LogError("Error in poll: " << strerror(err));
  71     }
  72     return retval;
  73 }
  74
  75 class SockRAII {
  76 public:
  77     SockRAII()
  78       : m_sock(-1)
  79     {}
  80
  81     virtual ~SockRAII() {
  82         if (m_sock > -1)
  83             close(m_sock);
  84     }
  85
  86     int Connect(char const * const interface) {
  87         sockaddr_un clientAddr;
  88         int flags;
  89
  90         if (m_sock != -1) // guard
  91             close(m_sock);
  92
  93         m_sock = socket(AF_UNIX, SOCK_STREAM, 0);
  94         if (m_sock < 0) {
  95             int err = errno;
  96             LogError("Error creating socket: " << strerror(err));
  97             return SECURITY_MANAGER_API_ERROR_SOCKET;
  98         }
  99
 100         if ((flags = fcntl(m_sock, F_GETFL, 0)) < 0 ||
 101             fcntl(m_sock, F_SETFL, flags | O_NONBLOCK) < 0)
 102         {
 103             int err = errno;
 104             LogError("Error in fcntl: " << strerror(err));
 105             return SECURITY_MANAGER_API_ERROR_SOCKET;
 106         }
 107
 108         memset(&clientAddr, 0, sizeof(clientAddr));
 109
 110         clientAddr.sun_family = AF_UNIX;
 111
 112         if (strlen(interface) >= sizeof(clientAddr.sun_path)) {
 113             LogError("Error: interface name " << interface << "is too long. Max len is:" << sizeof(clientAddr.sun_path));
 114             return SECURITY_MANAGER_API_ERROR_NO_SUCH_SERVICE;
 115         }
 116
 117         strcpy(clientAddr.sun_path, interface);
 118
 119         LogDebug("ClientAddr.sun_path = " << interface);
 120
 121         int retval = TEMP_FAILURE_RETRY(connect(m_sock, (struct sockaddr*)&clientAddr, SUN_LEN(&clientAddr)));
 122         if ((retval == -1) && (errno == EINPROGRESS)) {
 123             if (0 >= waitForSocket(m_sock, POLLOUT, POLL_TIMEOUT)) {
 124                 LogError("Error in waitForSocket.");
 125                 return SECURITY_MANAGER_API_ERROR_SOCKET;
 126             }
 127             int error = 0;
 128             socklen_t len = sizeof(error);
 129             retval = getsockopt(m_sock, SOL_SOCKET, SO_ERROR, &error, &len);
 130
 131             if (-1 == retval) {
 132                 int err = errno;
 133                 LogError("Error in getsockopt: " << strerror(err));
 134                 return SECURITY_MANAGER_API_ERROR_SOCKET;
 135             }
 136
 137             if (error == EACCES) {
 138                 LogError("Access denied");
 139                 return SECURITY_MANAGER_API_ERROR_ACCESS_DENIED;
 140             }
 141
 142             if (error != 0) {
 143                 LogError("Error in connect: " << strerror(error));
 144                 return SECURITY_MANAGER_API_ERROR_SOCKET;
 145             }
 146
 147             return SECURITY_MANAGER_API_SUCCESS;
 148         }
 149
 150         if (-1 == retval) {
 151             int err = errno;
 152             LogError("Error connecting socket: " << strerror(err));
 153             if (err == EACCES)
 154                 return SECURITY_MANAGER_API_ERROR_ACCESS_DENIED;
 155             if (err == ENOTSOCK)
 156                 return SECURITY_MANAGER_API_ERROR_NO_SUCH_SERVICE;
 157             return SECURITY_MANAGER_API_ERROR_SOCKET;
 158         }
 159
 160         return SECURITY_MANAGER_API_SUCCESS;
 161     }
 162
 163     int Get() {
 164         return m_sock;
 165     }
 166
 167 private:
 168     int m_sock;
 169 };
 170
 171 } // namespace anonymous
 172
 173 namespace SecurityManager {
 174
 175 int sendToServer(char const * const interface, const RawBuffer &send, MessageBuffer &recv) {
 176     int ret;
 177     SockRAII sock;
 178     ssize_t done = 0;
 179     char buffer[2048];
 180
 181     if (SECURITY_MANAGER_API_SUCCESS != (ret = sock.Connect(interface))) {
 182         LogError("Error in SockRAII");
 183         return ret;
 184     }
 185
 186     while ((send.size() - done) > 0) {
 187         if (0 >= waitForSocket(sock.Get(), POLLOUT, POLL_TIMEOUT)) {
 188             LogError("Error in poll(POLLOUT)");
 189             return SECURITY_MANAGER_API_ERROR_SOCKET;
 190         }
 191         ssize_t temp = TEMP_FAILURE_RETRY(write(sock.Get(), &send[done], send.size() - done));
 192         if (-1 == temp) {
 193             int err = errno;
 194             LogError("Error in write: " << strerror(err));
 195             return SECURITY_MANAGER_API_ERROR_SOCKET;
 196         }
 197         done += temp;
 198     }
 199
 200     do {
 201         if (0 >= waitForSocket(sock.Get(), POLLIN, POLL_TIMEOUT)) {
 202             LogError("Error in poll(POLLIN)");
 203             return SECURITY_MANAGER_API_ERROR_SOCKET;
 204         }
 205         ssize_t temp = TEMP_FAILURE_RETRY(read(sock.Get(), buffer, 2048));
 206         if (-1 == temp) {
 207             int err = errno;
 208             LogError("Error in read: " << strerror(err));
 209             return SECURITY_MANAGER_API_ERROR_SOCKET;
 210         }
 211
 212         if (0 == temp) {
 213             LogError("Read return 0/Connection closed by server(?)");
 214             return SECURITY_MANAGER_API_ERROR_SOCKET;
 215         }
 216
 217         RawBuffer raw(buffer, buffer+temp);
 218         recv.Push(raw);
 219     } while(!recv.Ready());
 220     return SECURITY_MANAGER_API_SUCCESS;
 221 }
 222
 223 int sendToServerAncData(char const * const interface, const RawBuffer &send, struct msghdr &hdr) {
 224     int ret;
 225     SockRAII sock;
 226     ssize_t done = 0;
 227
 228     if (SECURITY_MANAGER_API_SUCCESS != (ret = sock.Connect(interface))) {
 229         LogError("Error in SockRAII");
 230         return ret;
 231     }
 232
 233     while ((send.size() - done) > 0) {
 234         if (0 >= waitForSocket(sock.Get(), POLLOUT, POLL_TIMEOUT)) {
 235             LogError("Error in poll(POLLOUT)");
 236             return SECURITY_MANAGER_API_ERROR_SOCKET;
 237         }
 238         ssize_t temp = TEMP_FAILURE_RETRY(write(sock.Get(), &send[done], send.size() - done));
 239         if (-1 == temp) {
 240             int err = errno;
 241             LogError("Error in write: " << strerror(err));
 242             return SECURITY_MANAGER_API_ERROR_SOCKET;
 243         }
 244         done += temp;
 245     }
 246
 247     if (0 >= waitForSocket(sock.Get(), POLLIN, POLL_TIMEOUT)) {
 248         LogError("Error in poll(POLLIN)");
 249         return SECURITY_MANAGER_API_ERROR_SOCKET;
 250     }
 251
 252     ssize_t temp = TEMP_FAILURE_RETRY(recvmsg(sock.Get(), &hdr, MSG_CMSG_CLOEXEC));
 253
 254     if (temp < 0) {
 255         int err = errno;
 256         LogError("Error in recvmsg(): " << strerror(err) << " errno: " << err);
 257         return SECURITY_MANAGER_API_ERROR_SOCKET;
 258     }
 259
 260     if (0 == temp) {
 261         LogError("Read return 0/Connection closed by server(?)");
 262         return SECURITY_MANAGER_API_ERROR_SOCKET;
 263     }
 264
 265     return SECURITY_MANAGER_API_SUCCESS;
 266 }
 267
 268 int try_catch(const std::function<int()>& func)
 269 {
 270     try {
 271         return func();
 272     } catch (MessageBuffer::Exception::Base &e) {
 273         LogError("SecurityManager::MessageBuffer::Exception " << e.DumpToString());
 274     } catch (std::exception &e) {
 275         LogError("STD exception " << e.what());
 276     } catch (...) {
 277         LogError("Unknown exception occured");
 278     }
 279     return SECURITY_MANAGER_API_ERROR_UNKNOWN;
 280 }
 281
 282 } // namespace SecurityMANAGER
 283
 284 static void init_lib(void) __attribute__ ((constructor));
 285 static void init_lib(void)
 286 {
 287     securityClientEnableLogSystem();
 288 }
 289
 290 static void fini_lib(void) __attribute__ ((destructor));
 291 static void fini_lib(void)
 292 {
 293
 294 }
 295