static struct interface_proto_state * static_attach(const struct proto_handler *h, struct interface *iface, struct blob_attr *attr) { struct static_proto_state *state; state = calloc(1, sizeof(*state)); if (!state) return NULL; state->config = malloc(blob_pad_len(attr)); if (!state->config) goto error; memcpy(state->config, attr, blob_pad_len(attr)); state->proto.free = static_free; state->proto.cb = static_handler; return &state->proto; error: free(state); return NULL; }
int __hidden ubus_start_request(struct ubus_context *ctx, struct ubus_request *req, struct blob_attr *msg, int cmd, uint32_t peer) { memset(req, 0, sizeof(*req)); if (msg && blob_pad_len(msg) > UBUS_MAX_MSGLEN) return -1; INIT_LIST_HEAD(&req->list); INIT_LIST_HEAD(&req->pending); req->ctx = ctx; req->peer = peer; req->seq = ++ctx->request_seq; return ubus_send_msg(ctx, req->seq, msg, cmd, peer); }
static void client_cb(struct uloop_fd *sock, unsigned int events) { struct ubus_client *cl = container_of(sock, struct ubus_client, sock); struct ubus_msg_buf *ub; static struct iovec iov; static struct { struct cmsghdr h; int fd; } fd_buf = { .h = { .cmsg_type = SCM_RIGHTS, .cmsg_level = SOL_SOCKET, .cmsg_len = sizeof(fd_buf), } }; struct msghdr msghdr = { .msg_iov = &iov, .msg_iovlen = 1, }; /* first try to tx more pending data */ while ((ub = ubus_msg_head(cl))) { int written; written = ubus_msg_writev(sock->fd, ub, cl->txq_ofs); if (written < 0) { switch(errno) { case EINTR: case EAGAIN: break; default: goto disconnect; } break; } cl->txq_ofs += written; if (cl->txq_ofs < ub->len + sizeof(ub->hdr)) break; ubus_msg_dequeue(cl); } /* prevent further ULOOP_WRITE events if we don't have data * to send anymore */ if (!ubus_msg_head(cl) && (events & ULOOP_WRITE)) uloop_fd_add(sock, ULOOP_READ | ULOOP_EDGE_TRIGGER); retry: if (!sock->eof && cl->pending_msg_offset < sizeof(cl->hdrbuf)) { int offset = cl->pending_msg_offset; int bytes; fd_buf.fd = -1; iov.iov_base = ((char *) &cl->hdrbuf) + offset; iov.iov_len = sizeof(cl->hdrbuf) - offset; if (cl->pending_msg_fd < 0) { msghdr.msg_control = &fd_buf; msghdr.msg_controllen = sizeof(fd_buf); } else { msghdr.msg_control = NULL; msghdr.msg_controllen = 0; } bytes = recvmsg(sock->fd, &msghdr, 0); if (bytes < 0) goto out; if (fd_buf.fd >= 0) cl->pending_msg_fd = fd_buf.fd; cl->pending_msg_offset += bytes; if (cl->pending_msg_offset < sizeof(cl->hdrbuf)) goto out; if (blob_pad_len(&cl->hdrbuf.data) > UBUS_MAX_MSGLEN) goto disconnect; cl->pending_msg = ubus_msg_new(NULL, blob_raw_len(&cl->hdrbuf.data), false); if (!cl->pending_msg) goto disconnect; memcpy(&cl->pending_msg->hdr, &cl->hdrbuf.hdr, sizeof(cl->hdrbuf.hdr)); memcpy(cl->pending_msg->data, &cl->hdrbuf.data, sizeof(cl->hdrbuf.data)); } ub = cl->pending_msg; if (ub) { int offset = cl->pending_msg_offset - sizeof(ub->hdr); int len = blob_raw_len(ub->data) - offset; int bytes = 0; if (len > 0) { bytes = read(sock->fd, (char *) ub->data + offset, len); if (bytes <= 0) goto out; } if (bytes < len) { cl->pending_msg_offset += bytes; goto out; } /* accept message */ ub->fd = cl->pending_msg_fd; cl->pending_msg_fd = -1; cl->pending_msg_offset = 0; cl->pending_msg = NULL; ubusd_proto_receive_message(cl, ub); goto retry; } out: if (!sock->eof || ubus_msg_head(cl)) return; disconnect: handle_client_disconnect(cl); } static bool get_next_connection(int fd) { struct ubus_client *cl; int client_fd; client_fd = accept(fd, NULL, 0); if (client_fd < 0) { switch (errno) { case ECONNABORTED: case EINTR: return true; default: return false; } } cl = ubusd_proto_new_client(client_fd, client_cb); if (cl) uloop_fd_add(&cl->sock, ULOOP_READ | ULOOP_EDGE_TRIGGER); else close(client_fd); return true; } static void server_cb(struct uloop_fd *fd, unsigned int events) { bool next; do { next = get_next_connection(fd->fd); } while (next); }
static int rrdns_next_query(struct rrdns_context *rctx) { const char *addr = NULL, *hex = "0123456789abcdef"; struct rrdns_request *req; int i, alen, family; char *p, dname[73]; union { unsigned char uchar[4]; struct in6_addr in6; struct in_addr in; } a = { }; union { unsigned char buf[512]; HEADER hdr; } msg; if (rctx->addr_rem > 0 && blob_pad_len(rctx->addr_cur) <= rctx->addr_rem && blob_pad_len(rctx->addr_cur) >= sizeof(struct blob_attr)) { addr = blobmsg_get_string(rctx->addr_cur); rctx->addr_rem -= blob_pad_len(rctx->addr_cur); rctx->addr_cur = blob_next(rctx->addr_cur); } if (!addr) return 0; if (inet_pton(AF_INET6, addr, &a.in6)) { memset(dname, 0, sizeof(dname)); for (i = 0, p = dname; i < 16; i++) { *p++ = hex[a.in6.s6_addr[15-i] % 16]; *p++ = '.'; *p++ = hex[a.in6.s6_addr[15-i] / 16]; *p++ = '.'; } p += snprintf(p, p - dname - 1, "ip6.arpa"); family = AF_INET6; alen = p - dname; } else if (inet_pton(AF_INET, addr, &a.in)) { family = AF_INET; alen = snprintf(dname, sizeof(dname), "%u.%u.%u.%u.in-addr.arpa", a.uchar[3], a.uchar[2], a.uchar[1], a.uchar[0]); } else { return -EINVAL; } alen = res_mkquery(QUERY, dname, C_IN, T_PTR, NULL, 0, NULL, msg.buf, sizeof(msg.buf)); if (alen < 0) return alen; if (avl_find(&rctx->request_addrs, &a.in6)) return -ENOTUNIQ; if (send(rctx->socket.fd, msg.buf, alen, 0) != alen) return -errno; req = calloc(1, sizeof(*req)); if (!req) return -ENOMEM; req->id = msg.hdr.id; req->by_id.key = &req->id; avl_insert(&rctx->request_ids, &req->by_id); req->family = family; req->addr.in6 = a.in6; req->by_addr.key = &req->addr.in6; avl_insert(&rctx->request_addrs, &req->by_addr); return 0; }
static void client_cb(struct uloop_fd *sock, unsigned int events) { struct ubus_client *cl = container_of(sock, struct ubus_client, sock); struct ubus_msg_buf *ub; /* first try to tx more pending data */ while ((ub = ubus_msg_head(cl))) { int written; written = ubus_msg_writev(sock->fd, ub, cl->txq_ofs); if (written < 0) { switch(errno) { case EINTR: case EAGAIN: break; default: goto disconnect; } break; } cl->txq_ofs += written; if (cl->txq_ofs < ub->len + sizeof(ub->hdr)) break; ubus_msg_dequeue(cl); } /* prevent further ULOOP_WRITE events if we don't have data * to send anymore */ if (!ubus_msg_head(cl) && (events & ULOOP_WRITE)) uloop_fd_add(sock, ULOOP_READ | ULOOP_EDGE_TRIGGER); retry: if (!sock->eof && cl->pending_msg_offset < sizeof(cl->hdrbuf)) { int offset = cl->pending_msg_offset; int bytes; bytes = read(sock->fd, (char *)&cl->hdrbuf + offset, sizeof(cl->hdrbuf) - offset); if (bytes < 0) goto out; cl->pending_msg_offset += bytes; if (cl->pending_msg_offset < sizeof(cl->hdrbuf)) goto out; if (blob_pad_len(&cl->hdrbuf.data) > UBUS_MAX_MSGLEN) goto disconnect; cl->pending_msg = ubus_msg_new(NULL, blob_raw_len(&cl->hdrbuf.data), false); if (!cl->pending_msg) goto disconnect; memcpy(&cl->pending_msg->hdr, &cl->hdrbuf.hdr, sizeof(cl->hdrbuf.hdr)); memcpy(cl->pending_msg->data, &cl->hdrbuf.data, sizeof(cl->hdrbuf.data)); } ub = cl->pending_msg; if (ub) { int offset = cl->pending_msg_offset - sizeof(ub->hdr); int len = blob_raw_len(ub->data) - offset; int bytes = 0; if (len > 0) { bytes = read(sock->fd, (char *) ub->data + offset, len); if (bytes <= 0) goto out; } if (bytes < len) { cl->pending_msg_offset += bytes; goto out; } /* accept message */ cl->pending_msg_offset = 0; cl->pending_msg = NULL; ubusd_proto_receive_message(cl, ub); goto retry; } out: if (!sock->eof || ubus_msg_head(cl)) return; disconnect: handle_client_disconnect(cl); }