Kea: translator_shared_network.cc Source File

| Kea 3.2.0-git

translator_shared_network.cc
Go to the documentation of this file.
1// Copyright (C) 2018-2026 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8
9#include <yang/translator_shared_network.h>
10#include <yang/yang_models.h>
11
12#include <sstream>
13
14using namespace std;
15using namespace isc::data;
16using namespace libyang;
17using namespace sysrepo;
18
19namespace isc {
20namespace yang {
21
22TranslatorSharedNetwork::TranslatorSharedNetwork(Session session,
23 const string& model)
24 : Translator(session, model),
25 TranslatorOptionData(session, model),
26 TranslatorOptionDataList(session, model),
27 TranslatorPool(session, model),
28 TranslatorPools(session, model),
29 TranslatorPdPool(session, model),
30 TranslatorPdPools(session, model),
31 TranslatorHost(session, model),
32 TranslatorHosts(session, model),
33 TranslatorSubnet(session, model),
34 TranslatorSubnets(session, model) {
35}
36
37 ElementPtr
38TranslatorSharedNetwork::getSharedNetwork(DataNode const& data_node) {
39 try {
40 if (model_ == KEA_DHCP4_SERVER) {
41 return (getSharedNetworkKea(data_node, "subnet4"));
42 } else if (model_ == KEA_DHCP6_SERVER) {
43 return (getSharedNetworkKea(data_node, "subnet6"));
44 }
45 } catch (Error const& ex) {
46 isc_throw(NetconfError,
47 "getting shared network:"
48 << ex.what());
49 }
50 isc_throw(NotImplemented,
51 "getSharedNetwork not implemented for the model: " << model_);
52}
53
54 ElementPtr
55TranslatorSharedNetwork::getSharedNetworkFromAbsoluteXpath(string const& xpath) {
56 try {
57 return getSharedNetwork(findXPath(xpath));
58 } catch (NetconfError const&) {
59 return ElementPtr();
60 }
61}
62
63 ElementPtr
64TranslatorSharedNetwork::getSharedNetworkKea(DataNode const& data_node,
65 string const& subsel) {
66 ElementPtr result = Element::createMap();
67
68 getMandatoryLeaf(result, data_node, "name");
69
70 checkAndGetLeaf(result, data_node, "allocator");
71 checkAndGetLeaf(result, data_node, "cache-max-age");
72 checkAndGetLeaf(result, data_node, "cache-threshold");
73 checkAndGetLeaf(result, data_node, "calculate-tee-times");
74 checkAndGetLeaf(result, data_node, "client-class");
75 checkAndGetLeaf(result, data_node, "client-classes");
76 checkAndGetLeaf(result, data_node, "ddns-generated-prefix");
77 checkAndGetLeaf(result, data_node, "ddns-override-client-update");
78 checkAndGetLeaf(result, data_node, "ddns-override-no-update");
79 checkAndGetLeaf(result, data_node, "ddns-qualifying-suffix");
80 checkAndGetLeaf(result, data_node, "ddns-replace-client-name");
81 checkAndGetLeaf(result, data_node, "ddns-send-updates");
82 checkAndGetLeaf(result, data_node, "ddns-ttl-percent");
83 checkAndGetLeaf(result, data_node, "ddns-ttl");
84 checkAndGetLeaf(result, data_node, "ddns-ttl-min");
85 checkAndGetLeaf(result, data_node, "ddns-ttl-max");
86 checkAndGetLeaf(result, data_node, "ddns-update-on-renew");
87 checkAndGetLeaf(result, data_node, "ddns-use-conflict-resolution");
88 checkAndGetLeaf(result, data_node, "ddns-conflict-resolution-mode");
89 checkAndGetLeaf(result, data_node, "hostname-char-replacement");
90 checkAndGetLeaf(result, data_node, "hostname-char-set");
91 checkAndGetLeaf(result, data_node, "interface");
92 checkAndGetLeaf(result, data_node, "max-valid-lifetime");
93 checkAndGetLeaf(result, data_node, "min-valid-lifetime");
94 checkAndGetLeaf(result, data_node, "rebind-timer");
95 checkAndGetLeaf(result, data_node, "renew-timer");
96 checkAndGetLeaf(result, data_node, "require-client-classes");
97 checkAndGetLeaf(result, data_node, "evaluate-additional-classes");
98 checkAndGetLeaf(result, data_node, "reservations-global");
99 checkAndGetLeaf(result, data_node, "reservations-in-subnet");
100 checkAndGetLeaf(result, data_node, "reservations-out-of-pool");
101 checkAndGetLeaf(result, data_node, "store-extended-info");
102 checkAndGetLeaf(result, data_node, "t1-percent");
103 checkAndGetLeaf(result, data_node, "t2-percent");
104 checkAndGetLeaf(result, data_node, "valid-lifetime");
105 checkAndGetLeaf(result, data_node, "adaptive-lease-time-threshold");
106
107 checkAndGetAndJsonifyLeaf(result, data_node, "user-context");
108
109 ConstElementPtr options = getOptionDataList(data_node);
110 if (options) {
111 result->set("option-data", options);
112 }
113
114 ConstElementPtr subnets = getSubnets(data_node);
115 if (subnets) {
116 result->set(subsel, subnets);
117 }
118
119 checkAndGet(result, data_node, "relay",
120 [&](DataNode const& node) -> ElementPtr const {
121 ElementPtr relay(Element::createMap());
122 checkAndGetLeaf(relay, node, "ip-addresses");
123 return relay;
124 });
125
126 if (subsel == "subnet6") {
127 checkAndGetLeaf(result, data_node, "interface-id");
128 checkAndGetLeaf(result, data_node, "max-preferred-lifetime");
129 checkAndGetLeaf(result, data_node, "min-preferred-lifetime");
130 checkAndGetLeaf(result, data_node, "pd-allocator");
131 checkAndGetLeaf(result, data_node, "preferred-lifetime");
132 checkAndGetLeaf(result, data_node, "rapid-commit");
133 } else if (subsel == "subnet4") {
134 checkAndGetLeaf(result, data_node, "authoritative");
135 checkAndGetLeaf(result, data_node, "boot-file-name");
136 checkAndGetLeaf(result, data_node, "match-client-id");
137 checkAndGetLeaf(result, data_node, "next-server");
138 checkAndGetLeaf(result, data_node, "offer-lifetime");
139 checkAndGetLeaf(result, data_node, "server-hostname");
140 }
141
142 return (result->empty() ? ElementPtr() : result);
143}
144
145void
146TranslatorSharedNetwork::setSharedNetwork(string const& xpath,
147 ConstElementPtr elem) {
148 try {
149 if (model_ == KEA_DHCP4_SERVER) {
150 setSharedNetworkKea(xpath, elem, "subnet4");
151 } else if (model_ == KEA_DHCP6_SERVER) {
152 setSharedNetworkKea(xpath, elem, "subnet6");
153 } else {
154 isc_throw(NotImplemented,
155 "setSharedNetwork not implemented for the model: "
156 << model_);
157 }
158 } catch (Error const& ex) {
159 isc_throw(NetconfError,
160 "setting shared network '" << elem->str()
161 << "' : " << ex.what());
162 }
163}
164
165void
166TranslatorSharedNetwork::setSharedNetworkKea(string const& xpath,
167 ConstElementPtr elem,
168 string const& subsel) {
169 // Set the list element. This is important in case we have no other elements except the key.
170 setItem(xpath, ElementPtr(), LeafBaseType::Unknown);
171
172 // Skip key "name" since it was set with the list element in the call above
173 // with the LeafBaseType::Unknown parameter.
174
175 checkAndSetLeaf(elem, xpath, "allocator", LeafBaseType::String);
176 checkAndSetLeaf(elem, xpath, "cache-max-age", LeafBaseType::Uint32);
177 checkAndSetLeaf(elem, xpath, "cache-threshold", LeafBaseType::Dec64);
178 checkAndSetLeaf(elem, xpath, "calculate-tee-times", LeafBaseType::Bool);
179 checkAndSetLeaf(elem, xpath, "client-class", LeafBaseType::String);
180 checkAndSetLeaf(elem, xpath, "ddns-generated-prefix", LeafBaseType::String);
181 checkAndSetLeaf(elem, xpath, "ddns-override-client-update", LeafBaseType::Bool);
182 checkAndSetLeaf(elem, xpath, "ddns-override-no-update", LeafBaseType::Bool);
183 checkAndSetLeaf(elem, xpath, "ddns-qualifying-suffix", LeafBaseType::String);
184 checkAndSetLeaf(elem, xpath, "ddns-replace-client-name", LeafBaseType::String);
185 checkAndSetLeaf(elem, xpath, "ddns-send-updates", LeafBaseType::Bool);
186 checkAndSetLeaf(elem, xpath, "ddns-ttl-percent", LeafBaseType::Dec64);
187 checkAndSetLeaf(elem, xpath, "ddns-ttl", LeafBaseType::Uint32);
188 checkAndSetLeaf(elem, xpath, "ddns-ttl-min", LeafBaseType::Uint32);
189 checkAndSetLeaf(elem, xpath, "ddns-ttl-max", LeafBaseType::Uint32);
190 checkAndSetLeaf(elem, xpath, "ddns-update-on-renew", LeafBaseType::Bool);
191 checkAndSetLeaf(elem, xpath, "ddns-use-conflict-resolution", LeafBaseType::Bool);
192 checkAndSetLeaf(elem, xpath, "ddns-conflict-resolution-mode", LeafBaseType::Enum);
193 checkAndSetLeaf(elem, xpath, "hostname-char-replacement", LeafBaseType::String);
194 checkAndSetLeaf(elem, xpath, "hostname-char-set", LeafBaseType::String);
195 checkAndSetLeaf(elem, xpath, "interface", LeafBaseType::String);
196 checkAndSetLeaf(elem, xpath, "max-valid-lifetime", LeafBaseType::Uint32);
197 checkAndSetLeaf(elem, xpath, "min-valid-lifetime", LeafBaseType::Uint32);
198 checkAndSetLeaf(elem, xpath, "rebind-timer", LeafBaseType::Uint32);
199 checkAndSetLeaf(elem, xpath, "renew-timer", LeafBaseType::Uint32);
200 checkAndSetLeaf(elem, xpath, "reservations-global", LeafBaseType::Bool);
201 checkAndSetLeaf(elem, xpath, "reservations-in-subnet", LeafBaseType::Bool);
202 checkAndSetLeaf(elem, xpath, "reservations-out-of-pool", LeafBaseType::Bool);
203 checkAndSetLeaf(elem, xpath, "store-extended-info", LeafBaseType::Bool);
204 checkAndSetLeaf(elem, xpath, "t1-percent", LeafBaseType::Dec64);
205 checkAndSetLeaf(elem, xpath, "t2-percent", LeafBaseType::Dec64);
206 checkAndSetLeaf(elem, xpath, "valid-lifetime", LeafBaseType::Uint32);
207 checkAndSetLeaf(elem, xpath, "adaptive-lease-time-threshold", LeafBaseType::Dec64);
208 checkAndSetLeafList(elem, xpath, "client-classes", LeafBaseType::String);
209 checkAndSetLeafList(elem, xpath, "require-client-classes", LeafBaseType::String);
210 checkAndSetLeafList(elem, xpath, "evaluate-additional-classes", LeafBaseType::String);
211
212 checkAndSetUserContext(elem, xpath);
213
214 ConstElementPtr relay = elem->get("relay");
215 if (relay) {
216 ConstElementPtr addresses = relay->get("ip-addresses");
217 if (addresses && !addresses->empty()) {
218 for (ElementPtr const& addr : addresses->listValue()) {
219 setItem(xpath + "/relay/ip-addresses", addr, LeafBaseType::String);
220 }
221 }
222 }
223
224 ConstElementPtr options = elem->get("option-data");
225 if (options && !options->empty()) {
226 setOptionDataList(xpath, options);
227 }
228
229 ConstElementPtr subnets = elem->get(subsel);
230 if (subnets && !subnets->empty()) {
231 setSubnets(xpath, subnets);
232 }
233
234 if (subsel == "subnet6") {
235 checkAndSetLeaf(elem, xpath, "interface-id", LeafBaseType::String);
236 checkAndSetLeaf(elem, xpath, "max-preferred-lifetime", LeafBaseType::Uint32);
237 checkAndSetLeaf(elem, xpath, "min-preferred-lifetime", LeafBaseType::Uint32);
238 checkAndSetLeaf(elem, xpath, "pd-allocator", LeafBaseType::String);
239 checkAndSetLeaf(elem, xpath, "preferred-lifetime", LeafBaseType::Uint32);
240 checkAndSetLeaf(elem, xpath, "rapid-commit", LeafBaseType::Bool);
241 } else {
242 checkAndSetLeaf(elem, xpath, "authoritative", LeafBaseType::Bool);
243 checkAndSetLeaf(elem, xpath, "boot-file-name", LeafBaseType::String);
244 checkAndSetLeaf(elem, xpath, "match-client-id", LeafBaseType::Bool);
245 checkAndSetLeaf(elem, xpath, "next-server", LeafBaseType::String);
246 checkAndSetLeaf(elem, xpath, "offer-lifetime", LeafBaseType::Uint32);
247 checkAndSetLeaf(elem, xpath, "server-hostname", LeafBaseType::String);
248 }
249}
250
251TranslatorSharedNetworks::TranslatorSharedNetworks(Session session,
252 const string& model)
253 : Translator(session, model),
254 TranslatorOptionData(session, model),
255 TranslatorOptionDataList(session, model),
256 TranslatorPool(session, model),
257 TranslatorPools(session, model),
258 TranslatorPdPool(session, model),
259 TranslatorPdPools(session, model),
260 TranslatorHost(session, model),
261 TranslatorHosts(session, model),
262 TranslatorSubnet(session, model),
263 TranslatorSubnets(session, model),
264 TranslatorSharedNetwork(session, model) {
265}
266
267 ElementPtr
268TranslatorSharedNetworks::getSharedNetworks(DataNode const& data_node) {
269 return getList<TranslatorSharedNetwork>(data_node, "shared-network", *this,
270 &TranslatorSharedNetwork::getSharedNetwork);
271}
272
273 ElementPtr
274TranslatorSharedNetworks::getSharedNetworksFromAbsoluteXpath(string const& xpath) {
275 try {
276 return getSharedNetworks(findXPath(xpath));
277 } catch (NetconfError const&) {
278 return ElementPtr();
279 }
280}
281
282void
283TranslatorSharedNetworks::setSharedNetworks(string const& xpath,
284 ConstElementPtr elem) {
285 try {
286 if ((model_ == KEA_DHCP4_SERVER) ||
287 (model_ == KEA_DHCP6_SERVER)) {
288 setSharedNetworksKea(xpath, elem);
289 } else {
290 isc_throw(NotImplemented,
291 "setSharedNetworks not implemented for the model: "
292 << model_);
293 }
294 } catch (Error const& ex) {
295 isc_throw(NetconfError,
296 "setting shared networks '" << elem->str()
297 << "' : " << ex.what());
298 }
299}
300
301void
302TranslatorSharedNetworks::setSharedNetworksKea(string const& xpath,
303 ConstElementPtr elem) {
304 for (size_t i = 0; i < elem->size(); ++i) {
305 ElementPtr network = elem->getNonConst(i);
306 if (!network->contains("name")) {
307 isc_throw(BadValue, "setSharedNetworksKea requires name: "
308 << network->str());
309 }
310 string name = network->get("name")->stringValue();
311 ostringstream key;
312 key<< xpath << "/shared-network[name='" << name << "']";
313 setSharedNetwork(key.str(), network);
314 }
315}
316
317} // namespace yang
318} // namespace isc
Element::createMap
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
Definition data.cc:354
isc::BadValue
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
Definition exceptions/exceptions.h:132
isc::Exception::what
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
Definition exceptions/exceptions.cc:32
isc::NotImplemented
A generic exception that is thrown when a function is not implemented.
Definition exceptions/exceptions.h:166
isc::yang::TranslatorHost
Translation between YANG and JSON for a single host reservation.
Definition translator_host.h:113
isc::yang::TranslatorHosts
A translator class for converting host reservations list between YANG and JSON.
Definition translator_host.h:176
isc::yang::TranslatorOptionDataList
A translator class for converting an option data list between YANG and JSON.
Definition translator_option_data.h:136
isc::yang::TranslatorOptionDataList::setOptionDataList
void setOptionDataList(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set option data list from JSON to YANG.
Definition translator_option_data.cc:152
isc::yang::TranslatorOptionDataList::getOptionDataList
isc::data::ConstElementPtr getOptionDataList(libyang::DataNode const &data_node)
Translate option data list from YANG to JSON.
Definition translator_option_data.cc:121
isc::yang::TranslatorOptionData
Option data translation between YANG and JSON.
Definition translator_option_data.h:78
isc::yang::TranslatorPdPool
Prefix delegation pool translation between YANG and JSON.
Definition translator_pd_pool.h:121
isc::yang::TranslatorPdPools
A translator class for converting a pd-pool list between YANG and JSON.
Definition translator_pd_pool.h:199
isc::yang::TranslatorPool
A translator class for converting a pool between YANG and JSON.
Definition translator_pool.h:129
isc::yang::TranslatorPools
A translator class for converting pools between YANG and JSON.
Definition translator_pool.h:213
isc::yang::TranslatorSharedNetwork::getSharedNetworkFromAbsoluteXpath
isc::data::ElementPtr getSharedNetworkFromAbsoluteXpath(std::string const &xpath)
Translate a shared network from YANG to JSON.
Definition translator_shared_network.cc:55
isc::yang::TranslatorSharedNetwork::TranslatorSharedNetwork
TranslatorSharedNetwork(sysrepo::Session session, const std::string &model)
Constructor.
Definition translator_shared_network.cc:22
isc::yang::TranslatorSharedNetwork::getSharedNetwork
isc::data::ElementPtr getSharedNetwork(libyang::DataNode const &data_node)
Translate a shared network from YANG to JSON.
Definition translator_shared_network.cc:38
isc::yang::TranslatorSharedNetwork::setSharedNetworkKea
void setSharedNetworkKea(const std::string &xpath, isc::data::ConstElementPtr elem, const std::string &subsel)
setSharedNetwork for kea-dhcp4-server and kea-dhcp6-server models
Definition translator_shared_network.cc:166
isc::yang::TranslatorSharedNetwork::getSharedNetworkKea
isc::data::ElementPtr getSharedNetworkKea(libyang::DataNode const &data_node, const std::string &subsel)
getSharedNetwork for kea-dhcp4-server and kea-dhcp6-server models
Definition translator_shared_network.cc:64
isc::yang::TranslatorSharedNetwork::setSharedNetwork
void setSharedNetwork(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set shared network from JSON to YANG.
Definition translator_shared_network.cc:146
isc::yang::TranslatorSharedNetworks::TranslatorSharedNetworks
TranslatorSharedNetworks(sysrepo::Session session, const std::string &model)
Constructor.
Definition translator_shared_network.cc:251
isc::yang::TranslatorSharedNetworks::setSharedNetworksKea
void setSharedNetworksKea(const std::string &xpath, isc::data::ConstElementPtr elem)
setSharedNetworks for kea-dhcp4-server and kea-dhcp6-server
Definition translator_shared_network.cc:302
isc::yang::TranslatorSharedNetworks::getSharedNetworks
isc::data::ElementPtr getSharedNetworks(libyang::DataNode const &data_node)
Translate shared networks from YANG to JSON.
Definition translator_shared_network.cc:268
isc::yang::TranslatorSharedNetworks::getSharedNetworksFromAbsoluteXpath
isc::data::ElementPtr getSharedNetworksFromAbsoluteXpath(std::string const &xpath)
Translate shared networks from YANG to JSON.
Definition translator_shared_network.cc:274
isc::yang::TranslatorSharedNetworks::setSharedNetworks
void setSharedNetworks(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set shared networks from JSON to YANG.
Definition translator_shared_network.cc:283
isc::yang::TranslatorSubnet
Subnet (aka network range) translation between YANG and JSON.
Definition translator_subnet.h:278
isc::yang::TranslatorSubnets
A translator class for converting a subnet list between YANG and JSON.
Definition translator_subnet.h:350
isc::yang::TranslatorSubnets::setSubnets
void setSubnets(const std::string &xpath, isc::data::ConstElementPtr elem)
Translate and set subnets from JSON to YANG.
Definition translator_subnet.cc:396
isc::yang::TranslatorSubnets::getSubnets
isc::data::ElementPtr getSubnets(libyang::DataNode const &data_node)
Get and translate subnets from YANG to JSON.
Definition translator_subnet.cc:361
isc::yang::TranslatorSubnets::TranslatorSubnets
TranslatorSubnets(sysrepo::Session session, const std::string &model)
Constructor.
Definition translator_subnet.cc:347
isc::yang::Translator
Between YANG and JSON translator class for basic values.
Definition translator.h:30
isc::yang::Translator::getList
isc::data::ElementPtr getList(libyang::DataNode const &data_node, std::string const &xpath, T &t, isc::data::ElementPtr(T::*f)(libyang::DataNode const &)) const
Retrieve a list as ElementPtr from sysrepo from a certain xpath.
Definition translator.h:281
isc::yang::Translator::checkAndSetLeaf
void checkAndSetLeaf(isc::data::ConstElementPtr const &from, std::string const &xpath, std::string const &name, libyang::LeafBaseType const type)
Get an element from given ElementPtr node and set it in sysrepo at given xpath.
Definition translator.cc:63
isc::yang::Translator::checkAndGet
void checkAndGet(isc::data::ElementPtr const &storage, libyang::DataNode const &data_node, std::string const &xpath, T translate) const
Calls {translate} for the element found at {xpath} relative to {data_node} and sets the result in {st...
Definition translator.h:51
isc::yang::Translator::findXPath
libyang::DataNode findXPath(std::string const &xpath) const
Retrieves a YANG data node by xpath.
Definition translator.cc:132
isc::yang::Translator::getMandatoryLeaf
void getMandatoryLeaf(isc::data::ElementPtr &storage, libyang::DataNode const &data_node, std::string const &name) const
Retrieves a child YANG data node identified by name from the given parent YANG container node and sto...
Definition translator.cc:197
isc::yang::Translator::checkAndGetLeaf
void checkAndGetLeaf(isc::data::ElementPtr &storage, libyang::DataNode const &data_node, std::string const &name) const
Retrieves a child YANG data node identified by name from the given parent YANG container node and sto...
Definition translator.cc:32
isc::yang::Translator::checkAndSetUserContext
void checkAndSetUserContext(isc::data::ConstElementPtr const &from, std::string const &xpath)
Get an element from given ElementPtr node and set it in sysrepo at given xpath.
Definition translator.cc:99
isc::yang::Translator::setItem
void setItem(const std::string &xpath, isc::data::ConstElementPtr const elem, libyang::LeafBaseType const type)
Translate and set basic value from JSON to YANG.
Definition translator.cc:231
isc::yang::Translator::model_
std::string model_
The model.
Definition translator.h:434
isc::yang::Translator::checkAndGetAndJsonifyLeaf
void checkAndGetAndJsonifyLeaf(isc::data::ElementPtr &storage, libyang::DataNode const &data_node, const std::string &name) const
Retrieves a child YANG data node identified by name from the given parent YANG container node,...
Definition translator.cc:53
isc::yang::Translator::checkAndSetLeafList
void checkAndSetLeafList(isc::data::ConstElementPtr const &from, std::string const &xpath, std::string const &name, libyang::LeafBaseType const type)
Get an element from given ElementPtr node and set it in sysrepo at given xpath as a leaf-list.
Definition translator.cc:86
isc_throw
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Definition exceptions/exceptions.h:210
isc::data
Definition base_stamped_element.cc:12
isc::data::ConstElementPtr
boost::shared_ptr< const Element > ConstElementPtr
Definition data.h:30
isc::data::ElementPtr
boost::shared_ptr< Element > ElementPtr
Definition data.h:29
isc::yang
Definition adaptor.cc:17
isc
Defines the logger used by the top-level component of kea-lfc.
Definition check_exists_add.cc:18
isc::yang::NetconfError
Generic NETCONF error.
Definition netconf_error.h:30
translator_shared_network.h
yang_models.h