remove obseleted validation of key
[project/ubus.git] / ubusd_obj.c
1 /*
2  * Copyright (C) 2011 Felix Fietkau <nbd@openwrt.org>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License version 2.1
6  * as published by the Free Software Foundation
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  */
13
14 #include "ubusd.h"
15 #include "ubusd_obj.h"
16
17 struct avl_tree obj_types;
18 struct avl_tree objects;
19 struct avl_tree path;
20
21 static void ubus_unref_object_type(struct ubus_object_type *type)
22 {
23         struct ubus_method *m;
24
25         if (--type->refcount > 0)
26                 return;
27
28         while (!list_empty(&type->methods)) {
29                 m = list_first_entry(&type->methods, struct ubus_method, list);
30                 list_del(&m->list);
31                 free(m);
32         }
33
34         ubus_free_id(&obj_types, &type->id);
35         free(type);
36 }
37
38 static bool ubus_create_obj_method(struct ubus_object_type *type, struct blob_attr *attr)
39 {
40         struct ubus_method *m;
41         int bloblen = blob_raw_len(attr);
42
43         m = calloc(1, sizeof(*m) + bloblen);
44         if (!m)
45                 return false;
46
47         list_add_tail(&m->list, &type->methods);
48         memcpy(m->data, attr, bloblen);
49         m->name = blobmsg_name(m->data);
50
51         return true;
52 }
53
54 static struct ubus_object_type *ubus_create_obj_type(struct blob_attr *sig)
55 {
56         struct ubus_object_type *type;
57         struct blob_attr *pos;
58         int rem;
59
60         type = calloc(1, sizeof(*type));
61         if (!type)
62                 return NULL;
63
64         type->refcount = 1;
65
66         if (!ubus_alloc_id(&obj_types, &type->id, 0))
67                 goto error_free;
68
69         INIT_LIST_HEAD(&type->methods);
70
71         blob_for_each_attr(pos, sig, rem) {
72                 if (!blobmsg_check_attr(pos, true))
73                         goto error_unref;
74
75                 if (!ubus_create_obj_method(type, pos))
76                         goto error_unref;
77         }
78
79         return type;
80
81 error_unref:
82         ubus_unref_object_type(type);
83         return NULL;
84
85 error_free:
86         free(type);
87         return NULL;
88 }
89
90 static struct ubus_object_type *ubus_get_obj_type(uint32_t obj_id)
91 {
92         struct ubus_object_type *type;
93         struct ubus_id *id;
94
95         id = ubus_find_id(&obj_types, obj_id);
96         if (!id)
97                 return NULL;
98
99         type = container_of(id, struct ubus_object_type, id);
100         type->refcount++;
101         return type;
102 }
103
104 struct ubus_object *ubusd_create_object_internal(struct ubus_object_type *type, uint32_t id)
105 {
106         struct ubus_object *obj;
107
108         obj = calloc(1, sizeof(*obj));
109         if (!obj)
110                 return NULL;
111
112         if (!ubus_alloc_id(&objects, &obj->id, id))
113                 goto error_free;
114
115         obj->type = type;
116         INIT_LIST_HEAD(&obj->list);
117         INIT_LIST_HEAD(&obj->events);
118         INIT_LIST_HEAD(&obj->subscribers);
119         INIT_LIST_HEAD(&obj->target_list);
120         if (type)
121                 type->refcount++;
122
123         return obj;
124
125 error_free:
126         free(obj);
127         return NULL;
128 }
129
130 struct ubus_object *ubusd_create_object(struct ubus_client *cl, struct blob_attr **attr)
131 {
132         struct ubus_object *obj;
133         struct ubus_object_type *type = NULL;
134
135         if (attr[UBUS_ATTR_OBJTYPE])
136                 type = ubus_get_obj_type(blob_get_u32(attr[UBUS_ATTR_OBJTYPE]));
137         else if (attr[UBUS_ATTR_SIGNATURE])
138                 type = ubus_create_obj_type(attr[UBUS_ATTR_SIGNATURE]);
139
140         obj = ubusd_create_object_internal(type, 0);
141         if (type)
142                 ubus_unref_object_type(type);
143
144         if (!obj)
145                 return NULL;
146
147         if (attr[UBUS_ATTR_OBJPATH]) {
148                 obj->path.key = strdup(blob_data(attr[UBUS_ATTR_OBJPATH]));
149                 if (!obj->path.key)
150                         goto free;
151
152                 if (avl_insert(&path, &obj->path) != 0) {
153                         free((void *) obj->path.key);
154                         obj->path.key = NULL;
155                         goto free;
156                 }
157                 ubusd_send_obj_event(obj, true);
158         }
159
160         obj->client = cl;
161         list_add(&obj->list, &cl->objects);
162
163         return obj;
164
165 free:
166         ubusd_free_object(obj);
167         return NULL;
168 }
169
170 void ubus_subscribe(struct ubus_object *obj, struct ubus_object *target)
171 {
172         struct ubus_subscription *s;
173         bool first = list_empty(&target->subscribers);
174
175         s = calloc(1, sizeof(*s));
176         if (!s)
177                 return;
178
179         s->subscriber = obj;
180         s->target = target;
181         list_add(&s->list, &target->subscribers);
182         list_add(&s->target_list, &obj->target_list);
183
184         if (first)
185                 ubus_notify_subscription(target);
186 }
187
188 void ubus_unsubscribe(struct ubus_subscription *s)
189 {
190         struct ubus_object *obj = s->target;
191
192         list_del(&s->list);
193         list_del(&s->target_list);
194         free(s);
195
196         if (list_empty(&obj->subscribers))
197                 ubus_notify_subscription(obj);
198 }
199
200 void ubusd_free_object(struct ubus_object *obj)
201 {
202         struct ubus_subscription *s, *tmp;
203
204         list_for_each_entry_safe(s, tmp, &obj->target_list, target_list) {
205                 ubus_unsubscribe(s);
206         }
207         list_for_each_entry_safe(s, tmp, &obj->subscribers, list) {
208                 ubus_notify_unsubscribe(s);
209         }
210
211         ubusd_event_cleanup_object(obj);
212         if (obj->path.key) {
213                 ubusd_send_obj_event(obj, false);
214                 avl_delete(&path, &obj->path);
215                 free((void *) obj->path.key);
216         }
217         if (!list_empty(&obj->list))
218                 list_del(&obj->list);
219         ubus_free_id(&objects, &obj->id);
220         if (obj->type)
221                 ubus_unref_object_type(obj->type);
222         free(obj);
223 }
224
225 static void __constructor ubusd_obj_init(void)
226 {
227         ubus_init_id_tree(&objects);
228         ubus_init_id_tree(&obj_types);
229         ubus_init_string_tree(&path, false);
230         ubusd_event_init();
231 }