15     def __init__(self, inputfile: str, outputfile=None):  argument
17             self.tree = Devicetree.parseFile(inputfile)
22         self.output = outputfile
23         self.input = inputfile
24         self.has_root = False
27         certs = self.get_all_certificates()
29             if self.if_root(c):
33     def print_cert_info(self, node:Node):  argument
35         sign_key = self.get_sign_key(node)
36         nv = self.get_nv_ctr(node)
39 …          .format(node.name, img_id, "<b>root-certificate</b><br>" if self.if_root(node) else "", \
40 …              "<b>signing-key:</b> " + self.extract_label(sign_key) + "<br>" if sign_key else "", \
41                      "<b>nv counter:</b> " + self.extract_label(nv) + "<br>" if nv else "")
44     def print_data_info(self, node:Node):  argument
51     def print_img_info(self, node:Node):  argument
52         hash = self.extract_label(node.get_fields("hash"))
59     def tree_width(self, parent_set, root):  argument
76     def resolve_lay(self, parent_set, lay, name_idx, root, bounds, break_name):  argument
85             w = self.tree_width(parent_set, c)
99             self.resolve_lay(parent_set, lay, name_idx, c, new_bounds, break_name)
101     def tree_visualization(self):  argument
106         cert = self.get_certificates()
107         pk = self.get_rot_keys()
108         nv = self.get_nv_counters()
109         image = self.get_images()
157                 detail.append(self.print_data_info(p))
165             detail.append(self.print_cert_info(c))
167             if self.if_root(c):
172                 parent = self.extract_label(c.get_fields("parent"))
179             detail.append(self.print_img_info(i))
180             parent = self.extract_label(i.get_fields("parent"))
188             detail.append(self.print_data_info(n))
195         self.resolve_lay(parent_set, lay, name_idx, root_name, [-3, 3], break_name)
289     def if_root(self, node:Node) -> bool:  argument
295     def get_sign_key(self, node:Node):  argument
302     def get_nv_ctr(self, node:Node):  argument
309     def extract_label(self, label) -> str:  argument
314     def get_auth_data(self, node:Node):  argument
317     def format_auth_data_val(self, node:Node, cert:Node):  argument
325         if not self.if_root(cert) and "key_cert" in cert.name:
331     def get_node(self, nodes: List[Node], name: str) -> Node:  argument
336     def get_certificates(self) -> Node:  argument
337         children = self.tree.children
340                 return self.get_node(i.children, "manifests")
342     def get_images(self)-> Node:  argument
343         children = self.tree.children
346                 return self.get_node(i.children, "images")
348     def get_nv_counters(self) -> Node:  argument
349         children = self.tree.children
350         return self.get_node(children, "non_volatile_counters")
352     def get_rot_keys(self) -> Node:  argument
353         children = self.tree.children
354         return self.get_node(children, "rot_keys")
356     def get_all_certificates(self) -> Node:  argument
357         cert = self.get_certificates()
360     def get_all_images(self) -> Node:  argument
361         image = self.get_images()
364     def get_all_nv_counters(self) -> Node:  argument
365         nv = self.get_nv_counters()
368     def get_all_pks(self) -> Node:  argument
369         pk = self.get_rot_keys()
374     def validate_cert(self, node:Node) -> bool:  argument
386                 certs = self.get_all_certificates()
389                     if c.name == self.extract_label(node.get_fields("parent")):
397             self.has_root = True
408     def validate_img(self, node:Node) -> bool:  argument
423         certs = self.get_all_certificates()
426             if c.name == self.extract_label(node.get_fields("parent")):
435     def validate_nodes(self) -> bool:  argument
438         certs = self.get_all_certificates()
439         images = self.get_all_images()
442             node_valid = self.validate_cert(n)
446             node_valid = self.validate_img(i)
449         if not self.has_root:
454     def include_to_c(self, f):  argument
462     def generate_header(self, output):  argument
463         self.include_to_c(output)
465     def all_cert_to_c(self, f):  argument
466         certs = self.get_all_certificates()
468             self.cert_to_c(c, f)
472     def cert_to_c(self, node: Node, f):  argument
479         if not self.if_root(node):
486         sign = self.get_sign_key(node)
487         nv_ctr = self.get_nv_ctr(node)
497             f.write("\t\t\t\t.pk = &{},\n".format(self.extract_label(sign)))
509             f.write("\t\t\t\t.cert_nv_ctr = &{},\n".format(self.extract_label(nv_ctr)))
510             f.write("\t\t\t\t.plat_nv_ctr = &{}\n".format(self.extract_label(nv_ctr)))
517         auth_data = self.get_auth_data(node)
522                 type_desc, ptr, data_len = self.format_auth_data_val(d, node)
542     def img_to_c(self, node:Node, f):  argument
566     def all_img_to_c(self, f):  argument
567         images = self.get_all_images()
569             self.img_to_c(i, f)
573     def nv_to_c(self, f):  argument
574         nv_ctr = self.get_all_nv_counters()
586     def pk_to_c(self, f):  argument
587         pks = self.get_all_pks()
598     def buf_to_c(self, f):  argument
599         certs = self.get_all_certificates()
604             auth_data = self.get_auth_data(c)
607                 type_desc, ptr, data_len = self.format_auth_data_val(a, c)
615     def param_to_c(self, f):  argument
622         certs = self.get_all_certificates()
639     def cot_to_c(self, f):  argument
640         certs = self.get_all_certificates()
641         images = self.get_all_images()
659     def generate_c_file(self):  argument
660         filename = Path(self.output)
663         with open(self.output, 'w+') as output:
664             self.generate_header(output)
665             self.buf_to_c(output)
666             self.param_to_c(output)
667             self.nv_to_c(output)
668             self.pk_to_c(output)
669             self.all_cert_to_c(output)
670             self.all_img_to_c(output)
671             self.cot_to_c(output)