2 * Copyright (C) 2011-2012 Felix Fietkau <nbd@openwrt.org>
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
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.
14 #include <sys/types.h>
16 #include <sys/socket.h>
22 #include <libubox/usock.h>
23 #include <libubox/blob.h>
24 #include <libubox/blobmsg.h>
27 #include "libubus-internal.h"
29 #define STATIC_IOV(_var) { .iov_base = (char *) &(_var), .iov_len = sizeof(_var) }
31 static const struct blob_attr_info ubus_policy
[UBUS_ATTR_MAX
] = {
32 [UBUS_ATTR_STATUS
] = { .type
= BLOB_ATTR_INT32
},
33 [UBUS_ATTR_OBJID
] = { .type
= BLOB_ATTR_INT32
},
34 [UBUS_ATTR_OBJPATH
] = { .type
= BLOB_ATTR_STRING
},
35 [UBUS_ATTR_METHOD
] = { .type
= BLOB_ATTR_STRING
},
36 [UBUS_ATTR_ACTIVE
] = { .type
= BLOB_ATTR_INT8
},
37 [UBUS_ATTR_NO_REPLY
] = { .type
= BLOB_ATTR_INT8
},
40 static struct blob_attr
*attrbuf
[UBUS_ATTR_MAX
];
42 __hidden
struct blob_attr
**ubus_parse_msg(struct blob_attr
*msg
)
44 blob_parse(msg
, attrbuf
, ubus_policy
, UBUS_ATTR_MAX
);
48 static void wait_data(int fd
, bool write
)
50 struct pollfd pfd
= { .fd
= fd
};
52 pfd
.events
= write
? POLLOUT
: POLLIN
;
56 static int writev_retry(int fd
, struct iovec
*iov
, int iov_len
)
61 int cur_len
= writev(fd
, iov
, iov_len
);
75 while (cur_len
>= iov
->iov_len
) {
76 cur_len
-= iov
->iov_len
;
79 if (!cur_len
|| !iov_len
)
82 iov
->iov_len
-= cur_len
;
86 int __hidden
ubus_send_msg(struct ubus_context
*ctx
, uint32_t seq
,
87 struct blob_attr
*msg
, int cmd
, uint32_t peer
)
89 struct ubus_msghdr hdr
;
90 struct iovec iov
[2] = {
100 blob_buf_init(&b
, 0);
104 iov
[1].iov_base
= (char *) msg
;
105 iov
[1].iov_len
= blob_raw_len(msg
);
107 return writev_retry(ctx
->sock
.fd
, iov
, ARRAY_SIZE(iov
));
110 static bool recv_retry(int fd
, struct iovec
*iov
, bool wait
)
114 while (iov
->iov_len
> 0) {
116 wait_data(fd
, false);
118 bytes
= read(fd
, iov
->iov_base
, iov
->iov_len
);
133 iov
->iov_len
-= bytes
;
134 iov
->iov_base
+= bytes
;
140 static bool ubus_validate_hdr(struct ubus_msghdr
*hdr
)
142 if (hdr
->version
!= 0)
145 if (blob_raw_len(hdr
->data
) < sizeof(*hdr
->data
))
148 if (blob_pad_len(hdr
->data
) > UBUS_MAX_MSGLEN
)
154 static bool get_next_msg(struct ubus_context
*ctx
)
156 struct iovec iov
= STATIC_IOV(ctx
->msgbuf
.hdr
);
158 /* receive header + start attribute */
159 iov
.iov_len
+= sizeof(struct blob_attr
);
160 if (!recv_retry(ctx
->sock
.fd
, &iov
, false))
163 iov
.iov_len
= blob_len(ctx
->msgbuf
.hdr
.data
);
164 if (iov
.iov_len
> 0 && !recv_retry(ctx
->sock
.fd
, &iov
, true))
167 return ubus_validate_hdr(&ctx
->msgbuf
.hdr
);
170 void __hidden
ubus_handle_data(struct uloop_fd
*u
, unsigned int events
)
172 struct ubus_context
*ctx
= container_of(u
, struct ubus_context
, sock
);
173 struct ubus_msghdr
*hdr
= &ctx
->msgbuf
.hdr
;
175 while (get_next_msg(ctx
)) {
176 ubus_process_msg(ctx
, hdr
);
182 ctx
->connection_lost(ctx
);
186 ubus_refresh_state(struct ubus_context
*ctx
)
188 struct ubus_object
*obj
, *tmp
;
190 /* clear all type IDs, they need to be registered again */
191 avl_for_each_element(&ctx
->objects
, obj
, avl
)
194 /* push out all objects again */
195 avl_for_each_element_safe(&ctx
->objects
, obj
, avl
, tmp
) {
197 avl_delete(&ctx
->objects
, &obj
->avl
);
198 ubus_add_object(ctx
, obj
);
202 int ubus_reconnect(struct ubus_context
*ctx
, const char *path
)
205 struct ubus_msghdr hdr
;
206 struct blob_attr data
;
208 struct blob_attr
*buf
;
209 int ret
= UBUS_STATUS_UNKNOWN_ERROR
;
212 path
= UBUS_UNIX_SOCKET
;
214 if (ctx
->sock
.fd
>= 0) {
215 if (ctx
->sock
.registered
)
216 uloop_fd_delete(&ctx
->sock
);
221 ctx
->sock
.fd
= usock(USOCK_UNIX
, path
, NULL
);
222 if (ctx
->sock
.fd
< 0)
223 return UBUS_STATUS_CONNECTION_FAILED
;
225 if (read(ctx
->sock
.fd
, &hdr
, sizeof(hdr
)) != sizeof(hdr
))
228 if (!ubus_validate_hdr(&hdr
.hdr
))
231 if (hdr
.hdr
.type
!= UBUS_MSG_HELLO
)
234 buf
= calloc(1, blob_raw_len(&hdr
.data
));
238 memcpy(buf
, &hdr
.data
, sizeof(hdr
.data
));
239 if (read(ctx
->sock
.fd
, blob_data(buf
), blob_len(buf
)) != blob_len(buf
))
242 ctx
->local_id
= hdr
.hdr
.peer
;
246 ret
= UBUS_STATUS_OK
;
247 fcntl(ctx
->sock
.fd
, F_SETFL
, fcntl(ctx
->sock
.fd
, F_GETFL
) | O_NONBLOCK
);
249 ubus_refresh_state(ctx
);