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
21namespace OHOS {
22namespace Idl {
23void MetadataSerializer::Serialize()
24{
25    SerializeMetaComponent(metaComponent_);
26}
27
28void 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
66void 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
83void 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
92void 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
109void 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
125void MetadataSerializer::SerializeMetaParameter(MetaParameter* mp)
126{
127    if (mp == nullptr) {
128        return;
129    }
130    mp->name_ = reinterpret_cast<char*>(SerializeAdjust(mp->name_));
131}
132
133void MetadataSerializer::SerializeMetaType(MetaType* mt)
134{
135    if (mt == nullptr) {
136        return;
137    }
138    mt->nestedTypeIndexes_ = reinterpret_cast<int*>(SerializeAdjust(mt->nestedTypeIndexes_));
139}
140
141ptrdiff_t MetadataSerializer::SerializeAdjust(const void* addr)
142{
143    return reinterpret_cast<uintptr_t>(addr) - baseAddr_;
144}
145
146void MetadataSerializer::Deserialize()
147{
148    DeserializeMetaComponent(metaComponent_);
149}
150
151void 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
193void 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
212void 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
221void 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
238void 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
254void MetadataSerializer::DeserializeMetaParameter(MetaParameter* mp)
255{
256    if (mp == nullptr) {
257        return;
258    }
259    mp->name_ = reinterpret_cast<char*>(DeserializeAdjust(mp->name_));
260}
261
262void MetadataSerializer::DeserializeMetaType(MetaType* mt)
263{
264    if (mt == nullptr) {
265        return;
266    }
267    mt->nestedTypeIndexes_ = reinterpret_cast<int*>(DeserializeAdjust(mt->nestedTypeIndexes_));
268}
269
270uintptr_t MetadataSerializer::DeserializeAdjust(const void* addr)
271{
272    return reinterpret_cast<ptrdiff_t>(addr) + baseAddr_;
273}
274} // namespace Idl
275} // namespace OHOS
276