src/server/service/open-for.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Bumjin Im <bj.im@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        open-for.cpp
  20  * @author      Zbigniew Jasinski (z.jasinski@samsung.com)
  21  * @version     1.0
  22  * @brief       Implementation of open-for service
  23  */
  24
  25 #include <dpl/log/log.h>
  26 #include <dpl/serialization.h>
  27
  28 #include <protocols.h>
  29 #include <open-for.h>
  30 #include <unistd.h>
  31 #include <algorithm>
  32
  33 #include <security-server.h>
  34 #include <security-server-util.h>
  35
  36 namespace {
  37 // Service may open more than one socket.
  38 // These ID's will be assigned to sockets
  39 // and will be used only by service.
  40 // When new connection arrives, AcceptEvent
  41 // will be generated with proper ID to inform
  42 // service about input socket.
  43 //
  44 // Please note: SocketManaged does not use it and
  45 // does not check it in any way.
  46 //
  47 // If your service require only one socket
  48 // (uses only one socket labeled with smack)
  49 // you may ignore this ID (just pass 0)
  50 const int SERVICE_SOCKET_ID = 0;
  51
  52 } // namespace anonymous
  53
  54 namespace SecurityServer {
  55
  56 OpenForService::OpenForConnInfo::~OpenForConnInfo() {
  57     std::for_each(descriptorsVector.begin(),descriptorsVector.end(), ::close);
  58 }
  59
  60 GenericSocketService::ServiceDescriptionVector OpenForService::GetServiceDescription() {
  61     return ServiceDescriptionVector
  62         {{SERVICE_SOCKET_OPEN_FOR, "security-server::api-open-for", SERVICE_SOCKET_ID, true}};
  63 }
  64
  65 void OpenForService::accept(const AcceptEvent &event)
  66 {
  67     LogDebug("Accept event. ConnectionID.sock: " << event.connectionID.sock
  68         << " ConnectionID.counter: " << event.connectionID.counter
  69         << " ServiceID: " << event.interfaceID);
  70 }
  71
  72 void OpenForService::write(const WriteEvent &event)
  73 {
  74     LogDebug("WriteEvent. ConnectionID: " << event.connectionID.sock <<
  75         " Size: " << event.size << " Left: " << event.left);
  76     if (event.left == 0)
  77         m_serviceManager->Close(event.connectionID);
  78 }
  79
  80 void OpenForService::process(const ReadEvent &event)
  81 {
  82     LogDebug("Read event for counter: " << event.connectionID.counter);
  83     auto &info = m_connectionInfoMap[event.connectionID.counter];
  84     info.buffer.Push(event.rawBuffer);
  85
  86     // We can get several requests in one package.
  87     // Extract and process them all
  88     while(processOne(event.connectionID, info.buffer, info.descriptorsVector));
  89 }
  90
  91 void OpenForService::close(const CloseEvent &event)
  92 {
  93     LogDebug("CloseEvent. ConnectionID: " << event.connectionID.sock);
  94     auto &descVector = m_connectionInfoMap[event.connectionID.counter].descriptorsVector;
  95
  96     for (auto iter = descVector.begin(); iter != descVector.end(); ++iter)
  97         TEMP_FAILURE_RETRY(::close(*iter));
  98
  99     m_connectionInfoMap.erase(event.connectionID.counter);
 100 }
 101
 102 bool OpenForService::processOne(const ConnectionID &conn, MessageBuffer &buffer, std::vector<int> &descVector)
 103 {
 104     LogDebug("Iteration begin");
 105
 106     std::string filename;
 107     std::string client_label;
 108     OpenForHdrs msgType;
 109     MessageBuffer sendBuffer;
 110
 111     int retCode = SECURITY_SERVER_API_ERROR_SERVER_ERROR;
 112     int fd = -1;
 113
 114     if (!buffer.Ready())
 115         return false;
 116
 117     Try {
 118         int msgTypeInt;
 119         Deserialization::Deserialize(buffer, msgTypeInt);  //receive MSG_ID
 120         msgType = static_cast<OpenForHdrs>(msgTypeInt);
 121         Deserialization::Deserialize(buffer, filename);
 122     } Catch (MessageBuffer::Exception::Base) {
 123         LogError("Broken protocol. Closing socket.");
 124         m_serviceManager->Close(conn);
 125         return false;
 126     }
 127
 128     switch(msgType) {
 129     case OpenForHdrs::OPEN:
 130         LogDebug("Entering open-for OPEN server handler.");
 131         Deserialization::Deserialize(buffer, client_label);
 132         retCode = m_sharedFile.openSharedFile(filename, client_label, conn.sock, fd);
 133         break;
 134     case OpenForHdrs::REOPEN:
 135         LogDebug("Entering open-for REOPEN server handler.");
 136         retCode = m_sharedFile.reopenSharedFile(filename, conn.sock, fd);
 137         break;
 138     case OpenForHdrs::DELETE:
 139         LogDebug("Entering open-for DELETE server handler.");
 140         retCode = m_sharedFile.deleteSharedFile(filename, conn.sock);
 141         break;
 142     case OpenForHdrs::OPEN_DEPRECATED:
 143         LogDebug("Entering open-for OPEN-DEPRECATED server handler.");
 144         retCode = m_sharedFile.getFD(filename, conn.sock, fd);
 145         break;
 146     default:
 147         LogError("Error, unknown function called by client,");
 148         break;
 149     };
 150
 151     if (fd != -1)
 152         descVector.push_back(fd);
 153     SendMsgData sendMsgData(retCode, fd);
 154
 155     m_serviceManager->Write(conn, sendMsgData);
 156
 157     return true;
 158 }
 159
 160 } // namespace SecurityServer