chiark / gitweb /
libudev: list - use bit flags for 'sort' and 'unique'
[elogind.git] / libudev / libudev-list.c
1 /*
2  * libudev - interface to udev device information
3  *
4  * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  */
11
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <stddef.h>
15 #include <unistd.h>
16 #include <errno.h>
17 #include <string.h>
18
19 #include "libudev.h"
20 #include "libudev-private.h"
21
22 /**
23  * SECTION:libudev-list
24  * @short_description: list operation
25  *
26  * Libudev list operations.
27  */
28
29 /**
30  * udev_list_entry:
31  *
32  * Opaque object representing one entry in a list. An entry contains
33  * contains a name, and optionally a value.
34  */
35 struct udev_list_entry {
36         struct udev_list_node node;
37         struct udev *udev;
38         struct udev_list_node *list;
39         char *name;
40         char *value;
41         int num;
42 };
43
44 /* the list's head points to itself if empty */
45 void udev_list_init(struct udev_list_node *list)
46 {
47         list->next = list;
48         list->prev = list;
49 }
50
51 int udev_list_is_empty(struct udev_list_node *list)
52 {
53         return list->next == list;
54 }
55
56 static void udev_list_node_insert_between(struct udev_list_node *new,
57                                           struct udev_list_node *prev,
58                                           struct udev_list_node *next)
59 {
60         next->prev = new;
61         new->next = next;
62         new->prev = prev;
63         prev->next = new;
64 }
65
66 void udev_list_node_append(struct udev_list_node *new, struct udev_list_node *list)
67 {
68         udev_list_node_insert_between(new, list->prev, list);
69 }
70
71 void udev_list_node_remove(struct udev_list_node *entry)
72 {
73         struct udev_list_node *prev = entry->prev;
74         struct udev_list_node *next = entry->next;
75
76         next->prev = prev;
77         prev->next = next;
78
79         entry->prev = NULL;
80         entry->next = NULL;
81 }
82
83 /* return list entry which embeds this node */
84 static struct udev_list_entry *list_node_to_entry(struct udev_list_node *node)
85 {
86         char *list;
87
88         list = (char *)node;
89         list -= offsetof(struct udev_list_entry, node);
90         return (struct udev_list_entry *)list;
91 }
92
93 /* insert entry into a list as the last element  */
94 void udev_list_entry_append(struct udev_list_entry *new, struct udev_list_node *list)
95 {
96         /* inserting before the list head make the node the last node in the list */
97         udev_list_node_insert_between(&new->node, list->prev, list);
98         new->list = list;
99 }
100
101 /* remove entry from a list */
102 void udev_list_entry_remove(struct udev_list_entry *entry)
103 {
104         udev_list_node_remove(&entry->node);
105         entry->list = NULL;
106 }
107
108 /* insert entry into a list, before a given existing entry */
109 void udev_list_entry_insert_before(struct udev_list_entry *new, struct udev_list_entry *entry)
110 {
111         udev_list_node_insert_between(&new->node, entry->node.prev, &entry->node);
112         new->list = entry->list;
113 }
114
115 struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_node *list,
116                                             const char *name, const char *value,
117                                             unsigned int flags)
118 {
119         struct udev_list_entry *entry_loop = NULL;
120         struct udev_list_entry *entry_new;
121
122         if (flags & UDEV_LIST_UNIQUE) {
123                 udev_list_entry_foreach(entry_loop, udev_list_get_entry(list)) {
124                         if (strcmp(entry_loop->name, name) == 0) {
125                                 dbg(udev, "'%s' is already in the list\n", name);
126                                 free(entry_loop->value);
127                                 if (value == NULL) {
128                                         entry_loop->value = NULL;
129                                         dbg(udev, "'%s' value unset\n", name);
130                                         return entry_loop;
131                                 }
132                                 entry_loop->value = strdup(value);
133                                 if (entry_loop->value == NULL)
134                                         return NULL;
135                                 dbg(udev, "'%s' value replaced with '%s'\n", name, value);
136                                 return entry_loop;
137                         }
138                 }
139         }
140
141         if (flags & UDEV_LIST_SORT) {
142                 udev_list_entry_foreach(entry_loop, udev_list_get_entry(list)) {
143                         if (strcmp(entry_loop->name, name) > 0)
144                                 break;
145                 }
146         }
147
148         entry_new = malloc(sizeof(struct udev_list_entry));
149         if (entry_new == NULL)
150                 return NULL;
151         memset(entry_new, 0x00, sizeof(struct udev_list_entry));
152         entry_new->udev = udev;
153         entry_new->name = strdup(name);
154         if (entry_new->name == NULL) {
155                 free(entry_new);
156                 return NULL;
157         }
158
159         if (value != NULL) {
160                 entry_new->value = strdup(value);
161                 if (entry_new->value == NULL) {
162                         free(entry_new->name);
163                         free(entry_new);
164                         return NULL;
165                 }
166         }
167
168         if (entry_loop != NULL)
169                 udev_list_entry_insert_before(entry_new, entry_loop);
170         else
171                 udev_list_entry_append(entry_new, list);
172
173         dbg(udev, "'%s=%s' added\n", entry_new->name, entry_new->value);
174         return entry_new;
175 }
176
177 void udev_list_entry_delete(struct udev_list_entry *entry)
178 {
179         udev_list_node_remove(&entry->node);
180         free(entry->name);
181         free(entry->value);
182         free(entry);
183 }
184
185 void udev_list_cleanup_entries(struct udev *udev, struct udev_list_node *list)
186 {
187         struct udev_list_entry *entry_loop;
188         struct udev_list_entry *entry_tmp;
189
190         udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(list))
191                 udev_list_entry_delete(entry_loop);
192 }
193
194 struct udev_list_entry *udev_list_get_entry(struct udev_list_node *list)
195 {
196         if (udev_list_is_empty(list))
197                 return NULL;
198         return list_node_to_entry(list->next);
199 }
200
201 /**
202  * udev_list_entry_get_next:
203  * @list_entry: current entry
204  *
205  * Returns: the next entry from the list, #NULL is no more entries are found.
206  */
207 struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry)
208 {
209         struct udev_list_node *next;
210
211         if (list_entry == NULL)
212                 return NULL;
213         next = list_entry->node.next;
214         /* empty list or no more entries */
215         if (next == list_entry->list)
216                 return NULL;
217         return list_node_to_entry(next);
218 }
219
220 /**
221  * udev_list_entry_get_by_name:
222  * @list_entry: current entry
223  * @name: name string to match
224  *
225  * Returns: the entry where @name matched, #NULL if no matching entry is found.
226  */
227 struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_entry *list_entry, const char *name)
228 {
229         struct udev_list_entry *entry;
230
231         udev_list_entry_foreach(entry, list_entry) {
232                 if (strcmp(udev_list_entry_get_name(entry), name) == 0) {
233                         dbg(entry->udev, "found '%s=%s'\n", entry->name, entry->value);
234                         return entry;
235                 }
236         }
237         return NULL;
238 }
239
240 /**
241  * udev_list_entry_get_name:
242  * @list_entry: current entry
243  *
244  * Returns: the name string of this entry.
245  */
246 const char *udev_list_entry_get_name(struct udev_list_entry *list_entry)
247 {
248         if (list_entry == NULL)
249                 return NULL;
250         return list_entry->name;
251 }
252
253 /**
254  * udev_list_entry_get_value:
255  * @list_entry: current entry
256  *
257  * Returns: the value string of this entry.
258  */
259 const char *udev_list_entry_get_value(struct udev_list_entry *list_entry)
260 {
261         if (list_entry == NULL)
262                 return NULL;
263         return list_entry->value;
264 }
265
266 int udev_list_entry_get_num(struct udev_list_entry *list_entry)
267 {
268         if (list_entry == NULL)
269                 return -EINVAL;
270         return list_entry->num;
271 }
272
273 void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num)
274 {
275         if (list_entry == NULL)
276                 return;
277         list_entry->num = num;
278 }