src/io/FIo_MessagePortProxy.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file        FIo_MessagePortProxy.cpp
  19  * @brief       This is the implementation file for the _MessagePortProxy class.
  20  *
  21  */
  22
  23 #include <string.h>
  24 #include <typeinfo>
  25 #include <unique_ptr.h>
  26
  27 #include <message-port.h>
  28
  29 #include <FBaseSysLog.h>
  30 #include <FBase_StringConverter.h>
  31 #include <FApp_AppInfo.h>
  32
  33 #include "FIo_MessagePortProxy.h"
  34
  35 using namespace std;
  36
  37 using namespace Tizen::App;
  38 using namespace Tizen::Io;
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Base::Collection;
  41 using namespace Tizen::Base::Runtime;
  42
  43 namespace Tizen { namespace Io
  44 {
  45
  46 static const int MAX_MESSAGE_SIZE = 16 * 1024;
  47
  48 static void
  49 ConvertBundleToMap(const char *pKey, const int type, const bundle_keyval_t *pVal, void *pData)
  50 {
  51         //SysLog(NID_IO, "CB key = %s", pKey);
  52
  53         HashMap* pMap = static_cast<HashMap*>(pData);
  54
  55         if (pKey && pVal && pMap)
  56         {
  57                 size_t size = 0;
  58                 char* pStr = NULL;
  59                 switch (type)
  60                 {
  61                         case BUNDLE_TYPE_STR:
  62                                 bundle_keyval_get_basic_val(const_cast<bundle_keyval_t*>(pVal), reinterpret_cast<void**>(&pStr), &size);
  63                                 if (pStr)
  64                                 {
  65                                         pMap->Add(new (std::nothrow) String(pKey), new (std::nothrow) String(pStr));
  66                                 }
  67
  68                                 break;
  69                         case BUNDLE_TYPE_BYTE:
  70                                 bundle_keyval_get_basic_val(const_cast<bundle_keyval_t*>(pVal), reinterpret_cast<void**>(&pStr), &size);
  71
  72                                 //SysLog(NID_IO, "Bundle byte value = %s, size = %d", pStr, size);
  73
  74                                 if (pStr)
  75                                 {
  76                                         ByteBuffer* pBuffer = new (std::nothrow) ByteBuffer();
  77                                         SysTryReturnVoidResult(NID_IO, pMap != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
  78                                         result r = pBuffer->Construct(size);
  79                                         SysTryCatch(NID_IO, r == E_SUCCESS, delete pBuffer, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
  80
  81                                         r = pBuffer->SetArray((const byte*)pStr, 0, size);
  82                                         SysTryCatch(NID_IO, r == E_SUCCESS, delete pBuffer, E_INVALID_ARG, "[E_INVALID_ARG] The buffer argument is invalid.");
  83
  84                                         pBuffer->Flip();
  85
  86                                         pMap->Add(new (std::nothrow) String(pKey), pBuffer);
  87                                 }
  88
  89                                 break;
  90                         default:
  91                                 SysLog(NID_APP, "Invalid type for %s : %d", pKey, type);
  92                                 break;
  93                 }
  94         }
  95
  96 CATCH:
  97         return;
  98 }
  99
 100 static void
 101 OnMessageReceived(int id, const char* remote_app_id, const char* remote_port, bool trusted_port, bundle* data)
 102 {
 103         SysLog(NID_IO, "Message received");
 104
 105         _MessagePortProxy* p = _MessagePortProxy::GetProxy();
 106
 107         int ret = 0;
 108         char* pLocalPort = null;
 109
 110         ret = messageport_get_local_port_name(id, &pLocalPort);
 111         if (pLocalPort == null)
 112         {
 113                 SysSecureLog(NID_IO, "No local port for id: %d", id);
 114
 115                 bundle_free(data);
 116                 return;
 117         }
 118
 119         //SysLog(NID_IO, "local port name: %s", pLocalPort);
 120
 121         _IMessagePortListener* pListener = null;
 122         p->__listeners.GetValue(pLocalPort, pListener);
 123
 124         free(pLocalPort);
 125
 126         if (pListener != null)
 127         {
 128                 HashMap* pMap = new (std::nothrow) HashMap(SingleObjectDeleter);
 129                 SysTryCatch(NID_IO, pMap != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 130
 131                 result r = pMap->Construct();
 132                 SysTryCatch(NID_IO, r == E_SUCCESS, delete pMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 133
 134                 bundle_foreach(data, ConvertBundleToMap, pMap);
 135
 136                 if (remote_app_id == null) // Uni-directional
 137                 {
 138                         pListener->OnMessageReceivedN(pMap);
 139                 }
 140                 else // Bi-directional
 141                 {
 142                         SysSecureLog(NID_IO, "Message received from [%s:%s], trusted: %d", remote_app_id, remote_port, trusted_port);
 143
 144                         pListener->OnMessageReceivedN(remote_app_id, remote_port, trusted_port, pMap);
 145                 }
 146         }
 147
 148 CATCH:
 149         bundle_free(data);
 150 }
 151
 152 static void
 153 OnTrustedMessageReceived(int id, const char* remote_app_id, const char* remote_port, bool trusted_port, bundle* data)
 154 {
 155         SysLog(NID_IO, "Trusted message received");
 156
 157         _MessagePortProxy* p = _MessagePortProxy::GetProxy();
 158
 159         int ret = 0;
 160         char* pLocalPort = null;
 161         ret = messageport_get_local_port_name(id, &pLocalPort);
 162         if (pLocalPort == null)
 163         {
 164                 SysSecureLog(NID_IO, "No local port for id: %d", id);
 165
 166                 bundle_free(data);
 167                 return;
 168         }
 169
 170         _IMessagePortListener* pListener = null;
 171         p->__trustedListeners.GetValue(pLocalPort, pListener);
 172
 173         free(pLocalPort);
 174
 175         if (pListener != null)
 176         {
 177                 HashMap* pMap = new (std::nothrow) HashMap(SingleObjectDeleter);
 178                 SysTryCatch(NID_IO, pMap != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 179
 180                 result r = pMap->Construct();
 181                 SysTryCatch(NID_IO, r == E_SUCCESS, delete pMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 182
 183                 bundle_foreach(data, ConvertBundleToMap, pMap);
 184
 185                 if (remote_app_id == null) // Uni-directional
 186                 {
 187                         pListener->OnMessageReceivedN(pMap);
 188                 }
 189                 else // Bi-directional
 190                 {
 191                         SysSecureLog(NID_IO, "Trusted message received from [%s:%s], trusted: %d", remote_app_id, remote_port, trusted_port);
 192
 193                         pListener->OnMessageReceivedN(remote_app_id, remote_port, trusted_port, pMap);
 194                 }
 195         }
 196
 197 CATCH:
 198         bundle_free(data);
 199 }
 200
 201 _MessagePortProxy::_MessagePortProxy(void)
 202 {
 203 }
 204
 205 _MessagePortProxy::~_MessagePortProxy(void)
 206 {
 207 }
 208
 209 result
 210 _MessagePortProxy::Construct(void)
 211 {
 212         static _StringHashProvider hashProvider;
 213         static _StringComparer stringComparer;
 214
 215         __listeners.Construct(0, 0, hashProvider, stringComparer);
 216         __trustedListeners.Construct(0, 0, hashProvider, stringComparer);
 217         __ids.Construct(0, 0, hashProvider, stringComparer);
 218         __trustedIds.Construct(0, 0, hashProvider, stringComparer);
 219
 220         __appId = _AppInfo::GetApplicationId();
 221
 222         return E_SUCCESS;
 223 }
 224
 225
 226 result
 227 _MessagePortProxy::RegisterMessagePort(const String& localPort, bool isTrusted,
 228                                                                         const _IMessagePortListener& listener)
 229 {
 230         SysSecureLog(NID_IO, "Register a message port : [%ls:%ls]", __appId.GetPointer(), localPort.GetPointer());
 231
 232         int ret = 0;
 233         bool contain = false;
 234
 235         unique_ptr<char[]> pLocal(_StringConverter::CopyToCharArrayN(localPort));
 236
 237         if (!isTrusted)
 238         {
 239                 ret = messageport_register_local_port(pLocal.get(), OnMessageReceived);
 240                 SysTryReturnResult(NID_IO, ret >= 0, E_SYSTEM, "Failed to register the local message port. %d", ret);
 241
 242                 __listeners.ContainsKey(localPort, contain);
 243
 244                 if (!contain)
 245                 {
 246                         __listeners.Add(localPort, const_cast<_IMessagePortListener*>(&listener));
 247                         __ids.Add(localPort, ret);
 248                 }
 249                 else
 250                 {
 251                         __listeners.SetValue(localPort, const_cast<_IMessagePortListener*>(&listener));
 252                         __ids.SetValue(localPort, ret);
 253                 }
 254
 255         }
 256         else
 257         {
 258                 ret = messageport_register_trusted_local_port(pLocal.get(), OnTrustedMessageReceived);
 259                 SysTryReturnResult(NID_IO, ret >= 0, E_SYSTEM, "Failed to register the trusted local message port. %d", ret);
 260
 261                 __trustedListeners.ContainsKey(localPort, contain);
 262
 263                 if (!contain)
 264                 {
 265                         __trustedListeners.Add(localPort, const_cast<_IMessagePortListener*>(&listener));
 266                         __trustedIds.Add(localPort, ret);
 267                 }
 268                 else
 269                 {
 270                         __trustedListeners.SetValue(localPort, const_cast<_IMessagePortListener*>(&listener));
 271                         __trustedIds.SetValue(localPort, ret);
 272                 }
 273
 274         }
 275
 276         return E_SUCCESS;
 277 }
 278
 279 result
 280 _MessagePortProxy::RequestRemotePort(const AppId& remoteAppId,
 281                                                                         const String& remotePort,
 282                                                                         bool isTrusted)
 283 {
 284         SysSecureLog(NID_IO, "Request a remote message port [%ls:%ls]", remoteAppId.GetPointer(), remotePort.GetPointer());
 285
 286         result r = E_SUCCESS;
 287         int ret = 0;
 288         bool exist = false;
 289
 290         unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(remoteAppId));
 291         unique_ptr<char[]> pPort(_StringConverter::CopyToCharArrayN(remotePort));
 292
 293         if (!isTrusted)
 294         {
 295                 ret = messageport_check_remote_port(pAppId.get(), pPort.get(), &exist);
 296         }
 297         else
 298         {
 299                 ret = messageport_check_trusted_remote_port(pAppId.get(), pPort.get(), &exist);
 300         }
 301
 302         if (ret < 0)
 303         {
 304                 r = ConvertToResult(ret);
 305
 306                 SysTryReturnResult(NID_IO, r != E_CERTIFICATE_VERIFICATION_FAILED, E_CERTIFICATE_VERIFICATION_FAILED, "The target application is not signed with the same certificate.");
 307
 308                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to request the remote message port.");
 309
 310                 return r;
 311         }
 312
 313         SysTryReturnResult(NID_IO, exist, E_OBJ_NOT_FOUND, "The remote message port is not found.");
 314
 315         return E_SUCCESS;
 316 }
 317
 318 result
 319 _MessagePortProxy::SendMessage(const AppId& remoteAppId, const String& remotePort, bool isTrusted, const HashMap* pMap)
 320 {
 321         SysSecureLog(NID_IO, "Send a unidirectional message to remote port [%ls:%ls]", remoteAppId.GetPointer(), remotePort.GetPointer());
 322
 323         int ret = 0;
 324         int size = 0;
 325
 326         // Convert Map to bundle
 327         bundle* b = ConvertMapToBundleN(pMap, &size);
 328         SysTryReturnResult(NID_IO, b != null, E_INVALID_ARG, "The argument is invalid.");
 329         //SysTryReturnResult(NID_IO, size <= MAX_MESSAGE_SIZE, E_MAX_EXCEEDED, "The size of the message has exceeded the maximum limit.");
 330
 331         unique_ptr<char[]> pRemoteAppId(_StringConverter::CopyToCharArrayN(remoteAppId));
 332         unique_ptr<char[]> pRemotePort(_StringConverter::CopyToCharArrayN(remotePort));
 333
 334         if (!isTrusted)
 335         {
 336                 ret = messageport_send_message(pRemoteAppId.get(), pRemotePort.get(), b);
 337         }
 338         else
 339         {
 340                 ret = messageport_send_trusted_message(pRemoteAppId.get(), pRemotePort.get(), b);
 341         }
 342
 343         bundle_free(b);
 344
 345         if (ret < 0)
 346         {
 347                 result r = ConvertToResult(ret);
 348
 349                 SysTryReturnResult(NID_IO, r != E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "The remote message port is not found.");
 350                 SysTryReturnResult(NID_IO, r != E_CERTIFICATE_VERIFICATION_FAILED, E_CERTIFICATE_VERIFICATION_FAILED, "The target application is not signed with the same certificate.");
 351                 SysTryReturnResult(NID_IO, r != E_MAX_EXCEEDED, E_MAX_EXCEEDED, "The size of the message has exceeded the maximum limit.");
 352
 353                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to request the remote message port.");
 354
 355                 return r;
 356         }
 357
 358         return E_SUCCESS;
 359 }
 360
 361 result
 362 _MessagePortProxy::SendMessage(const String& localPort, bool isTrustedLocal, const AppId& remoteAppId, const String& remotePort, bool isTrustedRemote, const HashMap* pMap)
 363 {
 364         SysSecureLog(NID_IO, "Send a bidirectional message from [%ls:%ls] to [%ls:%ls]", __appId.GetPointer(), localPort.GetPointer(), remoteAppId.GetPointer(), remotePort.GetPointer());
 365
 366         result r = E_SUCCESS;
 367         int id = 0;
 368
 369         if (!isTrustedLocal)
 370         {
 371                 r = __ids.GetValue(localPort, id);
 372         }
 373         else
 374         {
 375                 r = __trustedIds.GetValue(localPort, id);
 376         }
 377
 378         SysTryReturnResult(NID_IO, r == E_SUCCESS, E_SYSTEM, "Internal system errors.");
 379
 380         int size = 0;
 381
 382         // Convert Map to bundle
 383         bundle* b = ConvertMapToBundleN(pMap, &size);
 384         SysTryReturnResult(NID_IO, b != null, E_INVALID_ARG, "The argument is invalid.");
 385         //SysTryReturnResult(NID_IO, size <= MAX_MESSAGE_SIZE, E_MAX_EXCEEDED, "The size of the message has exceeded the maximum limit.");
 386
 387         unique_ptr<char[]> pRemoteAppId(_StringConverter::CopyToCharArrayN(remoteAppId));
 388         unique_ptr<char[]> pRemotePort(_StringConverter::CopyToCharArrayN(remotePort));
 389
 390         int ret = 0;
 391         if (!isTrustedRemote)
 392         {
 393                 ret = messageport_send_bidirectional_message(id, pRemoteAppId.get(), pRemotePort.get(), b);
 394         }
 395         else
 396         {
 397                 ret = messageport_send_bidirectional_trusted_message(id, pRemoteAppId.get(), pRemotePort.get(), b);
 398         }
 399
 400         bundle_free(b);
 401
 402         if (ret < 0)
 403         {
 404                 result r = ConvertToResult(ret);
 405
 406                 SysTryReturnResult(NID_IO, r != E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "The remote message port is not found.");
 407                 SysTryReturnResult(NID_IO, r != E_CERTIFICATE_VERIFICATION_FAILED, E_CERTIFICATE_VERIFICATION_FAILED, "The target application is not signed with the same certificate.");
 408                 SysTryReturnResult(NID_IO, r != E_MAX_EXCEEDED, E_MAX_EXCEEDED, "The size of the message has exceeded the maximum limit.");
 409
 410                 SysLogException(NID_IO, E_SYSTEM, "[E_SYSTEM] Failed to request the remote message port.");
 411
 412                 return r;
 413         }
 414
 415         return E_SUCCESS;
 416 }
 417
 418 _MessagePortProxy*
 419 _MessagePortProxy::GetProxy(void)
 420 {
 421         static _MessagePortProxy* pProxy = null;
 422
 423         if (pProxy == null)
 424         {
 425                 unique_ptr<_MessagePortProxy> p(new (std::nothrow) _MessagePortProxy);
 426                 SysTryReturn(NID_IO, p != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 427
 428                 result r = p->Construct();
 429                 SysTryReturn(NID_IO, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] Failed to initialize a  message port proxy.");
 430
 431                 pProxy = p.release();
 432         }
 433
 434         SetLastResult(E_SUCCESS);
 435         return pProxy;
 436 }
 437
 438 result
 439 _MessagePortProxy::ConvertToResult(int error)
 440 {
 441         SysLog(NID_IO, "Native error = %d", error);
 442
 443         switch (error)
 444         {
 445                 case MESSAGEPORT_ERROR_IO_ERROR:
 446                         return E_SYSTEM;
 447
 448                 case MESSAGEPORT_ERROR_OUT_OF_MEMORY:
 449                         return E_OUT_OF_MEMORY;
 450
 451                 case MESSAGEPORT_ERROR_INVALID_PARAMETER:
 452                         return E_INVALID_ARG;
 453
 454                 case MESSAGEPORT_ERROR_MESSAGEPORT_NOT_FOUND:
 455                         return E_OBJ_NOT_FOUND;
 456
 457                 case MESSAGEPORT_ERROR_CERTIFICATE_NOT_MATCH:
 458                         return E_CERTIFICATE_VERIFICATION_FAILED;
 459
 460                 case MESSAGEPORT_ERROR_MAX_EXCEEDED:
 461                         return E_MAX_EXCEEDED;
 462
 463                 default:
 464                         return E_SYSTEM;
 465         }
 466
 467         return E_SYSTEM;
 468 }
 469
 470 bundle*
 471 _MessagePortProxy::ConvertMapToBundleN(const HashMap* pMap, int* pSize)
 472 {
 473         bundle *b = bundle_create();
 474         int size = 0;
 475
 476         std::unique_ptr<IMapEnumerator> pEnum (pMap->GetMapEnumeratorN());
 477         while(pEnum->MoveNext() == E_SUCCESS)
 478         {
 479                 const String* pKey = dynamic_cast<const String*>(pEnum->GetKey());
 480                 const Object* pValue = pEnum->GetValue();
 481
 482                 if (pKey && pValue)
 483                 {
 484                         unique_ptr<char[]> pKeyData(_StringConverter::CopyToCharArrayN(*pKey));
 485
 486                         if (typeid(*pValue) == typeid(const String)) // String
 487                         {
 488                                 const String* pStr = static_cast<const String*>(pValue);
 489                                 size += pStr->GetLength() * sizeof(wchar_t);
 490
 491                                 unique_ptr<char[]> pValueData(_StringConverter::CopyToCharArrayN(*pStr));
 492
 493                                 //SysLog(NID_IO, "key: %s, value: %s", pKeyData.get(), pValueData.get());
 494
 495                                 bundle_add(b, pKeyData.get(), pValueData.get());
 496                         }
 497                         else // ByteBuffer
 498                         {
 499                                 if (typeid(*pValue) == typeid(const ByteBuffer)) // ByteBuffer
 500                                 {
 501                                         const ByteBuffer* pBuffer = static_cast<const ByteBuffer*>(pValue);
 502                                         size += pBuffer->GetLimit();
 503
 504                                         //SysLog(NID_IO, "Add a string key: %s, byte value: %s", pKeyData.get(), pBuffer->GetPointer());
 505
 506                                         bundle_add_byte(b, pKeyData.get(), pBuffer->GetPointer(), pBuffer->GetLimit());
 507                                 }
 508                                 else
 509                                 {
 510                                         SysLog(NID_IO, "The value type is not supported.");
 511
 512                                         bundle_free(b);
 513                                         return null;
 514                                 }
 515                         }
 516                 }
 517                 else
 518                 {
 519                         SysLog(NID_IO, "The key type is not supported.");
 520
 521                         bundle_free(b);
 522                         return null;
 523                 }
 524         }
 525
 526         *pSize = size;
 527         return b;
 528 }
 529
 530 }}