• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/ubus/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, *tmp;
 24 
 25         if (--type->refcount > 0)
 26                 return;
 27 
 28         list_for_each_entry_safe(m, tmp, &type->methods, list) {
 29                 list_del(&m->list);
 30                 free(m);
 31         }
 32 
 33         ubus_free_id(&obj_types, &type->id);
 34         free(type);
 35 }
 36 
 37 static bool ubus_create_obj_method(struct ubus_object_type *type, struct blob_attr *attr)
 38 {
 39         struct ubus_method *m;
 40         size_t bloblen = blob_raw_len(attr);
 41 
 42         m = calloc(1, sizeof(*m) + bloblen);
 43         if (!m)
 44                 return false;
 45 
 46         list_add_tail(&m->list, &type->methods);
 47         memcpy(m->data, attr, bloblen);
 48         m->name = blobmsg_name(m->data);
 49 
 50         return true;
 51 }
 52 
 53 static struct ubus_object_type *ubus_create_obj_type(struct blob_attr *sig)
 54 {
 55         struct ubus_object_type *type;
 56         struct blob_attr *pos;
 57         size_t rem;
 58 
 59         type = calloc(1, sizeof(*type));
 60         if (!type)
 61                 return NULL;
 62 
 63         type->refcount = 1;
 64 
 65         if (!ubus_alloc_id(&obj_types, &type->id, 0))
 66                 goto error_free;
 67 
 68         INIT_LIST_HEAD(&type->methods);
 69 
 70         blob_for_each_attr(pos, sig, rem) {
 71                 if (!blobmsg_check_attr(pos, true))
 72                         goto error_unref;
 73 
 74                 if (!ubus_create_obj_method(type, pos))
 75                         goto error_unref;
 76         }
 77 
 78         return type;
 79 
 80 error_unref:
 81         ubus_unref_object_type(type);
 82         return NULL;
 83 
 84 error_free:
 85         free(type);
 86         return NULL;
 87 }
 88 
 89 static struct ubus_object_type *ubus_get_obj_type(uint32_t obj_id)
 90 {
 91         struct ubus_object_type *type;
 92         struct ubus_id *id;
 93 
 94         id = ubus_find_id(&obj_types, obj_id);
 95         if (!id)
 96                 return NULL;
 97 
 98         type = container_of(id, struct ubus_object_type, id);
 99         type->refcount++;
100         return type;
101 }
102 
103 struct ubus_object *ubusd_create_object_internal(struct ubus_object_type *type, uint32_t id)
104 {
105         struct ubus_object *obj;
106 
107         obj = calloc(1, sizeof(*obj));
108         if (!obj)
109                 return NULL;
110 
111         if (!ubus_alloc_id(&objects, &obj->id, id))
112                 goto error_free;
113 
114         obj->type = type;
115         INIT_LIST_HEAD(&obj->list);
116         INIT_LIST_HEAD(&obj->events);
117         INIT_LIST_HEAD(&obj->subscribers);
118         INIT_LIST_HEAD(&obj->target_list);
119         if (type)
120                 type->refcount++;
121 
122         return obj;
123 
124 error_free:
125         free(obj);
126         return NULL;
127 }
128 
129 struct ubus_object *ubusd_create_object(struct ubus_client *cl, struct blob_attr **attr)
130 {
131         struct ubus_object *obj;
132         struct ubus_object_type *type = NULL;
133 
134         if (attr[UBUS_ATTR_OBJTYPE])
135                 type = ubus_get_obj_type(blob_get_u32(attr[UBUS_ATTR_OBJTYPE]));
136         else if (attr[UBUS_ATTR_SIGNATURE])
137                 type = ubus_create_obj_type(attr[UBUS_ATTR_SIGNATURE]);
138 
139         obj = ubusd_create_object_internal(type, 0);
140         if (type)
141                 ubus_unref_object_type(type);
142 
143         if (!obj)
144                 return NULL;
145 
146         if (attr[UBUS_ATTR_OBJPATH]) {
147                 if (ubusd_acl_check(cl, blob_data(attr[UBUS_ATTR_OBJPATH]), NULL, UBUS_ACL_PUBLISH))
148                         goto free;
149 
150                 obj->path.key = strdup(blob_data(attr[UBUS_ATTR_OBJPATH]));
151                 if (!obj->path.key)
152                         goto free;
153 
154                 if (avl_insert(&path, &obj->path) != 0) {
155                         free((void *) obj->path.key);
156                         obj->path.key = NULL;
157                         goto free;
158                 }
159                 ubusd_send_obj_event(obj, true);
160         }
161 
162         obj->client = cl;
163         list_add(&obj->list, &cl->objects);
164 
165         return obj;
166 
167 free:
168         ubusd_free_object(obj);
169         return NULL;
170 }
171 
172 int ubus_subscribe(struct ubus_object *obj, struct ubus_object *target)
173 {
174         struct ubus_subscription *s;
175         bool first = list_empty(&target->subscribers);
176 
177         s = calloc(1, sizeof(*s));
178         if (!s)
179                 return UBUS_STATUS_NO_MEMORY;
180 
181         s->subscriber = obj;
182         s->target = target;
183         list_add(&s->list, &target->subscribers);
184         list_add(&s->target_list, &obj->target_list);
185 
186         if (first)
187                 ubus_notify_subscription(target);
188 
189         return 0;
190 }
191 
192 void ubus_unsubscribe(struct ubus_subscription *s)
193 {
194         struct ubus_object *obj = s->target;
195 
196         list_del(&s->list);
197         list_del(&s->target_list);
198         free(s);
199 
200         if (list_empty(&obj->subscribers))
201                 ubus_notify_subscription(obj);
202 }
203 
204 void ubusd_free_object(struct ubus_object *obj)
205 {
206         struct ubus_subscription *s, *tmp;
207 
208         list_for_each_entry_safe(s, tmp, &obj->target_list, target_list) {
209                 ubus_unsubscribe(s);
210         }
211         list_for_each_entry_safe(s, tmp, &obj->subscribers, list) {
212                 ubus_notify_unsubscribe(s);
213         }
214 
215         ubusd_event_cleanup_object(obj);
216         if (obj->path.key) {
217                 ubusd_send_obj_event(obj, false);
218                 avl_delete(&path, &obj->path);
219                 free((void *) obj->path.key);
220         }
221         if (!list_empty(&obj->list))
222                 list_del(&obj->list);
223         ubus_free_id(&objects, &obj->id);
224         if (obj->type)
225                 ubus_unref_object_type(obj->type);
226         free(obj);
227 }
228 
229 static void __constructor ubusd_obj_init(void)
230 {
231         ubus_init_id_tree(&objects);
232         ubus_init_id_tree(&obj_types);
233         ubus_init_string_tree(&path, false);
234         ubusd_event_init();
235         ubusd_acl_init();
236         ubusd_monitor_init();
237 }
238 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt