dutil.c

   1 /*
   2   SPDX-License-Identifier: GPL-2.0-only
   3
   4   Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
   5 */
   6
   7
   8 #include "dutil.h"
   9
  10 #include <ctype.h>
  11 #include <errno.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16 void *zalloc(size_t size)
  17 {
  18         return calloc(1, size);
  19 }
  20
  21 void __zfree(void **ptr)
  22 {
  23         free(*ptr);
  24         *ptr = NULL;
  25 }
  26
  27 struct str_node *str_node__new(const char *s, bool dupstr)
  28 {
  29         struct str_node *snode = malloc(sizeof(*snode));
  30
  31         if (snode != NULL){
  32                 if (dupstr) {
  33                         s = strdup(s);
  34                         if (s == NULL)
  35                                 goto out_delete;
  36                 }
  37                 snode->s = s;
  38         }
  39
  40         return snode;
  41
  42 out_delete:
  43         free(snode);
  44         return NULL;
  45 }
  46
  47 static void str_node__delete(struct str_node *snode, bool dupstr)
  48 {
  49         if (snode == NULL)
  50                 return;
  51
  52         if (dupstr)
  53                 zfree(&snode->s);
  54         free(snode);
  55 }
  56
  57 int __strlist__add(struct strlist *slist, const char *new_entry, void *priv)
  58 {
  59         struct rb_node **p = &slist->entries.rb_node;
  60         struct rb_node *parent = NULL;
  61         struct str_node *sn;
  62
  63         while (*p != NULL) {
  64                 int rc;
  65
  66                 parent = *p;
  67                 sn = rb_entry(parent, struct str_node, rb_node);
  68                 rc = strcmp(sn->s, new_entry);
  69
  70                 if (rc > 0)
  71                         p = &(*p)->rb_left;
  72                 else if (rc < 0)
  73                         p = &(*p)->rb_right;
  74                 else
  75                         return -EEXIST;
  76         }
  77
  78         sn = str_node__new(new_entry, slist->dupstr);
  79         if (sn == NULL)
  80                 return -ENOMEM;
  81
  82         rb_link_node(&sn->rb_node, parent, p);
  83         rb_insert_color(&sn->rb_node, &slist->entries);
  84
  85         sn->priv = priv;
  86
  87         list_add_tail(&sn->node, &slist->list_entries);
  88
  89         return 0;
  90 }
  91
  92 int strlist__add(struct strlist *slist, const char *new_entry)
  93 {
  94         return __strlist__add(slist, new_entry, NULL);
  95 }
  96
  97 int strlist__load(struct strlist *slist, const char *filename)
  98 {
  99         char entry[1024];
 100         int err = -1;
 101         FILE *fp = fopen(filename, "r");
 102
 103         if (fp == NULL)
 104                 return -1;
 105
 106         while (fgets(entry, sizeof(entry), fp) != NULL) {
 107                 const size_t len = strlen(entry);
 108
 109                 if (len == 0)
 110                         continue;
 111                 entry[len - 1] = '\0';
 112
 113                 if (strlist__add(slist, entry) != 0)
 114                         goto out;
 115         }
 116
 117         err = 0;
 118 out:
 119         fclose(fp);
 120         return err;
 121 }
 122
 123 struct strlist *strlist__new(bool dupstr)
 124 {
 125         struct strlist *slist = malloc(sizeof(*slist));
 126
 127         if (slist != NULL) {
 128                 slist->entries = RB_ROOT;
 129                 INIT_LIST_HEAD(&slist->list_entries);
 130                 slist->dupstr = dupstr;
 131         }
 132
 133         return slist;
 134 }
 135
 136 void strlist__delete(struct strlist *slist)
 137 {
 138         if (slist != NULL) {
 139                 struct str_node *pos;
 140                 struct rb_node *next = rb_first(&slist->entries);
 141
 142                 while (next) {
 143                         pos = rb_entry(next, struct str_node, rb_node);
 144                         next = rb_next(&pos->rb_node);
 145                         strlist__remove(slist, pos);
 146                 }
 147                 slist->entries = RB_ROOT;
 148                 free(slist);
 149         }
 150 }
 151
 152 void strlist__remove(struct strlist *slist, struct str_node *sn)
 153 {
 154         rb_erase(&sn->rb_node, &slist->entries);
 155         list_del_init(&sn->node);
 156         str_node__delete(sn, slist->dupstr);
 157 }
 158
 159 bool strlist__has_entry(struct strlist *slist, const char *entry)
 160 {
 161         struct rb_node **p = &slist->entries.rb_node;
 162         struct rb_node *parent = NULL;
 163
 164         while (*p != NULL) {
 165                 struct str_node *sn;
 166                 int rc;
 167
 168                 parent = *p;
 169                 sn = rb_entry(parent, struct str_node, rb_node);
 170                 rc = strcmp(sn->s, entry);
 171
 172                 if (rc > 0)
 173                         p = &(*p)->rb_left;
 174                 else if (rc < 0)
 175                         p = &(*p)->rb_right;
 176                 else
 177                         return true;
 178         }
 179
 180         return false;
 181 }
 182
 183 Elf_Scn *elf_section_by_name(Elf *elf, GElf_Shdr *shp, const char *name, size_t *index)
 184 {
 185         Elf_Scn *sec = NULL;
 186         size_t cnt = 1;
 187         size_t str_idx;
 188
 189         if (elf_getshdrstrndx(elf, &str_idx))
 190                 return NULL;
 191
 192         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 193                 char *str;
 194
 195                 gelf_getshdr(sec, shp);
 196                 str = elf_strptr(elf, str_idx, shp->sh_name);
 197                 if (!str)
 198                         return NULL;
 199                 if (!strcmp(name, str)) {
 200                         if (index)
 201                                 *index = cnt;
 202                         break;
 203                 }
 204                 ++cnt;
 205         }
 206
 207         return sec;
 208 }
 209
 210 Elf_Scn *elf_section_by_idx(Elf *elf, GElf_Shdr *shp, int idx, const char **name_out)
 211 {
 212         Elf_Scn *sec;
 213         size_t str_idx;
 214
 215         sec = elf_getscn(elf, idx);
 216         if (!sec)
 217                 return NULL;
 218         if (!gelf_getshdr(sec, shp))
 219                 return NULL;
 220         if (name_out) {
 221                 if (elf_getshdrstrndx(elf, &str_idx))
 222                         return NULL;
 223                 *name_out = elf_strptr(elf, str_idx, shp->sh_name);
 224         }
 225         return sec;
 226 }
 227
 228 char *strlwr(char *s)
 229 {
 230         int len = strlen(s), i;
 231
 232         for (i = 0; i < len; ++i)
 233                 s[i] = tolower(s[i]);
 234
 235         return s;
 236 }