015b571501bb82ac539012d182567f75044f7cc7
[project/uhttpd.git] / ubus.c
1 /*
2  * uhttpd - Tiny single-threaded httpd
3  *
4  *   Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
5  *   Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
6  *
7  *  Licensed under the Apache License, Version 2.0 (the "License");
8  *  you may not use this file except in compliance with the License.
9  *  You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  *  Unless required by applicable law or agreed to in writing, software
14  *  distributed under the License is distributed on an "AS IS" BASIS,
15  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  *  See the License for the specific language governing permissions and
17  *  limitations under the License.
18  */
19
20
21 #include <libubox/blobmsg.h>
22 #include <libubox/blobmsg_json.h>
23 #include <libubox/avl.h>
24 #include <libubox/avl-cmp.h>
25 #include <stdio.h>
26 #include <poll.h>
27
28 #include "uhttpd.h"
29 #include "plugin.h"
30 #include "ubus-session.h"
31
32 static const struct uhttpd_ops *ops;
33 static struct config *_conf;
34 #define conf (*_conf)
35
36 static struct ubus_context *ctx;
37 static struct blob_buf buf;
38
39 #define UH_UBUS_MAX_POST_SIZE   4096
40
41 static char *split_str(char *str)
42 {
43         if (str)
44                 str = strchr(str, '/');
45
46         while (str && *str == '/') {
47                 *str = 0;
48                 str++;
49         }
50         return str;
51 }
52
53 static bool
54 uh_ubus_request_parse_url(struct client *cl, char *url, char **sid, char **obj, char **fun)
55 {
56         url += strlen(conf.ubus_prefix);
57         while (url && *url == '/')
58                 url++;
59
60         *sid = url;
61
62         url = split_str(url);
63         *obj = url;
64
65         url = split_str(url);
66         *fun = url;
67
68         return *sid && *obj && *fun;
69 }
70
71 static void
72 uh_ubus_request_data_cb(struct ubus_request *req, int type, struct blob_attr *msg)
73 {
74         struct dispatch_ubus *du = container_of(req, struct dispatch_ubus, req);
75         struct client *cl = container_of(du, struct client, dispatch.ubus);
76         char *str;
77
78         if (!du->header_sent) {
79                 ops->http_header(cl, 200, "OK");
80                 ustream_printf(cl->us, "Content-Type: application/json\r\n\r\n");
81                 du->header_sent = true;
82         }
83
84         str = blobmsg_format_json_indent(msg, true, 0);
85         ops->chunk_write(cl, str, strlen(str));
86         free(str);
87 }
88
89 static void
90 uh_ubus_request_cb(struct ubus_request *req, int ret)
91 {
92         struct dispatch_ubus *du = container_of(req, struct dispatch_ubus, req);
93         struct client *cl = container_of(du, struct client, dispatch.ubus);
94
95         if (!du->header_sent)
96                 return ops->client_error(cl, 204, "No content", "Function did not return data");
97
98         ops->request_done(cl);
99 }
100
101 static void uh_ubus_close_fds(struct client *cl)
102 {
103         if (ctx->sock.fd < 0)
104                 return;
105
106         close(ctx->sock.fd);
107         ctx->sock.fd = -1;
108 }
109
110 static void uh_ubus_request_free(struct client *cl)
111 {
112         struct dispatch_ubus *du = &cl->dispatch.ubus;
113
114         if (du->jsobj)
115                 json_object_put(du->jsobj);
116
117         if (du->jstok)
118                 json_tokener_free(du->jstok);
119
120         if (du->req_pending)
121                 ubus_abort_request(ctx, &du->req);
122 }
123
124 static void uh_ubus_json_error(struct client *cl)
125 {
126         ops->client_error(cl, 400, "Bad Request", "Invalid JSON data");
127 }
128
129 static void uh_ubus_send_request(struct client *cl, json_object *obj)
130 {
131         struct dispatch *d = &cl->dispatch;
132         struct dispatch_ubus *du = &d->ubus;
133         int ret;
134
135         blob_buf_init(&buf, 0);
136
137         if (obj && !blobmsg_add_object(&buf, obj))
138                 return uh_ubus_json_error(cl);
139
140         ret = ubus_invoke_async(ctx, du->obj, du->func, buf.head, &du->req);
141         if (ret)
142                 return ops->client_error(cl, 500, "Internal Error",
143                         "Error sending ubus request: %s", ubus_strerror(ret));
144
145         du->req.data_cb = uh_ubus_request_data_cb;
146         du->req.complete_cb = uh_ubus_request_cb;
147         ubus_complete_request_async(ctx, &du->req);
148
149         du->req_pending = true;
150 }
151
152 static void uh_ubus_data_done(struct client *cl)
153 {
154         struct dispatch_ubus *du = &cl->dispatch.ubus;
155         struct json_object *obj = du->jsobj;
156
157         if (!obj || json_object_get_type(obj) != json_type_object)
158                 return uh_ubus_json_error(cl);
159
160         uh_ubus_send_request(cl, obj);
161 }
162
163 static int uh_ubus_data_send(struct client *cl, const char *data, int len)
164 {
165         struct dispatch_ubus *du = &cl->dispatch.ubus;
166
167         if (du->jsobj) {
168                 uh_ubus_json_error(cl);
169                 return 0;
170         }
171
172         du->post_len += len;
173         if (du->post_len > UH_UBUS_MAX_POST_SIZE) {
174                 ops->client_error(cl, 413, "Too Large", "Message too big");
175                 return 0;
176         }
177
178         du->jsobj = json_tokener_parse_ex(du->jstok, data, len);
179         return len;
180 }
181
182 static void uh_ubus_defer_post(struct client *cl)
183 {
184         struct dispatch *d = &cl->dispatch;
185
186         d->ubus.jstok = json_tokener_new();
187         if (d->ubus.jstok)
188                 return ops->client_error(cl, 500, "Internal Error", "Internal Error");
189
190         d->data_send = uh_ubus_data_send;
191         d->data_done = uh_ubus_data_done;
192 }
193
194 static void uh_ubus_handle_request(struct client *cl, char *url, struct path_info *pi)
195 {
196         struct uh_ubus_session *ses;
197         struct dispatch *d = &cl->dispatch;
198         char *sid, *obj, *fun;
199
200         blob_buf_init(&buf, 0);
201
202         if (!uh_ubus_request_parse_url(cl, url, &sid, &obj, &fun))
203                 return ops->client_error(cl, 400, "Bad Request", "Invalid Request");
204
205         ses = uh_ubus_session_get(sid);
206         if (!ses)
207                 return ops->client_error(cl, 404, "Not Found", "No such session %s", sid);
208
209         if (!uh_ubus_session_acl_allowed(ses, obj, fun))
210                 return ops->client_error(cl, 403, "Denied", "Access to object denied");
211
212         if (ubus_lookup_id(ctx, obj, &d->ubus.obj))
213                 return ops->client_error(cl, 500, "Not Found", "No such object");
214
215         d->close_fds = uh_ubus_close_fds;
216         d->free = uh_ubus_request_free;
217         d->ubus.func = fun;
218
219         if (cl->request.method == UH_HTTP_MSG_POST)
220                 uh_ubus_defer_post(cl);
221         else
222                 uh_ubus_send_request(cl, NULL);
223 }
224
225 static bool
226 uh_ubus_check_url(const char *url)
227 {
228         return ops->path_match(conf.ubus_prefix, url);
229 }
230
231 static int
232 uh_ubus_init(void)
233 {
234         static struct dispatch_handler ubus_dispatch = {
235                 .check_url = uh_ubus_check_url,
236                 .handle_request = uh_ubus_handle_request,
237         };
238
239         ctx = ubus_connect(conf.ubus_socket);
240         if (!ctx) {
241                 fprintf(stderr, "Unable to connect to ubus socket\n");
242                 exit(1);
243         }
244
245         ops->dispatch_add(&ubus_dispatch);
246         if (ubus_session_api_init(ctx)) {
247                 fprintf(stderr, "Unable to initialize ubus session API\n");
248                 exit(1);
249         }
250
251         uloop_done();
252         return 0;
253 }
254
255
256 static int uh_ubus_plugin_init(const struct uhttpd_ops *o, struct config *c)
257 {
258         ops = o;
259         _conf = c;
260         return uh_ubus_init();
261 }
262
263 static void uh_ubus_post_init(void)
264 {
265         ubus_add_uloop(ctx);
266 }
267
268 const struct uhttpd_plugin uhttpd_plugin = {
269         .init = uh_ubus_plugin_init,
270         .post_init = uh_ubus_post_init,
271 };