1 // SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause)
2 /*
3  * libfdt - Flat Device Tree manipulation
4  * Copyright (C) 2006 David Gibson, IBM Corporation.
5  */
6 #include "libfdt_env.h"
7 
8 #include <fdt.h>
9 #include <libfdt.h>
10 
11 #include "libfdt_internal.h"
12 
fdt_nodename_eq_(const void * fdt,int offset,const char * s,int len)13 static int fdt_nodename_eq_(const void *fdt, int offset,
14                 const char *s, int len)
15 {
16     int olen;
17     const char *p = fdt_get_name(fdt, offset, &olen);
18 
19     if (!p || olen < len)
20         /* short match */
21         return 0;
22 
23     if (memcmp(p, s, len) != 0)
24         return 0;
25 
26     if (p[len] == '\0')
27         return 1;
28     else if (!memchr(s, '@', len) && (p[len] == '@'))
29         return 1;
30     else
31         return 0;
32 }
33 
fdt_get_string(const void * fdt,int stroffset,int * lenp)34 const char *fdt_get_string(const void *fdt, int stroffset, int *lenp)
35 {
36     int32_t totalsize;
37     uint32_t absoffset;
38     size_t len;
39     int err;
40     const char *s, *n;
41 
42     if (can_assume(VALID_INPUT)) {
43         s = (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
44 
45         if (lenp)
46             *lenp = strlen(s);
47         return s;
48     }
49     totalsize = fdt_ro_probe_(fdt);
50     err = totalsize;
51     if (totalsize < 0)
52         goto fail;
53 
54     err = -FDT_ERR_BADOFFSET;
55     absoffset = stroffset + fdt_off_dt_strings(fdt);
56     if (absoffset >= (unsigned)totalsize)
57         goto fail;
58     len = totalsize - absoffset;
59 
60     if (fdt_magic(fdt) == FDT_MAGIC) {
61         if (stroffset < 0)
62             goto fail;
63         if (can_assume(LATEST) || fdt_version(fdt) >= 17) {
64             if ((unsigned)stroffset >= fdt_size_dt_strings(fdt))
65                 goto fail;
66             if ((fdt_size_dt_strings(fdt) - stroffset) < len)
67                 len = fdt_size_dt_strings(fdt) - stroffset;
68         }
69     } else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
70         unsigned int sw_stroffset = -stroffset;
71 
72         if ((stroffset >= 0) ||
73             (sw_stroffset > fdt_size_dt_strings(fdt)))
74             goto fail;
75         if (sw_stroffset < len)
76             len = sw_stroffset;
77     } else {
78         err = -FDT_ERR_INTERNAL;
79         goto fail;
80     }
81 
82     s = (const char *)fdt + absoffset;
83     n = memchr(s, '\0', len);
84     if (!n) {
85         /* missing terminating NULL */
86         err = -FDT_ERR_TRUNCATED;
87         goto fail;
88     }
89 
90     if (lenp)
91         *lenp = n - s;
92     return s;
93 
94 fail:
95     if (lenp)
96         *lenp = err;
97     return NULL;
98 }
99 
fdt_string(const void * fdt,int stroffset)100 const char *fdt_string(const void *fdt, int stroffset)
101 {
102     return fdt_get_string(fdt, stroffset, NULL);
103 }
104 
fdt_string_eq_(const void * fdt,int stroffset,const char * s,int len)105 static int fdt_string_eq_(const void *fdt, int stroffset,
106               const char *s, int len)
107 {
108     int slen;
109     const char *p = fdt_get_string(fdt, stroffset, &slen);
110 
111     return p && (slen == len) && (memcmp(p, s, len) == 0);
112 }
113 
fdt_find_max_phandle(const void * fdt,uint32_t * phandle)114 int fdt_find_max_phandle(const void *fdt, uint32_t *phandle)
115 {
116     uint32_t max = 0;
117     int offset = -1;
118 
119     while (true) {
120         uint32_t value;
121 
122         offset = fdt_next_node(fdt, offset, NULL);
123         if (offset < 0) {
124             if (offset == -FDT_ERR_NOTFOUND)
125                 break;
126 
127             return offset;
128         }
129 
130         value = fdt_get_phandle(fdt, offset);
131 
132         if (value > max)
133             max = value;
134     }
135 
136     if (phandle)
137         *phandle = max;
138 
139     return 0;
140 }
141 
fdt_generate_phandle(const void * fdt,uint32_t * phandle)142 int fdt_generate_phandle(const void *fdt, uint32_t *phandle)
143 {
144     uint32_t max;
145     int err;
146 
147     err = fdt_find_max_phandle(fdt, &max);
148     if (err < 0)
149         return err;
150 
151     if (max == FDT_MAX_PHANDLE)
152         return -FDT_ERR_NOPHANDLES;
153 
154     if (phandle)
155         *phandle = max + 1;
156 
157     return 0;
158 }
159 
fdt_mem_rsv(const void * fdt,int n)160 static const struct fdt_reserve_entry *fdt_mem_rsv(const void *fdt, int n)
161 {
162     unsigned int offset = n * sizeof(struct fdt_reserve_entry);
163     unsigned int absoffset = fdt_off_mem_rsvmap(fdt) + offset;
164 
165     if (!can_assume(VALID_INPUT)) {
166         if (absoffset < fdt_off_mem_rsvmap(fdt))
167             return NULL;
168         if (absoffset > fdt_totalsize(fdt) -
169             sizeof(struct fdt_reserve_entry))
170             return NULL;
171     }
172     return fdt_mem_rsv_(fdt, n);
173 }
174 
fdt_get_mem_rsv(const void * fdt,int n,uint64_t * address,uint64_t * size)175 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
176 {
177     const struct fdt_reserve_entry *re;
178 
179     FDT_RO_PROBE(fdt);
180     re = fdt_mem_rsv(fdt, n);
181     if (!can_assume(VALID_INPUT) && !re)
182         return -FDT_ERR_BADOFFSET;
183 
184     *address = fdt64_ld_(&re->address);
185     *size = fdt64_ld_(&re->size);
186     return 0;
187 }
188 
fdt_num_mem_rsv(const void * fdt)189 int fdt_num_mem_rsv(const void *fdt)
190 {
191     int i;
192     const struct fdt_reserve_entry *re;
193 
194     for (i = 0; (re = fdt_mem_rsv(fdt, i)) != NULL; i++) {
195         if (fdt64_ld_(&re->size) == 0)
196             return i;
197     }
198     return -FDT_ERR_TRUNCATED;
199 }
200 
nextprop_(const void * fdt,int offset)201 static int nextprop_(const void *fdt, int offset)
202 {
203     uint32_t tag;
204     int nextoffset;
205 
206     do {
207         tag = fdt_next_tag(fdt, offset, &nextoffset);
208 
209         switch (tag) {
210         case FDT_END:
211             if (nextoffset >= 0)
212                 return -FDT_ERR_BADSTRUCTURE;
213             else
214                 return nextoffset;
215 
216         case FDT_PROP:
217             return offset;
218         }
219         offset = nextoffset;
220     } while (tag == FDT_NOP);
221 
222     return -FDT_ERR_NOTFOUND;
223 }
224 
fdt_subnode_offset_namelen(const void * fdt,int offset,const char * name,int namelen)225 int fdt_subnode_offset_namelen(const void *fdt, int offset,
226                    const char *name, int namelen)
227 {
228     int depth;
229 
230     FDT_RO_PROBE(fdt);
231 
232     for (depth = 0;
233          (offset >= 0) && (depth >= 0);
234          offset = fdt_next_node(fdt, offset, &depth))
235         if ((depth == 1)
236             && fdt_nodename_eq_(fdt, offset, name, namelen))
237             return offset;
238 
239     if (depth < 0)
240         return -FDT_ERR_NOTFOUND;
241     return offset; /* error */
242 }
243 
fdt_subnode_offset(const void * fdt,int parentoffset,const char * name)244 int fdt_subnode_offset(const void *fdt, int parentoffset,
245                const char *name)
246 {
247     return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
248 }
249 
fdt_path_offset_namelen(const void * fdt,const char * path,int namelen)250 int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
251 {
252     const char *end = path + namelen;
253     const char *p = path;
254     int offset = 0;
255 
256     FDT_RO_PROBE(fdt);
257 
258     /* see if we have an alias */
259     if (*path != '/') {
260         const char *q = memchr(path, '/', end - p);
261 
262         if (!q)
263             q = end;
264 
265         p = fdt_get_alias_namelen(fdt, p, q - p);
266         if (!p)
267             return -FDT_ERR_BADPATH;
268         offset = fdt_path_offset(fdt, p);
269 
270         p = q;
271     }
272 
273     while (p < end) {
274         const char *q;
275 
276         while (*p == '/') {
277             p++;
278             if (p == end)
279                 return offset;
280         }
281         q = memchr(p, '/', end - p);
282         if (! q)
283             q = end;
284 
285         offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
286         if (offset < 0)
287             return offset;
288 
289         p = q;
290     }
291 
292     return offset;
293 }
294 
fdt_path_offset(const void * fdt,const char * path)295 int fdt_path_offset(const void *fdt, const char *path)
296 {
297     return fdt_path_offset_namelen(fdt, path, strlen(path));
298 }
299 
fdt_get_name(const void * fdt,int nodeoffset,int * len)300 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
301 {
302     const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset);
303     const char *nameptr;
304     int err;
305 
306     if (((err = fdt_ro_probe_(fdt)) < 0)
307         || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
308             goto fail;
309 
310     nameptr = nh->name;
311 
312     if (!can_assume(LATEST) && fdt_version(fdt) < 0x10) {
313         /*
314          * For old FDT versions, match the naming conventions of V16:
315          * give only the leaf name (after all /). The actual tree
316          * contents are loosely checked.
317          */
318         const char *leaf;
319         leaf = strrchr(nameptr, '/');
320         if (leaf == NULL) {
321             err = -FDT_ERR_BADSTRUCTURE;
322             goto fail;
323         }
324         nameptr = leaf+1;
325     }
326 
327     if (len)
328         *len = strlen(nameptr);
329 
330     return nameptr;
331 
332  fail:
333     if (len)
334         *len = err;
335     return NULL;
336 }
337 
fdt_first_property_offset(const void * fdt,int nodeoffset)338 int fdt_first_property_offset(const void *fdt, int nodeoffset)
339 {
340     int offset;
341 
342     if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
343         return offset;
344 
345     return nextprop_(fdt, offset);
346 }
347 
fdt_next_property_offset(const void * fdt,int offset)348 int fdt_next_property_offset(const void *fdt, int offset)
349 {
350     if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0)
351         return offset;
352 
353     return nextprop_(fdt, offset);
354 }
355 
fdt_get_property_by_offset_(const void * fdt,int offset,int * lenp)356 static const struct fdt_property *fdt_get_property_by_offset_(const void *fdt,
357                                       int offset,
358                                       int *lenp)
359 {
360     int err;
361     const struct fdt_property *prop;
362 
363     if (!can_assume(VALID_INPUT) &&
364         (err = fdt_check_prop_offset_(fdt, offset)) < 0) {
365         if (lenp)
366             *lenp = err;
367         return NULL;
368     }
369 
370     prop = fdt_offset_ptr_(fdt, offset);
371 
372     if (lenp)
373         *lenp = fdt32_ld_(&prop->len);
374 
375     return prop;
376 }
377 
fdt_get_property_by_offset(const void * fdt,int offset,int * lenp)378 const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
379                               int offset,
380                               int *lenp)
381 {
382     /* Prior to version 16, properties may need realignment
383      * and this API does not work. fdt_getprop_*() will, however. */
384 
385     if (!can_assume(LATEST) && fdt_version(fdt) < 0x10) {
386         if (lenp)
387             *lenp = -FDT_ERR_BADVERSION;
388         return NULL;
389     }
390 
391     return fdt_get_property_by_offset_(fdt, offset, lenp);
392 }
393 
fdt_get_property_namelen_(const void * fdt,int offset,const char * name,int namelen,int * lenp,int * poffset)394 static const struct fdt_property *fdt_get_property_namelen_(const void *fdt,
395                                     int offset,
396                                     const char *name,
397                                     int namelen,
398                                 int *lenp,
399                                 int *poffset)
400 {
401     for (offset = fdt_first_property_offset(fdt, offset);
402          (offset >= 0);
403          (offset = fdt_next_property_offset(fdt, offset))) {
404         const struct fdt_property *prop;
405 
406         prop = fdt_get_property_by_offset_(fdt, offset, lenp);
407         if (!can_assume(LIBFDT_FLAWLESS) && !prop) {
408             offset = -FDT_ERR_INTERNAL;
409             break;
410         }
411         if (fdt_string_eq_(fdt, fdt32_ld_(&prop->nameoff),
412                    name, namelen)) {
413             if (poffset)
414                 *poffset = offset;
415             return prop;
416         }
417     }
418 
419     if (lenp)
420         *lenp = offset;
421     return NULL;
422 }
423 
424 
fdt_get_property_namelen(const void * fdt,int offset,const char * name,int namelen,int * lenp)425 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
426                             int offset,
427                             const char *name,
428                             int namelen, int *lenp)
429 {
430     /* Prior to version 16, properties may need realignment
431      * and this API does not work. fdt_getprop_*() will, however. */
432     if (!can_assume(LATEST) && fdt_version(fdt) < 0x10) {
433         if (lenp)
434             *lenp = -FDT_ERR_BADVERSION;
435         return NULL;
436     }
437 
438     return fdt_get_property_namelen_(fdt, offset, name, namelen, lenp,
439                      NULL);
440 }
441 
442 
fdt_get_property(const void * fdt,int nodeoffset,const char * name,int * lenp)443 const struct fdt_property *fdt_get_property(const void *fdt,
444                         int nodeoffset,
445                         const char *name, int *lenp)
446 {
447     return fdt_get_property_namelen(fdt, nodeoffset, name,
448                     strlen(name), lenp);
449 }
450 
fdt_getprop_namelen(const void * fdt,int nodeoffset,const char * name,int namelen,int * lenp)451 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
452                 const char *name, int namelen, int *lenp)
453 {
454     int poffset;
455     const struct fdt_property *prop;
456 
457     prop = fdt_get_property_namelen_(fdt, nodeoffset, name, namelen, lenp,
458                      &poffset);
459     if (!prop)
460         return NULL;
461 
462     /* Handle realignment */
463     if (!can_assume(LATEST) && fdt_version(fdt) < 0x10 &&
464         (poffset + sizeof(*prop)) % 8 && fdt32_ld_(&prop->len) >= 8)
465         return prop->data + 4;
466     return prop->data;
467 }
468 
fdt_getprop_by_offset(const void * fdt,int offset,const char ** namep,int * lenp)469 const void *fdt_getprop_by_offset(const void *fdt, int offset,
470                   const char **namep, int *lenp)
471 {
472     const struct fdt_property *prop;
473 
474     prop = fdt_get_property_by_offset_(fdt, offset, lenp);
475     if (!prop)
476         return NULL;
477     if (namep) {
478         const char *name;
479         int namelen;
480 
481         if (!can_assume(VALID_INPUT)) {
482             name = fdt_get_string(fdt, fdt32_ld_(&prop->nameoff),
483                           &namelen);
484             *namep = name;
485             if (!name) {
486                 if (lenp)
487                     *lenp = namelen;
488                 return NULL;
489             }
490         } else {
491             *namep = fdt_string(fdt, fdt32_ld_(&prop->nameoff));
492         }
493     }
494 
495     /* Handle realignment */
496     if (!can_assume(LATEST) && fdt_version(fdt) < 0x10 &&
497         (offset + sizeof(*prop)) % 8 && fdt32_ld_(&prop->len) >= 8)
498         return prop->data + 4;
499     return prop->data;
500 }
501 
fdt_getprop(const void * fdt,int nodeoffset,const char * name,int * lenp)502 const void *fdt_getprop(const void *fdt, int nodeoffset,
503             const char *name, int *lenp)
504 {
505     return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
506 }
507 
fdt_get_phandle(const void * fdt,int nodeoffset)508 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
509 {
510     const fdt32_t *php;
511     int len;
512 
513     /* FIXME: This is a bit sub-optimal, since we potentially scan
514      * over all the properties twice. */
515     php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
516     if (!php || (len != sizeof(*php))) {
517         php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
518         if (!php || (len != sizeof(*php)))
519             return 0;
520     }
521 
522     return fdt32_ld_(php);
523 }
524 
fdt_get_alias_namelen(const void * fdt,const char * name,int namelen)525 const char *fdt_get_alias_namelen(const void *fdt,
526                   const char *name, int namelen)
527 {
528     int aliasoffset;
529 
530     aliasoffset = fdt_path_offset(fdt, "/aliases");
531     if (aliasoffset < 0)
532         return NULL;
533 
534     return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
535 }
536 
fdt_get_alias(const void * fdt,const char * name)537 const char *fdt_get_alias(const void *fdt, const char *name)
538 {
539     return fdt_get_alias_namelen(fdt, name, strlen(name));
540 }
541 
fdt_get_path(const void * fdt,int nodeoffset,char * buf,int buflen)542 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
543 {
544     int pdepth = 0, p = 0;
545     int offset, depth, namelen;
546     const char *name;
547 
548     FDT_RO_PROBE(fdt);
549 
550     if (buflen < 2)
551         return -FDT_ERR_NOSPACE;
552 
553     for (offset = 0, depth = 0;
554          (offset >= 0) && (offset <= nodeoffset);
555          offset = fdt_next_node(fdt, offset, &depth)) {
556         while (pdepth > depth) {
557             do {
558                 p--;
559             } while (buf[p-1] != '/');
560             pdepth--;
561         }
562 
563         if (pdepth >= depth) {
564             name = fdt_get_name(fdt, offset, &namelen);
565             if (!name)
566                 return namelen;
567             if ((p + namelen + 1) <= buflen) {
568                 memcpy(buf + p, name, namelen);
569                 p += namelen;
570                 buf[p++] = '/';
571                 pdepth++;
572             }
573         }
574 
575         if (offset == nodeoffset) {
576             if (pdepth < (depth + 1))
577                 return -FDT_ERR_NOSPACE;
578 
579             if (p > 1) /* special case so that root path is "/", not "" */
580                 p--;
581             buf[p] = '\0';
582             return 0;
583         }
584     }
585 
586     if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
587         return -FDT_ERR_BADOFFSET;
588     else if (offset == -FDT_ERR_BADOFFSET)
589         return -FDT_ERR_BADSTRUCTURE;
590 
591     return offset; /* error from fdt_next_node() */
592 }
593 
fdt_supernode_atdepth_offset(const void * fdt,int nodeoffset,int supernodedepth,int * nodedepth)594 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
595                  int supernodedepth, int *nodedepth)
596 {
597     int offset, depth;
598     int supernodeoffset = -FDT_ERR_INTERNAL;
599 
600     FDT_RO_PROBE(fdt);
601 
602     if (supernodedepth < 0)
603         return -FDT_ERR_NOTFOUND;
604 
605     for (offset = 0, depth = 0;
606          (offset >= 0) && (offset <= nodeoffset);
607          offset = fdt_next_node(fdt, offset, &depth)) {
608         if (depth == supernodedepth)
609             supernodeoffset = offset;
610 
611         if (offset == nodeoffset) {
612             if (nodedepth)
613                 *nodedepth = depth;
614 
615             if (supernodedepth > depth)
616                 return -FDT_ERR_NOTFOUND;
617             else
618                 return supernodeoffset;
619         }
620     }
621 
622     if (!can_assume(VALID_INPUT)) {
623         if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
624             return -FDT_ERR_BADOFFSET;
625         else if (offset == -FDT_ERR_BADOFFSET)
626             return -FDT_ERR_BADSTRUCTURE;
627     }
628 
629     return offset; /* error from fdt_next_node() */
630 }
631 
fdt_node_depth(const void * fdt,int nodeoffset)632 int fdt_node_depth(const void *fdt, int nodeoffset)
633 {
634     int nodedepth;
635     int err;
636 
637     err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
638     if (err)
639         return (can_assume(LIBFDT_FLAWLESS) || err < 0) ? err :
640             -FDT_ERR_INTERNAL;
641     return nodedepth;
642 }
643 
fdt_parent_offset(const void * fdt,int nodeoffset)644 int fdt_parent_offset(const void *fdt, int nodeoffset)
645 {
646     int nodedepth = fdt_node_depth(fdt, nodeoffset);
647 
648     if (nodedepth < 0)
649         return nodedepth;
650     return fdt_supernode_atdepth_offset(fdt, nodeoffset,
651                         nodedepth - 1, NULL);
652 }
653 
fdt_node_offset_by_prop_value(const void * fdt,int startoffset,const char * propname,const void * propval,int proplen)654 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
655                   const char *propname,
656                   const void *propval, int proplen)
657 {
658     int offset;
659     const void *val;
660     int len;
661 
662     FDT_RO_PROBE(fdt);
663 
664     /* FIXME: The algorithm here is pretty horrible: we scan each
665      * property of a node in fdt_getprop(), then if that didn't
666      * find what we want, we scan over them again making our way
667      * to the next node.  Still it's the easiest to implement
668      * approach; performance can come later. */
669     for (offset = fdt_next_node(fdt, startoffset, NULL);
670          offset >= 0;
671          offset = fdt_next_node(fdt, offset, NULL)) {
672         val = fdt_getprop(fdt, offset, propname, &len);
673         if (val && (len == proplen)
674             && (memcmp(val, propval, len) == 0))
675             return offset;
676     }
677 
678     return offset; /* error from fdt_next_node() */
679 }
680 
fdt_node_offset_by_phandle(const void * fdt,uint32_t phandle)681 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
682 {
683     int offset;
684 
685     if ((phandle == 0) || (phandle == ~0U))
686         return -FDT_ERR_BADPHANDLE;
687 
688     FDT_RO_PROBE(fdt);
689 
690     /* FIXME: The algorithm here is pretty horrible: we
691      * potentially scan each property of a node in
692      * fdt_get_phandle(), then if that didn't find what
693      * we want, we scan over them again making our way to the next
694      * node.  Still it's the easiest to implement approach;
695      * performance can come later. */
696     for (offset = fdt_next_node(fdt, -1, NULL);
697          offset >= 0;
698          offset = fdt_next_node(fdt, offset, NULL)) {
699         if (fdt_get_phandle(fdt, offset) == phandle)
700             return offset;
701     }
702 
703     return offset; /* error from fdt_next_node() */
704 }
705 
fdt_stringlist_contains(const char * strlist,int listlen,const char * str)706 int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
707 {
708     int len = strlen(str);
709     const char *p;
710 
711     while (listlen >= len) {
712         if (memcmp(str, strlist, len+1) == 0)
713             return 1;
714         p = memchr(strlist, '\0', listlen);
715         if (!p)
716             return 0; /* malformed strlist.. */
717         listlen -= (p-strlist) + 1;
718         strlist = p + 1;
719     }
720     return 0;
721 }
722 
fdt_stringlist_count(const void * fdt,int nodeoffset,const char * property)723 int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
724 {
725     const char *list, *end;
726     int length, count = 0;
727 
728     list = fdt_getprop(fdt, nodeoffset, property, &length);
729     if (!list)
730         return length;
731 
732     end = list + length;
733 
734     while (list < end) {
735         length = strnlen(list, end - list) + 1;
736 
737         /* Abort if the last string isn't properly NUL-terminated. */
738         if (list + length > end)
739             return -FDT_ERR_BADVALUE;
740 
741         list += length;
742         count++;
743     }
744 
745     return count;
746 }
747 
fdt_stringlist_search(const void * fdt,int nodeoffset,const char * property,const char * string)748 int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
749               const char *string)
750 {
751     int length, len, idx = 0;
752     const char *list, *end;
753 
754     list = fdt_getprop(fdt, nodeoffset, property, &length);
755     if (!list)
756         return length;
757 
758     len = strlen(string) + 1;
759     end = list + length;
760 
761     while (list < end) {
762         length = strnlen(list, end - list) + 1;
763 
764         /* Abort if the last string isn't properly NUL-terminated. */
765         if (list + length > end)
766             return -FDT_ERR_BADVALUE;
767 
768         if (length == len && memcmp(list, string, length) == 0)
769             return idx;
770 
771         list += length;
772         idx++;
773     }
774 
775     return -FDT_ERR_NOTFOUND;
776 }
777 
fdt_stringlist_get(const void * fdt,int nodeoffset,const char * property,int idx,int * lenp)778 const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
779                    const char *property, int idx,
780                    int *lenp)
781 {
782     const char *list, *end;
783     int length;
784 
785     list = fdt_getprop(fdt, nodeoffset, property, &length);
786     if (!list) {
787         if (lenp)
788             *lenp = length;
789 
790         return NULL;
791     }
792 
793     end = list + length;
794 
795     while (list < end) {
796         length = strnlen(list, end - list) + 1;
797 
798         /* Abort if the last string isn't properly NUL-terminated. */
799         if (list + length > end) {
800             if (lenp)
801                 *lenp = -FDT_ERR_BADVALUE;
802 
803             return NULL;
804         }
805 
806         if (idx == 0) {
807             if (lenp)
808                 *lenp = length - 1;
809 
810             return list;
811         }
812 
813         list += length;
814         idx--;
815     }
816 
817     if (lenp)
818         *lenp = -FDT_ERR_NOTFOUND;
819 
820     return NULL;
821 }
822 
fdt_node_check_compatible(const void * fdt,int nodeoffset,const char * compatible)823 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
824                   const char *compatible)
825 {
826     const void *prop;
827     int len;
828 
829     prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
830     if (!prop)
831         return len;
832 
833     return !fdt_stringlist_contains(prop, len, compatible);
834 }
835 
fdt_node_offset_by_compatible(const void * fdt,int startoffset,const char * compatible)836 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
837                   const char *compatible)
838 {
839     int offset, err;
840 
841     FDT_RO_PROBE(fdt);
842 
843     /* FIXME: The algorithm here is pretty horrible: we scan each
844      * property of a node in fdt_node_check_compatible(), then if
845      * that didn't find what we want, we scan over them again
846      * making our way to the next node.  Still it's the easiest to
847      * implement approach; performance can come later. */
848     for (offset = fdt_next_node(fdt, startoffset, NULL);
849          offset >= 0;
850          offset = fdt_next_node(fdt, offset, NULL)) {
851         err = fdt_node_check_compatible(fdt, offset, compatible);
852         if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
853             return err;
854         else if (err == 0)
855             return offset;
856     }
857 
858     return offset; /* error from fdt_next_node() */
859 }
860