Fix generated code build error for extension option

 - Some internal api symbols can be ambiguous.

Change-Id: I9dfa663c9eb70b566050590695a8fb5dfd950cdf
Signed-off-by: jusung son <jusung07.son@samsung.com>

diff --git a/idlc/gen/version2/c_body_generator_array_base_cb.hh b/idlc/gen/version2/c_body_generator_array_base_cb.hh
index 32eadeb84dd241bdd48ca35f4d2045bf69a49ed3..6cf8d5832981dd58e7c5d56b164949a5d6cc24af 100644 (file)
--- a/idlc/gen/version2/c_body_generator_array_base_cb.hh
+++ b/idlc/gen/version2/c_body_generator_array_base_cb.hh
@@ -51,7 +51,7 @@ static void __<PREFIX>_<NAME>_to(rpc_port_parcel_h parcel, void *data)
     rpc_port_parcel_write_string(parcel, handle->value[i]);
     </IS_STRING_TYPE?>
     <IS_FD_TYPE?>
-    rpc_port_parcel_write_fd(parcel, handle->value[i]);
+    dl_rpc_port_parcel_write_fd(parcel, handle->value[i]);
     </IS_FD_TYPE?>
     <IS_DEFAULT_TYPE?>
     rpc_port_parcel_burst_write(parcel, (const unsigned char *)(&handle->value[i]), sizeof(<ELEMENT_TYPE_SIZE>));
@@ -91,7 +91,7 @@ static void __<PREFIX>_<NAME>_from(rpc_port_parcel_h parcel, void *data)
     rpc_port_parcel_read_string(parcel, &handle->value[i]);
     </IS_STRING_TYPE?>
     <IS_FD_TYPE?>
-    rpc_port_parcel_read_fd(parcel, &handle->value[i]);
+    dl_rpc_port_parcel_read_fd(parcel, &handle->value[i]);
     </IS_FD_TYPE?>
     <IS_DEFAULT_TYPE?>
     rpc_port_parcel_burst_read(parcel, (unsigned char *)(&handle->value[i]), sizeof(<ELEMENT_TYPE_SIZE>));

diff --git a/idlc/gen/version2/c_body_generator_base_cb.hh b/idlc/gen/version2/c_body_generator_base_cb.hh
index 5d16a96b87008a1c3246b51f93c19f091d87d524..aa12bae68bf4c5e763ad6fe4c2a6c64ac7be2253 100644 (file)
--- a/idlc/gen/version2/c_body_generator_base_cb.hh
+++ b/idlc/gen/version2/c_body_generator_base_cb.hh
@@ -65,13 +65,13 @@ static void __rpc_port_unit_to(rpc_port_parcel_h parcel, void *user_data)
     return;
   }
 
-  ret = rpc_port_parcel_get_data_size(parcel, &size_pos);
+  ret = dl_rpc_port_parcel_get_data_size(parcel, &size_pos);
   if (ret != RPC_PORT_ERROR_NONE) {
     set_last_result(ret);
     return;
   }
 
-  ret = rpc_port_parcel_reserve(parcel, sizeof(unsigned int));
+  ret = dl_rpc_port_parcel_reserve(parcel, sizeof(unsigned int));
   if (ret != RPC_PORT_ERROR_NONE) {
     set_last_result(ret);
     return;
@@ -80,14 +80,14 @@ static void __rpc_port_unit_to(rpc_port_parcel_h parcel, void *user_data)
   if (unit->write_cb)
     unit->write_cb(parcel, unit);
 
-  ret = rpc_port_parcel_get_data_size(parcel, &cur_pos);
+  ret = dl_rpc_port_parcel_get_data_size(parcel, &cur_pos);
   if (ret != RPC_PORT_ERROR_NONE) {
     set_last_result(ret);
     return;
   }
 
   size = cur_pos - size_pos - sizeof(unsigned int);
-  ret = rpc_port_parcel_set_data_size(parcel, size_pos);
+  ret = dl_rpc_port_parcel_set_data_size(parcel, size_pos);
   if (ret != RPC_PORT_ERROR_NONE) {
     set_last_result(ret);
     return;
@@ -99,7 +99,7 @@ static void __rpc_port_unit_to(rpc_port_parcel_h parcel, void *user_data)
     return;
   }
 
-  ret = rpc_port_parcel_set_data_size(parcel, cur_pos);
+  ret = dl_rpc_port_parcel_set_data_size(parcel, cur_pos);
 
   set_last_result(ret);
 }
@@ -117,27 +117,27 @@ static void __rpc_port_unit_from(rpc_port_parcel_h parcel, void *user_data)
   rpc_port_parcel_read_array_count(parcel, &size);
   if (size == 0) return;
 
-  ret = rpc_port_parcel_get_reader(parcel, &start_pos);
+  ret = dl_rpc_port_parcel_get_reader(parcel, &start_pos);
   if (ret != RPC_PORT_ERROR_NONE) {
     set_last_result(ret);
     return;
   }
 
-  ret = rpc_port_parcel_create_from_parcel(&sub_parcel, parcel, start_pos,
+  ret = dl_rpc_port_parcel_create_from_parcel(&sub_parcel, parcel, start_pos,
                                            size);
   if (ret != RPC_PORT_ERROR_NONE) {
     set_last_result(ret);
     return;
   }
 
-  ret = rpc_port_parcel_reserve(sub_parcel, size);
+  ret = dl_rpc_port_parcel_reserve(sub_parcel, size);
   if (ret != RPC_PORT_ERROR_NONE) {
     rpc_port_parcel_destroy(sub_parcel);
     set_last_result(ret);
     return;
   }
 
-  ret = rpc_port_parcel_set_reader(parcel, start_pos + size);
+  ret = dl_rpc_port_parcel_set_reader(parcel, start_pos + size);
   if (ret != RPC_PORT_ERROR_NONE) {
     rpc_port_parcel_destroy(sub_parcel);
     set_last_result(ret);
@@ -206,7 +206,7 @@ static void __rpc_port_unit_map_from(rpc_port_parcel_h parcel, void *user_data)
   int i;
 
   rpc_port_parcel_read_array_count(parcel, &size);
-  rpc_port_parcel_pin(parcel);
+  dl_rpc_port_parcel_pin(parcel);
   for (i = 0; i < size; ++i) {
     unit = rpc_port_unit_create(0, 0);
     if (unit == nullptr) {
@@ -437,7 +437,7 @@ static void rpc_port_unit_map_write_file_desc_write_cb(rpc_port_parcel_h parcel,
   rpc_port_unit_h unit = data;
   int *handle = unit->data;
 
-  rpc_port_parcel_write_fd(parcel, *handle);
+  dl_rpc_port_parcel_write_fd(parcel, *handle);
 }
 
 static int rpc_port_unit_map_write_file_desc(rpc_port_unit_map_h unit_map,
@@ -758,7 +758,7 @@ static void rpc_port_unit_map_read_file_desc(rpc_port_unit_map_h unit_map,
     return;
   }
 
-  rpc_port_parcel_read_fd(unit->parcel, value);
+  dl_rpc_port_parcel_read_fd(unit->parcel, value);
 }
 )__c_cb";
 
@@ -841,7 +841,7 @@ static void __<PREFIX>_<NAME>_to(rpc_port_parcel_h parcel, void *data)
   rpc_port_parcel_write_string(parcel, handle-><ELEMENT_NAME>);
   </IS_STRING?>
   <IS_FD?>
-  rpc_port_parcel_write_fd(parcel, handle-><ELEMENT_NAME>);
+  dl_rpc_port_parcel_write_fd(parcel, handle-><ELEMENT_NAME>);
   </IS_FD?>
   <IS_VALUE?>
   rpc_port_parcel_burst_write(parcel, (const unsigned char*)(&handle-><ELEMENT_NAME>), sizeof(handle-><ELEMENT_NAME>));
@@ -872,7 +872,7 @@ static void __<PREFIX>_<NAME>_from(rpc_port_parcel_h parcel, void *data)
   rpc_port_parcel_read_string(parcel, &handle-><ELEMENT_NAME>);
   </IS_STRING?>
   <IS_FD?>
-  rpc_port_parcel_read_fd(parcel, &handle-><ELEMENT_NAME>);
+  dl_rpc_port_parcel_read_fd(parcel, &handle-><ELEMENT_NAME>);
   </IS_FD?>
   <IS_VALUE?>
   rpc_port_parcel_burst_read(parcel, (unsigned char*)(&handle-><ELEMENT_NAME>), sizeof(handle-><ELEMENT_NAME>));
@@ -1478,17 +1478,17 @@ typedef int (*rpc_port_parcel_read_fd_t)(rpc_port_parcel_h h, int* fd);
 typedef int (*rpc_port_parcel_clone_t)(rpc_port_parcel_h* h, rpc_port_parcel_h origin);
 typedef int (*rpc_port_get_peer_info_t)(rpc_port_h h, pid_t* pid, uid_t* uid);
 
-static rpc_port_parcel_reserve_t rpc_port_parcel_reserve;
-static rpc_port_parcel_create_from_parcel_t rpc_port_parcel_create_from_parcel;
-static rpc_port_parcel_set_data_size_t rpc_port_parcel_set_data_size;
-static rpc_port_parcel_get_data_size_t rpc_port_parcel_get_data_size;
-static rpc_port_parcel_pin_t rpc_port_parcel_pin;
-static rpc_port_parcel_get_reader_t rpc_port_parcel_get_reader;
-static rpc_port_parcel_set_reader_t rpc_port_parcel_set_reader;
-static rpc_port_parcel_write_fd_t rpc_port_parcel_write_fd;
-static rpc_port_parcel_read_fd_t rpc_port_parcel_read_fd;
-static rpc_port_parcel_clone_t rpc_port_parcel_clone;
-static rpc_port_get_peer_info_t rpc_port_get_peer_info;
+static rpc_port_parcel_reserve_t dl_rpc_port_parcel_reserve;
+static rpc_port_parcel_create_from_parcel_t dl_rpc_port_parcel_create_from_parcel;
+static rpc_port_parcel_set_data_size_t dl_rpc_port_parcel_set_data_size;
+static rpc_port_parcel_get_data_size_t dl_rpc_port_parcel_get_data_size;
+static rpc_port_parcel_pin_t dl_rpc_port_parcel_pin;
+static rpc_port_parcel_get_reader_t dl_rpc_port_parcel_get_reader;
+static rpc_port_parcel_set_reader_t dl_rpc_port_parcel_set_reader;
+static rpc_port_parcel_write_fd_t dl_rpc_port_parcel_write_fd;
+static rpc_port_parcel_read_fd_t dl_rpc_port_parcel_read_fd;
+static rpc_port_parcel_clone_t dl_rpc_port_parcel_clone;
+static rpc_port_get_peer_info_t dl_rpc_port_get_peer_info;
 
 static bool rpc_port_internal_loaded;
 
@@ -1499,78 +1499,78 @@ static void rpc_port_internal_init(void)
     if (rpc_port_internal_loaded)
       return;
 
-    rpc_port_parcel_reserve = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_reserve == nullptr) {
+    dl_rpc_port_parcel_reserve = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_reserve == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_create_from_parcel";
-    rpc_port_parcel_create_from_parcel = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_create_from_parcel == nullptr) {
+    dl_rpc_port_parcel_create_from_parcel = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_create_from_parcel == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_set_data_size";
-    rpc_port_parcel_set_data_size = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_set_data_size == nullptr) {
+    dl_rpc_port_parcel_set_data_size = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_set_data_size == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_get_data_size";
-    rpc_port_parcel_get_data_size = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_get_data_size == nullptr) {
+    dl_rpc_port_parcel_get_data_size = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_get_data_size == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_pin";
-    rpc_port_parcel_pin = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_pin == nullptr) {
+    dl_rpc_port_parcel_pin = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_pin == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_get_reader";
-    rpc_port_parcel_get_reader = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_get_reader == nullptr) {
+    dl_rpc_port_parcel_get_reader = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_get_reader == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_set_reader";
-    rpc_port_parcel_set_reader = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_set_reader == nullptr) {
+    dl_rpc_port_parcel_set_reader = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_set_reader == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_write_fd";
-    rpc_port_parcel_write_fd = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_write_fd == nullptr) {
+    dl_rpc_port_parcel_write_fd = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_write_fd == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_read_fd";
-    rpc_port_parcel_read_fd = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_read_fd == nullptr) {
+    dl_rpc_port_parcel_read_fd = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_read_fd == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_parcel_clone";
-    rpc_port_parcel_clone = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_parcel_clone == nullptr) {
+    dl_rpc_port_parcel_clone = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_parcel_clone == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }
 
     symbol = "rpc_port_get_peer_info";
-    rpc_port_get_peer_info = dlsym(RTLD_DEFAULT, symbol);
-    if (rpc_port_get_peer_info == nullptr) {
+    dl_rpc_port_get_peer_info = dlsym(RTLD_DEFAULT, symbol);
+    if (dl_rpc_port_get_peer_info == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol);
       return;
     }

diff --git a/idlc/gen/version2/c_body_generator_list_base_cb.hh b/idlc/gen/version2/c_body_generator_list_base_cb.hh
index 34825c816201276b667a64d8e2a7373690b8cbeb..ab5b2a86886314c94ed1097a635df2e1e845d468 100644 (file)
--- a/idlc/gen/version2/c_body_generator_list_base_cb.hh
+++ b/idlc/gen/version2/c_body_generator_list_base_cb.hh
@@ -58,7 +58,7 @@ static void __<PREFIX>_<NAME>_to(rpc_port_parcel_h parcel, void *data)
     </IS_STRING_TYPE?>
 
     <IS_FD_TYPE?>
-    rpc_port_parcel_write_fd(parcel, *((int *)value));
+    dl_rpc_port_parcel_write_fd(parcel, *((int *)value));
     </IS_FD_TYPE?>
 
     <IS_DEFAULT_TYPE?>
@@ -105,7 +105,7 @@ static void __<PREFIX>_<NAME>_from(rpc_port_parcel_h parcel, void *data)
       set_last_result(RPC_PORT_ERROR_OUT_OF_MEMORY);
       return;
     }
-    rpc_port_parcel_read_fd(parcel, value);
+    dl_rpc_port_parcel_read_fd(parcel, value);
     </IS_FD_TYPE?>
 
     <IS_DEFAULT_TYPE?>

diff --git a/idlc/gen/version2/c_body_generator_map_base_cb.hh b/idlc/gen/version2/c_body_generator_map_base_cb.hh
index ed92544e447df8a129fdf74291e9eacb38b412af..116e88497c17f38b30634f66e269a10d0e9c833b 100644 (file)
--- a/idlc/gen/version2/c_body_generator_map_base_cb.hh
+++ b/idlc/gen/version2/c_body_generator_map_base_cb.hh
@@ -59,7 +59,7 @@ static gboolean __<PREFIX>_<NAME>_traverse_cb(gpointer key, gpointer value, gpoi
   rpc_port_parcel_write_string(info->parcel, STRING_GET(value));
   </IS_STRING_TYPE?>
   <IS_FD_TYPE?>
-  rpc_port_parcel_write_fd(info->parcel, *((int *)value));
+  dl_rpc_port_parcel_write_fd(info->parcel, *((int *)value));
   </IS_FD_TYPE?>
   <IS_DEFAULT_TYPE?>
   rpc_port_parcel_burst_write(info->parcel, (const unsigned char *)value, sizeof(<VALUE_TYPE>));
@@ -123,7 +123,7 @@ static void __<PREFIX>_<NAME>_from(rpc_port_parcel_h parcel, void *data)
     rpc_port_parcel_read_string(parcel, &value);
     </IS_STRING_TYPE?>
     <IS_FD_TYPE?>
-    rpc_port_parcel_read_fd(parcel, &value);
+    dl_rpc_port_parcel_read_fd(parcel, &value);
     </IS_FD_TYPE?>
     <IS_DEFAULT_TYPE?>
     rpc_port_parcel_burst_read(parcel, (unsigned char *)(&value), sizeof(<VALUE_TYPE>));

diff --git a/idlc/gen/version2/c_proxy_body_generator_cb.hh b/idlc/gen/version2/c_proxy_body_generator_cb.hh
index b5b38d20772dd500841bdb7f5f589e6aa6dfbdcd..06e49e2324dcb7419550d6bdc153f5172ddb576b 100644 (file)
--- a/idlc/gen/version2/c_proxy_body_generator_cb.hh
+++ b/idlc/gen/version2/c_proxy_body_generator_cb.hh
@@ -704,7 +704,7 @@ EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<IFACE_NAME>_invoke_callback(void
     return RPC_PORT_ERROR_INVALID_PARAMETER;
   }
 
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   rpc_port_proxy_lem_request_queue_push(handle, cloned_parcel);
 
   source = g_idle_source_new();
@@ -729,7 +729,7 @@ EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<IFACE_NAME>_send_result(void* h,
     return RPC_PORT_ERROR_INVALID_PARAMETER;
   }
 
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   rpc_port_proxy_lem_result_queue_push(handle, cloned_parcel);
   return RPC_PORT_ERROR_NONE;
 }
@@ -2146,7 +2146,7 @@ EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<IFACE_NAME>_invoke_callback(void
     return RPC_PORT_ERROR_INVALID_PARAMETER;
   }
 
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   rpc_port_proxy_lem_request_queue_push(handle, cloned_parcel);
 
   source = g_idle_source_new();
@@ -2171,7 +2171,7 @@ EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<IFACE_NAME>_send_result(void* h,
     return RPC_PORT_ERROR_INVALID_PARAMETER;
   }
 
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   rpc_port_proxy_lem_result_queue_push(handle, cloned_parcel);
   return RPC_PORT_ERROR_NONE;
 }

diff --git a/idlc/gen/version2/c_stub_body_generator.cc b/idlc/gen/version2/c_stub_body_generator.cc
index 5c140c49ee45b2ae064b1e8e26484ddd993a8c8e..d365b97ab9246022a9f0adb1ab50c951d289b6b7 100644 (file)
--- a/idlc/gen/version2/c_stub_body_generator.cc
+++ b/idlc/gen/version2/c_stub_body_generator.cc
@@ -118,6 +118,7 @@ void CStubBodyGenerator::OnInitGen(std::ofstream& stream) {
       .Repeat("LEM_APIS", GetDocument().GetBlocks(), lem_apis)
       .Replace("VERSION", std::string(FULLVER))
       .Replace("INCLUDE", GetIncludeHeader())
+      .Replace("INTERNAL_INCLUDE", GenIncludeInternalHeader())
       .Replace("UNIT_MAP_DEFINITION", GetUnitMapDefinition())
       .Replace("STRUCTURE_DEFINITION", GetStructureDefinition())
       .Replace("REMOTE_EXCEPTION_DEFINITION", GetRemoteExceptionDefinition())
@@ -677,5 +678,9 @@ std::string CStubBodyGenerator::GetInterfaceContextExtensionBase(
   return "";
 }
 
+std::string CStubBodyGenerator::GenIncludeInternalHeader() {
+  if (options_->UseExtension()) return CB_INTERNAL_HEADER_INCLUSION;
+  return "";
+}
 }  // namespace version2
 }  // namespace tidl

diff --git a/idlc/gen/version2/c_stub_body_generator.hh b/idlc/gen/version2/c_stub_body_generator.hh
index 8eb53c4b90523e1543070c144ca08acced909bbb..a08a4bbe82bcd890c3aa7d4d23a2388947282dfd 100644 (file)
--- a/idlc/gen/version2/c_stub_body_generator.hh
+++ b/idlc/gen/version2/c_stub_body_generator.hh
@@ -76,6 +76,7 @@ class CStubBodyGenerator : public CBodyGeneratorBase {
   std::string GenMethodHandlers(const Interface& iface);
   std::string GenAccessControlSet(const Interface& iface);
   std::string GetLemBase();
+  std::string GenIncludeInternalHeader();
 
  private:
   std::shared_ptr<Options> options_;

diff --git a/idlc/gen/version2/c_stub_body_generator_cb.hh b/idlc/gen/version2/c_stub_body_generator_cb.hh
index 460a0248cf2f940598a38647bc100d2f2a889032..75c3ece3053c1747dbc6dccb696cd5c9ed07befa 100644 (file)
--- a/idlc/gen/version2/c_stub_body_generator_cb.hh
+++ b/idlc/gen/version2/c_stub_body_generator_cb.hh
@@ -49,6 +49,7 @@ R"__c_cb(
 #include <app_common.h>
 
 <INCLUDE>
+<INTERNAL_INCLUDE>
 
 #undef LOG_TAG
 #define LOG_TAG "RPC_PORT_STUB"
@@ -378,7 +379,7 @@ EXPORT_API int rpc_port_stub_<INPUT_FILE>_lem_<IFACE_NAME>_send(void *context, c
 
   if (gettid() == getpid()) {
     if (handle->callback.received) {
-      rpc_port_parcel_clone(&cloned_parcel, parcel);
+      dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
       handle->callback.received(context, sender, instance, cloned_parcel);
       rpc_port_parcel_destroy(cloned_parcel);
     }
@@ -1812,7 +1813,7 @@ pid_t pid;
 if (ARRAY_SIZE(privileges) < 1)
   return RPC_PORT_ERROR_NONE;
 
-ret = rpc_port_get_peer_info(h->port, &pid, &uid);
+ret = dl_rpc_port_get_peer_info(h->port, &pid, &uid);
 if (ret == RPC_PORT_ERROR_NONE && uid < REGULAR_UID_MIN) {
   _W("Bypass access control. pid(%d), uid(%u)", pid, uid);
   return RPC_PORT_ERROR_NONE;
@@ -1936,7 +1937,7 @@ static rpc_port_stub_lem_data_h rpc_port_stub_lem_data_create_with_parcel(void *
     return nullptr;
   }
 
-  rpc_port_parcel_clone(&data->parcel, parcel);
+  dl_rpc_port_parcel_clone(&data->parcel, parcel);
   if (data->parcel == nullptr) {
     _E("Failed to clone parcel");
     rpc_port_stub_lem_data_destroy(data);
@@ -2249,6 +2250,10 @@ static gboolean rpc_port_stub_lem_on_received(gpointer user_data)
 }
 )__c_cb";
 
+constexpr const char CB_INTERNAL_HEADER_INCLUSION[] =
+R"__cpp_cb(
+#include <rpc-port-internal.h>
+)__cpp_cb";
 
 /**
  * <PREFIX> The prefix of the interface.

diff --git a/idlc/gen/version2/cpp_generator_base_cb.hh b/idlc/gen/version2/cpp_generator_base_cb.hh
index af5239d4dde82d03d0e535be9a80d70446b53d93..038e309b547d6924a014d4cdd3c257f9d6296b03 100644 (file)
--- a/idlc/gen/version2/cpp_generator_base_cb.hh
+++ b/idlc/gen/version2/cpp_generator_base_cb.hh
@@ -470,19 +470,19 @@ class Unit {
     rpc_port_parcel_write_int32(parcel, type_);
 
     unsigned int size_pos = 0;
-    rpc_port_parcel_get_data_size(parcel, &size_pos);
-    rpc_port_parcel_reserve(parcel, sizeof(unsigned int));
+    dl_rpc_port_parcel_get_data_size(parcel, &size_pos);
+    dl_rpc_port_parcel_reserve(parcel, sizeof(unsigned int));
 
     for (auto& i : cmds_) {
       i(parcel);
     }
 
     unsigned int cur_pos;
-    rpc_port_parcel_get_data_size(parcel, &cur_pos);
+    dl_rpc_port_parcel_get_data_size(parcel, &cur_pos);
     size_t size = cur_pos - size_pos - sizeof(unsigned int);
-    rpc_port_parcel_set_data_size(parcel, size_pos);
+    dl_rpc_port_parcel_set_data_size(parcel, size_pos);
     rpc_port_parcel_write_int32(parcel, size);
-    rpc_port_parcel_set_data_size(parcel, cur_pos);
+    dl_rpc_port_parcel_set_data_size(parcel, cur_pos);
     cmds_.clear();
   }
 
@@ -495,14 +495,14 @@ class Unit {
     if (size == 0) return;
 
     uint32_t start_pos = 0;
-    rpc_port_parcel_get_reader(parcel, &start_pos);
+    dl_rpc_port_parcel_get_reader(parcel, &start_pos);
 
     rpc_port_parcel_h sub_parcel_raw = nullptr;
-    rpc_port_parcel_create_from_parcel(&sub_parcel_raw, parcel, start_pos,
+    dl_rpc_port_parcel_create_from_parcel(&sub_parcel_raw, parcel, start_pos,
                                        size);
     sub_parcel_.reset(sub_parcel_raw);
-    rpc_port_parcel_reserve(sub_parcel_.get(), size);
-    rpc_port_parcel_set_reader(parcel, start_pos + size);
+    dl_rpc_port_parcel_reserve(sub_parcel_.get(), size);
+    dl_rpc_port_parcel_set_reader(parcel, start_pos + size);
   }
 
   <SERIALIZER>
@@ -645,7 +645,7 @@ rpc_port_parcel_write_string(p, value.GetFileName().c_str());
 
 constexpr const char CB_UNIT_IMPL_SERIALIZER_FILE_DESC[] =
 R"__cpp_cb(
-rpc_port_parcel_write_fd(p, value.Get());
+dl_rpc_port_parcel_write_fd(p, value.Get());
 )__cpp_cb";
 
 constexpr const char CB_UNIT_IMPL_SERIALIZER_BASE[] =
@@ -828,7 +828,7 @@ if (tmp_filename != nullptr) {
 constexpr const char CB_UNIT_IMPL_DESERIALIZER_FILE_DESC[] =
 R"__cpp_cb(
 int fd = -1;
-rpc_port_parcel_read_fd(sub_parcel_.get(), &fd);
+dl_rpc_port_parcel_read_fd(sub_parcel_.get(), &fd);
 value.Set(fd);
 )__cpp_cb";
 
@@ -888,7 +888,7 @@ class UnitMap {
   void Deserialize(rpc_port_parcel_h parcel) {
     int size = 0;
     rpc_port_parcel_read_array_count(parcel, &size);
-    rpc_port_parcel_pin(parcel);
+    dl_rpc_port_parcel_pin(parcel);
     for (int i = 0; i < size; ++i) {
       auto unit = std::make_shared<Unit>();
       unit->Deserialize(parcel);
@@ -967,107 +967,107 @@ using rpc_port_parcel_read_fd_t = int (*)(rpc_port_parcel_h h, int* fd);
 using rpc_port_parcel_clone_t = int (*)(rpc_port_parcel_h* h, rpc_port_parcel_h origin);
 using rpc_port_get_peer_info_t = int (*)(rpc_port_h h, pid_t* pid, uid_t* uid);
 
-rpc_port_parcel_reserve_t rpc_port_parcel_reserve;
-rpc_port_parcel_create_from_parcel_t rpc_port_parcel_create_from_parcel;
-rpc_port_parcel_set_data_size_t rpc_port_parcel_set_data_size;
-rpc_port_parcel_get_data_size_t rpc_port_parcel_get_data_size;
-rpc_port_parcel_pin_t rpc_port_parcel_pin;
-rpc_port_parcel_get_reader_t rpc_port_parcel_get_reader;
-rpc_port_parcel_set_reader_t rpc_port_parcel_set_reader;
-rpc_port_parcel_write_fd_t rpc_port_parcel_write_fd;
-rpc_port_parcel_read_fd_t rpc_port_parcel_read_fd;
-rpc_port_parcel_clone_t rpc_port_parcel_clone;
-rpc_port_get_peer_info_t rpc_port_get_peer_info;
+rpc_port_parcel_reserve_t dl_rpc_port_parcel_reserve;
+rpc_port_parcel_create_from_parcel_t dl_rpc_port_parcel_create_from_parcel;
+rpc_port_parcel_set_data_size_t dl_rpc_port_parcel_set_data_size;
+rpc_port_parcel_get_data_size_t dl_rpc_port_parcel_get_data_size;
+rpc_port_parcel_pin_t dl_rpc_port_parcel_pin;
+rpc_port_parcel_get_reader_t dl_rpc_port_parcel_get_reader;
+rpc_port_parcel_set_reader_t dl_rpc_port_parcel_set_reader;
+rpc_port_parcel_write_fd_t dl_rpc_port_parcel_write_fd;
+rpc_port_parcel_read_fd_t dl_rpc_port_parcel_read_fd;
+rpc_port_parcel_clone_t dl_rpc_port_parcel_clone;
+rpc_port_get_peer_info_t dl_rpc_port_get_peer_info;
 
 class RpcPortInternals {
  public:
   RpcPortInternals() {
     std::string symbol = "rpc_port_parcel_reserve";
-    rpc_port_parcel_reserve = reinterpret_cast<rpc_port_parcel_reserve_t>(
+    dl_rpc_port_parcel_reserve = reinterpret_cast<rpc_port_parcel_reserve_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_reserve == nullptr) {
+    if (dl_rpc_port_parcel_reserve == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_create_from_parcel";
-    rpc_port_parcel_create_from_parcel = reinterpret_cast<rpc_port_parcel_create_from_parcel_t>(
+    dl_rpc_port_parcel_create_from_parcel = reinterpret_cast<rpc_port_parcel_create_from_parcel_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_create_from_parcel == nullptr) {
+    if (dl_rpc_port_parcel_create_from_parcel == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_set_data_size";
-    rpc_port_parcel_set_data_size =
+    dl_rpc_port_parcel_set_data_size =
         reinterpret_cast<rpc_port_parcel_set_data_size_t>(
             dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_set_data_size == nullptr) {
+    if (dl_rpc_port_parcel_set_data_size == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_get_data_size";
-    rpc_port_parcel_get_data_size =
+    dl_rpc_port_parcel_get_data_size =
         reinterpret_cast<rpc_port_parcel_get_data_size_t>(
             dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_get_data_size == nullptr) {
+    if (dl_rpc_port_parcel_get_data_size == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_pin";
-    rpc_port_parcel_pin = reinterpret_cast<rpc_port_parcel_pin_t>(
+    dl_rpc_port_parcel_pin = reinterpret_cast<rpc_port_parcel_pin_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_pin == nullptr) {
+    if (dl_rpc_port_parcel_pin == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_get_reader";
-    rpc_port_parcel_get_reader = reinterpret_cast<rpc_port_parcel_get_reader_t>(
+    dl_rpc_port_parcel_get_reader = reinterpret_cast<rpc_port_parcel_get_reader_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_get_reader == nullptr) {
+    if (dl_rpc_port_parcel_get_reader == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_set_reader";
-    rpc_port_parcel_set_reader = reinterpret_cast<rpc_port_parcel_set_reader_t>(
+    dl_rpc_port_parcel_set_reader = reinterpret_cast<rpc_port_parcel_set_reader_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_set_reader == nullptr) {
+    if (dl_rpc_port_parcel_set_reader == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_write_fd";
-    rpc_port_parcel_write_fd = reinterpret_cast<rpc_port_parcel_write_fd_t>(
+    dl_rpc_port_parcel_write_fd = reinterpret_cast<rpc_port_parcel_write_fd_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_write_fd == nullptr) {
+    if (dl_rpc_port_parcel_write_fd == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_read_fd";
-    rpc_port_parcel_read_fd = reinterpret_cast<rpc_port_parcel_read_fd_t>(
+    dl_rpc_port_parcel_read_fd = reinterpret_cast<rpc_port_parcel_read_fd_t>(
         dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_read_fd == nullptr) {
+    if (dl_rpc_port_parcel_read_fd == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_parcel_clone";
-    rpc_port_parcel_clone = reinterpret_cast<rpc_port_parcel_clone_t>(
+    dl_rpc_port_parcel_clone = reinterpret_cast<rpc_port_parcel_clone_t>(
     dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_parcel_clone == nullptr) {
+    if (dl_rpc_port_parcel_clone == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }
 
     symbol = "rpc_port_get_peer_info";
-    rpc_port_get_peer_info = reinterpret_cast<rpc_port_get_peer_info_t>(
+    dl_rpc_port_get_peer_info = reinterpret_cast<rpc_port_get_peer_info_t>(
     dlsym(RTLD_DEFAULT, symbol.c_str()));
-    if (rpc_port_get_peer_info == nullptr) {
+    if (dl_rpc_port_get_peer_info == nullptr) {
       _E("Failed to find symbol(%s). Please check rpc-port version", symbol.c_str());
       return;
     }

diff --git a/idlc/gen/version2/cpp_proxy_body_generator_cb.hh b/idlc/gen/version2/cpp_proxy_body_generator_cb.hh
index 26dc7e5a02d8f78d4350bdf1cfe0cc5bb3b81197..5f284e179b490cd8c7ca14696af5efdc574aa6ec 100644 (file)
--- a/idlc/gen/version2/cpp_proxy_body_generator_cb.hh
+++ b/idlc/gen/version2/cpp_proxy_body_generator_cb.hh
@@ -725,7 +725,7 @@ EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<CLS_NAME>_invoke_callback(void*
   auto* handle = static_cast<rpc_port::<FILE_NAMESPACE>::LocalExecution*>(h);
   auto* ptr = new std::weak_ptr<rpc_port::<FILE_NAMESPACE>::LocalExecution>(handle->shared_from_this());
   rpc_port_parcel_h cloned_parcel = nullptr;
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   handle->RequestQueuePush(cloned_parcel);
   auto* source = g_idle_source_new();
   if (source == nullptr) {
@@ -755,7 +755,7 @@ EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<CLS_NAME>_invoke_callback(void*
 EXPORT_API int rpc_port_proxy_<INPUT_FILE>_lem_<CLS_NAME>_send_result(void* h, rpc_port_parcel_h parcel) {
   auto* handle = static_cast<rpc_port::<FILE_NAMESPACE>::LocalExecution*>(h);
   rpc_port_parcel_h cloned_parcel = nullptr;
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   handle->ResultQueuePush(cloned_parcel);
   return RPC_PORT_ERROR_NONE;
 }

diff --git a/idlc/gen/version2/cpp_stub_body_generator_cb.hh b/idlc/gen/version2/cpp_stub_body_generator_cb.hh
index 0ed537f09a617315a0fe7ab58f98606fbe0a44e6..37b34c07936a8c352e41f4448f425bdfe7da7f57 100644 (file)
--- a/idlc/gen/version2/cpp_stub_body_generator_cb.hh
+++ b/idlc/gen/version2/cpp_stub_body_generator_cb.hh
@@ -334,7 +334,7 @@ bool <CLS_NAME>::ServiceBase::CheckPrivileges(rpc_port_h port, int method_id) {
   if (found == privilege_map_.end())
     return true;
 
-  ret = rpc_port_get_peer_info(port, &pid, &uid);
+  ret = dl_rpc_port_get_peer_info(port, &pid, &uid);
   if(ret == RPC_PORT_ERROR_NONE && uid < kRegularUidMin) {
     _W("Bypass access control. pid(%d), uid(%u)", pid, uid);
     return true;
@@ -834,7 +834,7 @@ EXPORT_API int rpc_port_stub_<INPUT_FILE>_lem_<CLS_NAME>_send(void* context, rpc
   }
 
   rpc_port_parcel_h cloned_parcel = nullptr;
-  rpc_port_parcel_clone(&cloned_parcel, parcel);
+  dl_rpc_port_parcel_clone(&cloned_parcel, parcel);
   if (gettid() == getpid()) {
     <CLS_NAME>_context_->OnReceived(context, cloned_parcel);
     return RPC_PORT_ERROR_NONE;