1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 
17 #include <climits>
18 
19 #include "metadata/metadata_serializer.h"
20 
21 namespace OHOS {
22 namespace Idl {
Serialize()23 void MetadataSerializer::Serialize()
24 {
25     SerializeMetaComponent(metaComponent_);
26 }
27 
SerializeMetaComponent(MetaComponent * mc)28 void MetadataSerializer::SerializeMetaComponent(MetaComponent* mc)
29 {
30     if (mc == nullptr) {
31         return;
32     }
33     mc->name_ = reinterpret_cast<char*>(SerializeAdjust(mc->name_));
34 
35     for (int i = 0; i < mc->namespaceNumber_; i++) {
36         MetaNamespace* mn = mc->namespaces_[i];
37         SerializeMetaNamespace(mn);
38         mc->namespaces_[i] = reinterpret_cast<MetaNamespace*>(SerializeAdjust(mn));
39     }
40     mc->namespaces_ = reinterpret_cast<MetaNamespace**>(SerializeAdjust(mc->namespaces_));
41 
42     for (int i = 0; i < mc->sequenceableNumber_; i++) {
43         MetaSequenceable* mp = mc->sequenceables_[i];
44         SerializeMetaSequenceable(mp);
45         mc->sequenceables_[i] = reinterpret_cast<MetaSequenceable*>(SerializeAdjust(mp));
46     }
47     mc->sequenceables_ = reinterpret_cast<MetaSequenceable**>(SerializeAdjust(mc->sequenceables_));
48 
49     for (int i = 0; i < mc->interfaceNumber_; i++) {
50         MetaInterface* mi = mc->interfaces_[i];
51         SerializeMetaInterface(mi);
52         mc->interfaces_[i] = reinterpret_cast<MetaInterface*>(SerializeAdjust(mi));
53     }
54     mc->interfaces_ = reinterpret_cast<MetaInterface**>(SerializeAdjust(mc->interfaces_));
55 
56     for (int i = 0; i < mc->typeNumber_; i++) {
57         MetaType* mt = mc->types_[i];
58         SerializeMetaType(mt);
59         mc->types_[i] = reinterpret_cast<MetaType*>(SerializeAdjust(mt));
60     }
61     mc->types_ = reinterpret_cast<MetaType**>(SerializeAdjust(mc->types_));
62 
63     mc->stringPool_ = reinterpret_cast<char*>(SerializeAdjust(mc->stringPool_));
64 }
65 
SerializeMetaNamespace(MetaNamespace * mn)66 void MetadataSerializer::SerializeMetaNamespace(MetaNamespace* mn)
67 {
68     if (mn == nullptr) {
69         return;
70     }
71     mn->name_ = reinterpret_cast<char*>(SerializeAdjust(mn->name_));
72     mn->sequenceableIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mn->sequenceableIndexes_));
73     mn->interfaceIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mn->interfaceIndexes_));
74 
75     for (int i = 0; i < mn->namespaceNumber_; i++) {
76         MetaNamespace* innermn = mn->namespaces_[i];
77         SerializeMetaNamespace(innermn);
78         mn->namespaces_[i] = reinterpret_cast<MetaNamespace*>(SerializeAdjust(innermn));
79     }
80     mn->namespaces_ = reinterpret_cast<MetaNamespace**>(SerializeAdjust(mn->namespaces_));
81 }
82 
SerializeMetaSequenceable(MetaSequenceable * mp)83 void MetadataSerializer::SerializeMetaSequenceable(MetaSequenceable* mp)
84 {
85     if (mp == nullptr) {
86         return;
87     }
88     mp->name_ = reinterpret_cast<char*>(SerializeAdjust(mp->name_));
89     mp->namespace_ = reinterpret_cast<char*>(SerializeAdjust(mp->namespace_));
90 }
91 
SerializeMetaInterface(MetaInterface * mi)92 void MetadataSerializer::SerializeMetaInterface(MetaInterface* mi)
93 {
94     if (mi == nullptr) {
95         return;
96     }
97     mi->license_ = reinterpret_cast<char*>(SerializeAdjust(mi->license_));
98     mi->name_ = reinterpret_cast<char*>(SerializeAdjust(mi->name_));
99     mi->namespace_ = reinterpret_cast<char*>(SerializeAdjust(mi->namespace_));
100 
101     for (int i = 0; i < mi->methodNumber_; i++) {
102         MetaMethod* mm = mi->methods_[i];
103         SerializeMetaMethod(mm);
104         mi->methods_[i] = reinterpret_cast<MetaMethod*>(SerializeAdjust(mm));
105     }
106     mi->methods_ = reinterpret_cast<MetaMethod**>(SerializeAdjust(mi->methods_));
107 }
108 
SerializeMetaMethod(MetaMethod * mm)109 void MetadataSerializer::SerializeMetaMethod(MetaMethod* mm)
110 {
111     if (mm == nullptr) {
112         return;
113     }
114     mm->name_ = reinterpret_cast<char*>(SerializeAdjust(mm->name_));
115     mm->signature_ = reinterpret_cast<char*>(SerializeAdjust(mm->signature_));
116 
117     for (int i = 0; i < mm->parameterNumber_; i++) {
118         MetaParameter* mp = mm->parameters_[i];
119         SerializeMetaParameter(mp);
120         mm->parameters_[i] = reinterpret_cast<MetaParameter*>(SerializeAdjust(mp));
121     }
122     mm->parameters_ = reinterpret_cast<MetaParameter**>(SerializeAdjust(mm->parameters_));
123 }
124 
SerializeMetaParameter(MetaParameter * mp)125 void MetadataSerializer::SerializeMetaParameter(MetaParameter* mp)
126 {
127     if (mp == nullptr) {
128         return;
129     }
130     mp->name_ = reinterpret_cast<char*>(SerializeAdjust(mp->name_));
131 }
132 
SerializeMetaType(MetaType * mt)133 void MetadataSerializer::SerializeMetaType(MetaType* mt)
134 {
135     if (mt == nullptr) {
136         return;
137     }
138     mt->nestedTypeIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mt->nestedTypeIndexes_));
139 }
140 
SerializeAdjust(const void * addr)141 ptrdiff_t MetadataSerializer::SerializeAdjust(const void* addr)
142 {
143     return reinterpret_cast<uintptr_t>(addr) - baseAddr_;
144 }
145 
Deserialize()146 void MetadataSerializer::Deserialize()
147 {
148     DeserializeMetaComponent(metaComponent_);
149 }
150 
DeserializeMetaComponent(MetaComponent * mc)151 void MetadataSerializer::DeserializeMetaComponent(MetaComponent* mc)
152 {
153     if (mc == nullptr) {
154         return;
155     }
156     mc->name_ = reinterpret_cast<char*>(DeserializeAdjust(mc->name_));
157 
158     mc->namespaces_ = reinterpret_cast<MetaNamespace**>(DeserializeAdjust(mc->namespaces_));
159     if (mc->namespaceNumber_ > 0 && mc->namespaceNumber_ < INT_MAX) {
160         for (int i = 0; i < mc->namespaceNumber_; i++) {
161             mc->namespaces_[i] = reinterpret_cast<MetaNamespace*>(DeserializeAdjust(mc->namespaces_[i]));
162             MetaNamespace* mn = mc->namespaces_[i];
163             DeserializeMetaNamespace(mn);
164         }
165     }
166 
167     mc->sequenceables_ = reinterpret_cast<MetaSequenceable**>(DeserializeAdjust(mc->sequenceables_));
168     if (mc->sequenceableNumber_ > 0 && mc->sequenceableNumber_ < INT_MAX) {
169         for (int i = 0; i < mc->sequenceableNumber_; i++) {
170             mc->sequenceables_[i] = reinterpret_cast<MetaSequenceable*>(DeserializeAdjust(mc->sequenceables_[i]));
171             MetaSequenceable* mp = mc->sequenceables_[i];
172             DeserializeMetaSequenceable(mp);
173         }
174     }
175 
176     mc->interfaces_ = reinterpret_cast<MetaInterface**>(DeserializeAdjust(mc->interfaces_));
177     for (int i = 0; i < mc->interfaceNumber_; i++) {
178         mc->interfaces_[i] = reinterpret_cast<MetaInterface*>(DeserializeAdjust(mc->interfaces_[i]));
179         MetaInterface* mi = mc->interfaces_[i];
180         DeserializeMetaInterface(mi);
181     }
182 
183     mc->types_ = reinterpret_cast<MetaType**>(DeserializeAdjust(mc->types_));
184     for (int i = 0; i < mc->typeNumber_; i++) {
185         mc->types_[i] = reinterpret_cast<MetaType*>(DeserializeAdjust(mc->types_[i]));
186         MetaType* mt = mc->types_[i];
187         DeserializeMetaType(mt);
188     }
189 
190     mc->stringPool_ = reinterpret_cast<char*>(DeserializeAdjust(mc->stringPool_));
191 }
192 
DeserializeMetaNamespace(MetaNamespace * mn)193 void MetadataSerializer::DeserializeMetaNamespace(MetaNamespace* mn)
194 {
195     if (mn == nullptr) {
196         return;
197     }
198     mn->name_ = reinterpret_cast<char*>(DeserializeAdjust(mn->name_));
199     mn->sequenceableIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mn->sequenceableIndexes_));
200     mn->interfaceIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mn->interfaceIndexes_));
201 
202     mn->namespaces_ = reinterpret_cast<MetaNamespace**>(DeserializeAdjust(mn->namespaces_));
203     if (mn->namespaceNumber_ > 0 && mn->namespaceNumber_ < INT_MAX) {
204         for (int i = 0; i < mn->namespaceNumber_; i++) {
205             mn->namespaces_[i] = reinterpret_cast<MetaNamespace*>(DeserializeAdjust(mn->namespaces_[i]));
206             MetaNamespace* innermn = mn->namespaces_[i];
207             DeserializeMetaNamespace(innermn);
208         }
209     }
210 }
211 
DeserializeMetaSequenceable(MetaSequenceable * mp)212 void MetadataSerializer::DeserializeMetaSequenceable(MetaSequenceable* mp)
213 {
214     if (mp == nullptr) {
215         return;
216     }
217     mp->name_ = reinterpret_cast<char*>(DeserializeAdjust(mp->name_));
218     mp->namespace_ = reinterpret_cast<char*>(DeserializeAdjust(mp->namespace_));
219 }
220 
DeserializeMetaInterface(MetaInterface * mi)221 void MetadataSerializer::DeserializeMetaInterface(MetaInterface* mi)
222 {
223     if (mi == nullptr) {
224         return;
225     }
226     mi->license_ = reinterpret_cast<char*>(DeserializeAdjust(mi->license_));
227     mi->name_ = reinterpret_cast<char*>(DeserializeAdjust(mi->name_));
228     mi->namespace_ = reinterpret_cast<char*>(DeserializeAdjust(mi->namespace_));
229 
230     mi->methods_ = reinterpret_cast<MetaMethod**>(DeserializeAdjust(mi->methods_));
231     for (int i = 0; i < mi->methodNumber_; i++) {
232         mi->methods_[i] = reinterpret_cast<MetaMethod*>(DeserializeAdjust(mi->methods_[i]));
233         MetaMethod* mm = mi->methods_[i];
234         DeserializeMetaMethod(mm);
235     }
236 }
237 
DeserializeMetaMethod(MetaMethod * mm)238 void MetadataSerializer::DeserializeMetaMethod(MetaMethod* mm)
239 {
240     if (mm == nullptr) {
241         return;
242     }
243     mm->name_ = reinterpret_cast<char*>(DeserializeAdjust(mm->name_));
244     mm->signature_ = reinterpret_cast<char*>(DeserializeAdjust(mm->signature_));
245 
246     mm->parameters_ = reinterpret_cast<MetaParameter**>(DeserializeAdjust(mm->parameters_));
247     for (int i = 0; i < mm->parameterNumber_; i++) {
248         mm->parameters_[i] = reinterpret_cast<MetaParameter*>(DeserializeAdjust(mm->parameters_[i]));
249         MetaParameter* mp = mm->parameters_[i];
250         DeserializeMetaParameter(mp);
251     }
252 }
253 
DeserializeMetaParameter(MetaParameter * mp)254 void MetadataSerializer::DeserializeMetaParameter(MetaParameter* mp)
255 {
256     if (mp == nullptr) {
257         return;
258     }
259     mp->name_ = reinterpret_cast<char*>(DeserializeAdjust(mp->name_));
260 }
261 
DeserializeMetaType(MetaType * mt)262 void MetadataSerializer::DeserializeMetaType(MetaType* mt)
263 {
264     if (mt == nullptr) {
265         return;
266     }
267     mt->nestedTypeIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mt->nestedTypeIndexes_));
268 }
269 
DeserializeAdjust(const void * addr)270 uintptr_t MetadataSerializer::DeserializeAdjust(const void* addr)
271 {
272     return reinterpret_cast<ptrdiff_t>(addr) + baseAddr_;
273 }
274 } // namespace Idl
275 } // namespace OHOS
276