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

Sources/ubus/libubus-io.c

  1 /*
  2  * Copyright (C) 2011-2014 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 #define _GNU_SOURCE
 15 #include <sys/types.h>
 16 #include <sys/uio.h>
 17 #include <sys/socket.h>
 18 
 19 #include <unistd.h>
 20 #include <fcntl.h>
 21 #include <poll.h>
 22 
 23 #include <libubox/usock.h>
 24 #include <libubox/blob.h>
 25 #include <libubox/blobmsg.h>
 26 
 27 #include "libubus.h"
 28 #include "libubus-internal.h"
 29 
 30 #define STATIC_IOV(_var) { .iov_base = (char *) &(_var), .iov_len = sizeof(_var) }
 31 
 32 #define UBUS_MSGBUF_REDUCTION_INTERVAL  16
 33 
 34 static const struct blob_attr_info ubus_policy[UBUS_ATTR_MAX] = {
 35         [UBUS_ATTR_STATUS] = { .type = BLOB_ATTR_INT32 },
 36         [UBUS_ATTR_OBJID] = { .type = BLOB_ATTR_INT32 },
 37         [UBUS_ATTR_OBJPATH] = { .type = BLOB_ATTR_STRING },
 38         [UBUS_ATTR_METHOD] = { .type = BLOB_ATTR_STRING },
 39         [UBUS_ATTR_ACTIVE] = { .type = BLOB_ATTR_INT8 },
 40         [UBUS_ATTR_NO_REPLY] = { .type = BLOB_ATTR_INT8 },
 41         [UBUS_ATTR_SUBSCRIBERS] = { .type = BLOB_ATTR_NESTED },
 42 };
 43 
 44 static struct blob_attr *attrbuf[UBUS_ATTR_MAX];
 45 
 46 __hidden struct blob_attr **ubus_parse_msg(struct blob_attr *msg, size_t len)
 47 {
 48         blob_parse_untrusted(msg, len, attrbuf, ubus_policy, UBUS_ATTR_MAX);
 49         return attrbuf;
 50 }
 51 
 52 static void wait_data(int fd, bool write)
 53 {
 54         struct pollfd pfd = { .fd = fd };
 55 
 56         pfd.events = write ? POLLOUT : POLLIN;
 57         poll(&pfd, 1, -1);
 58 }
 59 
 60 static int writev_retry(int fd, struct iovec *iov, int iov_len, int sock_fd)
 61 {
 62         static struct {
 63                 int fd;
 64                 struct cmsghdr h;
 65         } fd_buf = {
 66                 .h = {
 67                         .cmsg_len = sizeof(fd_buf),
 68                         .cmsg_level = SOL_SOCKET,
 69                         .cmsg_type = SCM_RIGHTS,
 70                 }
 71         };
 72         struct msghdr msghdr = {
 73                 .msg_iov = iov,
 74                 .msg_iovlen = iov_len,
 75                 .msg_control = &fd_buf,
 76                 .msg_controllen = sizeof(fd_buf),
 77         };
 78         int len = 0;
 79 
 80         do {
 81                 ssize_t cur_len;
 82 
 83                 if (sock_fd < 0) {
 84                         msghdr.msg_control = NULL;
 85                         msghdr.msg_controllen = 0;
 86                 } else {
 87                         fd_buf.fd = sock_fd;
 88                 }
 89 
 90                 cur_len = sendmsg(fd, &msghdr, 0);
 91                 if (cur_len < 0) {
 92                         switch(errno) {
 93                         case EAGAIN:
 94                                 wait_data(fd, true);
 95                                 break;
 96                         case EINTR:
 97                                 break;
 98                         default:
 99                                 return -1;
100                         }
101                         continue;
102                 }
103 
104                 if (len > 0)
105                         sock_fd = -1;
106 
107                 len += cur_len;
108                 while (cur_len >= (ssize_t) iov->iov_len) {
109                         cur_len -= iov->iov_len;
110                         iov_len--;
111                         iov++;
112                         if (!iov_len)
113                                 return len;
114                 }
115                 iov->iov_base += cur_len;
116                 iov->iov_len -= cur_len;
117                 msghdr.msg_iov = iov;
118                 msghdr.msg_iovlen = iov_len;
119         } while (1);
120 
121         /* Should never reach here */
122         return -1;
123 }
124 
125 int __hidden ubus_send_msg(struct ubus_context *ctx, uint32_t seq,
126                            struct blob_attr *msg, int cmd, uint32_t peer, int fd)
127 {
128         struct ubus_msghdr hdr;
129         struct iovec iov[2] = {
130                 STATIC_IOV(hdr)
131         };
132         int ret;
133 
134         hdr.version = 0;
135         hdr.type = cmd;
136         hdr.seq = cpu_to_be16(seq);
137         hdr.peer = cpu_to_be32(peer);
138 
139         if (!msg) {
140                 blob_buf_init(&b, 0);
141                 msg = b.head;
142         }
143 
144         iov[1].iov_base = (char *) msg;
145         iov[1].iov_len = blob_raw_len(msg);
146 
147         ret = writev_retry(ctx->sock.fd, iov, ARRAY_SIZE(iov), fd);
148         if (ret < 0)
149                 ctx->sock.eof = true;
150 
151         if (fd >= 0)
152                 close(fd);
153 
154         return ret;
155 }
156 
157 static int recv_retry(struct ubus_context *ctx, struct iovec *iov, bool wait, int *recv_fd)
158 {
159         int bytes, total = 0;
160         int fd = ctx->sock.fd;
161         static struct {
162                 int fd;
163                 struct cmsghdr h;
164         } fd_buf = {
165                 .h = {
166                         .cmsg_type = SCM_RIGHTS,
167                         .cmsg_level = SOL_SOCKET,
168                         .cmsg_len = sizeof(fd_buf),
169                 },
170         };
171         struct msghdr msghdr = {
172                 .msg_iov = iov,
173                 .msg_iovlen = 1,
174         };
175 
176         while (iov->iov_len > 0) {
177                 if (recv_fd) {
178                         msghdr.msg_control = &fd_buf;
179                         msghdr.msg_controllen = sizeof(fd_buf);
180                 } else {
181                         msghdr.msg_control = NULL;
182                         msghdr.msg_controllen = 0;
183                 }
184 
185                 fd_buf.fd = -1;
186                 bytes = recvmsg(fd, &msghdr, 0);
187                 if (!bytes)
188                         return -1;
189 
190                 if (bytes < 0) {
191                         bytes = 0;
192                         if (errno == EINTR)
193                                 continue;
194 
195                         if (errno != EAGAIN)
196                                 return -1;
197                 }
198                 if (!wait && !bytes)
199                         return 0;
200 
201                 if (recv_fd)
202                         *recv_fd = fd_buf.fd;
203 
204                 recv_fd = NULL;
205 
206                 wait = true;
207                 iov->iov_len -= bytes;
208                 iov->iov_base += bytes;
209                 total += bytes;
210 
211                 if (iov->iov_len > 0)
212                         wait_data(fd, false);
213         }
214 
215         return total;
216 }
217 
218 bool ubus_validate_hdr(struct ubus_msghdr *hdr)
219 {
220         struct blob_attr *data = (struct blob_attr *) (hdr + 1);
221 
222         if (hdr->version != 0)
223                 return false;
224 
225         if (blob_raw_len(data) < sizeof(*data))
226                 return false;
227 
228         if (blob_pad_len(data) > UBUS_MAX_MSGLEN)
229                 return false;
230 
231         return true;
232 }
233 
234 static bool alloc_msg_buf(struct ubus_context *ctx, int len)
235 {
236         void *ptr;
237         int buf_len = ctx->msgbuf_data_len;
238         int rem;
239 
240         if (!ctx->msgbuf.data)
241                 buf_len = 0;
242 
243         rem = (len % UBUS_MSG_CHUNK_SIZE);
244         if (rem > 0)
245                 len += UBUS_MSG_CHUNK_SIZE - rem;
246 
247         if (len < buf_len &&
248             ++ctx->msgbuf_reduction_counter > UBUS_MSGBUF_REDUCTION_INTERVAL) {
249                 ctx->msgbuf_reduction_counter = 0;
250                 buf_len = 0;
251         }
252 
253         if (len <= buf_len)
254                 return true;
255 
256         ptr = realloc(ctx->msgbuf.data, len);
257         if (!ptr)
258                 return false;
259 
260         ctx->msgbuf.data = ptr;
261         ctx->msgbuf_data_len = len;
262         return true;
263 }
264 
265 static bool get_next_msg(struct ubus_context *ctx, int *recv_fd)
266 {
267         struct {
268                 struct ubus_msghdr hdr;
269                 struct blob_attr data;
270         } hdrbuf;
271         struct iovec iov = STATIC_IOV(hdrbuf);
272         int len;
273         int r;
274 
275         /* receive header + start attribute */
276         r = recv_retry(ctx, &iov, false, recv_fd);
277         if (r <= 0) {
278                 if (r < 0)
279                         ctx->sock.eof = true;
280 
281                 return false;
282         }
283 
284         hdrbuf.hdr.seq = be16_to_cpu(hdrbuf.hdr.seq);
285         hdrbuf.hdr.peer = be32_to_cpu(hdrbuf.hdr.peer);
286 
287         if (!ubus_validate_hdr(&hdrbuf.hdr))
288                 return false;
289 
290         len = blob_raw_len(&hdrbuf.data);
291         if (!alloc_msg_buf(ctx, len))
292                 return false;
293 
294         memcpy(&ctx->msgbuf.hdr, &hdrbuf.hdr, sizeof(hdrbuf.hdr));
295         memcpy(ctx->msgbuf.data, &hdrbuf.data, sizeof(hdrbuf.data));
296 
297         iov.iov_base = (char *)ctx->msgbuf.data + sizeof(hdrbuf.data);
298         iov.iov_len = blob_len(ctx->msgbuf.data);
299         if (iov.iov_len > 0 &&
300             recv_retry(ctx, &iov, true, NULL) <= 0)
301                 return false;
302 
303         return true;
304 }
305 
306 void __hidden ubus_handle_data(struct uloop_fd *u, unsigned int events)
307 {
308         struct ubus_context *ctx = container_of(u, struct ubus_context, sock);
309         int recv_fd = -1;
310 
311         while (get_next_msg(ctx, &recv_fd)) {
312                 ubus_process_msg(ctx, &ctx->msgbuf, recv_fd);
313                 if (uloop_cancelling() || ctx->cancel_poll)
314                         break;
315         }
316 
317         if (u->eof)
318                 ctx->connection_lost(ctx);
319 }
320 
321 void __hidden ubus_poll_data(struct ubus_context *ctx, int timeout)
322 {
323         struct pollfd pfd = {
324                 .fd = ctx->sock.fd,
325                 .events = POLLIN | POLLERR,
326         };
327 
328         ctx->cancel_poll = false;
329         poll(&pfd, 1, timeout ? timeout : -1);
330         ubus_handle_data(&ctx->sock, ULOOP_READ);
331 }
332 
333 static void
334 ubus_refresh_state(struct ubus_context *ctx)
335 {
336         struct ubus_object *obj, *tmp;
337         struct ubus_object **objs;
338         int n, i = 0;
339 
340         /* clear all type IDs, they need to be registered again */
341         avl_for_each_element(&ctx->objects, obj, avl)
342                 if (obj->type)
343                         obj->type->id = 0;
344 
345         /* push out all objects again */
346         objs = alloca(ctx->objects.count * sizeof(*objs));
347         avl_remove_all_elements(&ctx->objects, obj, avl, tmp) {
348                 objs[i++] = obj;
349                 obj->id = 0;
350         }
351 
352         for (n = i, i = 0; i < n; i++)
353                 ubus_add_object(ctx, objs[i]);
354 }
355 
356 int ubus_reconnect(struct ubus_context *ctx, const char *path)
357 {
358         struct {
359                 struct ubus_msghdr hdr;
360                 struct blob_attr data;
361         } hdr;
362         struct blob_attr *buf;
363         int ret = UBUS_STATUS_UNKNOWN_ERROR;
364 
365         if (!path)
366                 path = UBUS_UNIX_SOCKET;
367 
368         if (ctx->sock.fd >= 0) {
369                 if (ctx->sock.registered)
370                         uloop_fd_delete(&ctx->sock);
371 
372                 close(ctx->sock.fd);
373         }
374 
375         ctx->sock.eof = false;
376         ctx->sock.error = false;
377         ctx->sock.fd = usock(USOCK_UNIX, path, NULL);
378         if (ctx->sock.fd < 0)
379                 return UBUS_STATUS_CONNECTION_FAILED;
380 
381         if (read(ctx->sock.fd, &hdr, sizeof(hdr)) != sizeof(hdr))
382                 goto out_close;
383 
384         if (!ubus_validate_hdr(&hdr.hdr))
385                 goto out_close;
386 
387         if (hdr.hdr.type != UBUS_MSG_HELLO)
388                 goto out_close;
389 
390         buf = calloc(1, blob_raw_len(&hdr.data));
391         if (!buf)
392                 goto out_close;
393 
394         memcpy(buf, &hdr.data, sizeof(hdr.data));
395         if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != (ssize_t) blob_len(buf))
396                 goto out_free;
397 
398         ctx->local_id = hdr.hdr.peer;
399         if (!ctx->local_id)
400                 goto out_free;
401 
402         ret = UBUS_STATUS_OK;
403         fcntl(ctx->sock.fd, F_SETFL, fcntl(ctx->sock.fd, F_GETFL) | O_NONBLOCK | O_CLOEXEC);
404 
405         ubus_refresh_state(ctx);
406 
407 out_free:
408         free(buf);
409 out_close:
410         if (ret)
411                 close(ctx->sock.fd);
412 
413         return ret;
414 }
415 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt