Merge "Alarm Conditional AppLaunch Refactoring" into tizen_2.2

[platform/framework/native/appfw.git] / src / io / FIo_IpcClient.cpp

diff --git a/src/io/FIo_IpcClient.cpp b/src/io/FIo_IpcClient.cpp
index 62449ed..ef638b2 100644 (file)
--- a/src/io/FIo_IpcClient.cpp
+++ b/src/io/FIo_IpcClient.cpp
@@ -1,5 +1,4 @@
 //
-// Open Service Platform
 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
 //
 // Licensed under the Apache License, Version 2.0 (the License);
@@ -57,6 +56,7 @@ namespace Tizen { namespace Io
 
 _IpcClient::_IpcClient(void)
        : __pReverseSource(null)
+       , __fdCount(0)
        , __pFdLock(null)
        , __pListener(null)
 {
@@ -134,6 +134,7 @@ struct HelloMessage
 {
        int pid;
        bool reverse;
+       char appId[256];
 };
 
 result
@@ -145,14 +146,22 @@ _IpcClient::MakeConnection(bool forReverse)
        socklen_t serverLen = 0;
        int client = -1;
        int ret = 0;
-       HelloMessage helloMessage = {0, false};
+       int retry = 0;
+       HelloMessage helloMessage = {0, 0};
        std::string socketName;
        char* pSocketName = null;
        size_t socketNameLength = 0;
        int flags = 0;
 
        helloMessage.pid = getpid();
-       helloMessage.reverse = forReverse;
+       if (forReverse)
+       {
+               helloMessage.reverse = 1;
+       }
+       else
+       {
+               helloMessage.reverse = 0;
+       }
 
        pSocketName = _StringConverter::CopyToCharArrayN(__name);
        SysTryReturnResult(NID_IO, pSocketName != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
@@ -165,6 +174,21 @@ _IpcClient::MakeConnection(bool forReverse)
        socketNameLength = socketName.size() + 1;
        SysTryReturnResult(NID_IO, socketNameLength < 108, E_INVALID_ARG, "Server name is too long.");
 
+       if (__fdCount == 0)
+       {
+               // Set an appId
+               String appId = _AppInfo::GetApplicationId();
+               int length = (appId.GetLength() + 1) * sizeof(wchar_t);
+               if (length > 255)
+               {
+                       length = 255;
+               }
+
+               SysTryReturnResult(NID_IO, appId.GetLength() > 0, E_SYSTEM, "AppId dose not exist.");
+
+               memcpy(helloMessage.appId, appId.GetPointer(), length);
+       }
+
        client = socket(AF_UNIX, SOCK_STREAM, 0);
        SysTryCatch(NID_IO, client != -1, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create a socket : %s.", strerror(errno));
 
@@ -178,8 +202,26 @@ _IpcClient::MakeConnection(bool forReverse)
        strncpy(server.sun_path, socketName.c_str(), socketNameLength);
        serverLen = sizeof(server);
 
-       ret = connect(client, (struct sockaddr*) &server, serverLen);
-       if (ret != 0)
+       // Retry if the server is not ready
+       retry = 5;
+       while (retry > 0)
+       {
+               ret = connect(client, (struct sockaddr*) &server, serverLen);
+               if (ret < 0 && errno == ENOENT)
+               {
+                       SysLog(NID_IO, "The server is not ready. %d", retry);
+
+                       usleep(1000 * 1000);
+
+                       --retry;
+               }
+               else
+               {
+                       break;
+               }
+       }
+
+       if (ret < 0)
        {
                SysTryCatch(NID_IO, errno == EINPROGRESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to connect to server(%s) : %s",
                                   socketName.c_str(), strerror(errno));
@@ -260,6 +302,8 @@ _IpcClient::MakeConnection(bool forReverse)
        }
        else
        {
+               ++__fdCount;
+
                ReleaseFd(client);
        }
 
@@ -447,6 +491,25 @@ _IpcClient::SendAsync(IPC::Message* pMessage)
        while (remain > 0)
        {
                written = write(fd, (char*) pData, remain);
+               if (written < 0)
+               {
+                       ReleaseFd(fd);
+
+                       if (errno == EAGAIN)
+                       {
+                               SysLogException(NID_IO, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] The socket buffer is full.");
+                               return E_RESOURCE_UNAVAILABLE;
+                       }
+                       else if (errno == EPIPE)
+                       {
+                               SysLogException(NID_IO, E_INVALID_CONNECTION, "[E_INVALID_CONNECTION] The socket connection is closed.");
+                               return E_INVALID_CONNECTION;
+                       }
+
+                       SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to send a request: %d, %s", errno, strerror(errno));
+                       return E_SYSTEM;
+               }
+
                remain -= written;
                pData += written;
        }
@@ -473,8 +536,6 @@ _IpcClient::SendSync(IPC::Message* pMessage)
 
        std::string message;
 
-       struct pollfd pfd;
-
        IPC::Message* pReply = null;
        MessageReplyDeserializer* pReplyDeserializer = null;
        IPC::SyncMessage* pSyncMessage = dynamic_cast <IPC::SyncMessage*>(pMessage);
@@ -491,21 +552,59 @@ _IpcClient::SendSync(IPC::Message* pMessage)
        while (remain > 0)
        {
                written = write(fd, (char*) pData, remain);
+               if (written < 0)
+               {
+                       ReleaseFd(fd);
+
+                       if (errno == EAGAIN)
+                       {
+                               SysLogException(NID_IO, E_RESOURCE_UNAVAILABLE, "[E_RESOURCE_UNAVAILABLE] The socket buffer is full.");
+                               return E_RESOURCE_UNAVAILABLE;
+                       }
+                       else if (errno == EPIPE)
+                       {
+                               SysLogException(NID_IO, E_INVALID_CONNECTION, "[E_INVALID_CONNECTION] The socket connection is closed.");
+                               return E_INVALID_CONNECTION;
+                       }
+
+                       SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to send a request: %d, %s", errno, strerror(errno));
+                       return E_SYSTEM;
+               }
+
                remain -= written;
                pData += written;
        }
 
        // Wait reply
+       struct pollfd pfd;
+
        pfd.fd = fd;
        pfd.events = POLLIN | POLLRDHUP;
        pfd.revents = 0;
 
+       int ret = 0;
+
        while (true)
        {
-               poll(&pfd, 1, -1);
+               ret = poll(&pfd, 1, -1);
+               if (ret < 0)
+               {
+                       if (errno == EINTR)
+                       {
+                               continue;
+                       }
+
+                       SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to poll (%d, %s).", errno, strerror(errno));
+
+                       ReleaseFd(fd);
+                       return E_SYSTEM;
+               }
 
                if (pfd.revents & POLLRDHUP)
                {
+                       SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] POLLRDHUP");
+
+                       ReleaseFd(fd);
                        return E_SYSTEM;
                }
 
@@ -514,13 +613,23 @@ _IpcClient::SendSync(IPC::Message* pMessage)
                        readSize = read(fd, buffer, 1024);
                }
 
-               message.append(buffer, readSize);
+               if (readSize > 0)
+               {
+                       message.append(buffer, readSize);
+               }
 
                pEndOfMessage = (char*) IPC::Message::FindNext(message.data(), message.data() + message.size());
                if (pEndOfMessage)
                {
                        pReply = new (std::nothrow) IPC::Message(message.data(), pEndOfMessage - message.data());
-                       SysTryReturnResult(NID_IO, pReply != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
+                       if (pReply == null)
+                       {
+                               SysLogException(NID_IO, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
+
+                               ReleaseFd(fd);
+                               return E_OUT_OF_MEMORY;
+                       }
+
                        break;
                }
        }