int main(int argc, char** argv)
{
struct sockaddr_in cli_addr;
socklen_t len = sizeof(struct sockaddr);
int type = USOCK_TCP | USOCK_SERVER | USOCK_NOCLOEXEC | USOCK_IPV4ONLY;
const char *host = "127.0.0.1";
const char *service = "8000";
char recv_buf[1024] = {0};
int connect_fd, u_fd;
u_fd = usock(type, host, service);
if(u_fd < 0) {
perror("usock");
return -1;
}
while (1) {
connect_fd = accept(u_fd, (struct sockaddr *)(&cli_addr), &len);
if (connect_fd < 0) {
perror("accept");
return -1;
}
printf("client_addr: %s\n", inet_ntoa(cli_addr.sin_addr));
recv(connect_fd, recv_buf, 1024, 0);
printf("recv %s\n", recv_buf);
close(connect_fd);
}
return 0;
}
int jrpc_client_init(struct jrpc_client *client, char *host, char *port)
{
char *debug_level_env;
memset(client, 0, sizeof(*client));
debug_level_env = getenv("JRPC_DEBUG");
if (debug_level_env == NULL)
client->conn.debug_level = 0;
else {
client->conn.debug_level = strtol(debug_level_env, NULL, 10);
dlog("JSONRPC-C Debug level %d\n", client->conn.debug_level);
}
strncpy(client->host, host, sizeof(client->host) - 1);
strncpy(client->port, port, sizeof(client->host) - 1);
client->conn.buffer_size = 1500;
client->conn.buffer = calloc(1, 1500);
client->conn.pos = 0;
client->conn.sock.fd =
usock(USOCK_TCP | USOCK_IPV4ONLY | USOCK_NUMERIC,
host, port);
if (client->conn.sock.fd < 0) {
return 1;
}
return 0;
}
int main() {
int fd = usock(USOCK_UNIX | USOCK_NONBLOCK, "ubus.sock", NULL);
ssize_t number = send(fd, "Hello", strlen("Hello"), 0);
fprintf(stdout, "send number is :%ld\n", number);
close(fd);
return 0;
}
static void log_handle_reconnect(struct uloop_timeout *timeout)
{
sender.fd = usock((log_udp) ? (USOCK_UDP) : (USOCK_TCP), log_ip, log_port);
if (sender.fd < 0) {
fprintf(stderr, "failed to connect: %s\n", strerror(errno));
uloop_timeout_set(&retry, 1000);
} else {
uloop_fd_add(&sender, ULOOP_READ);
syslog(LOG_INFO, "Logread connected to %s:%s\n", log_ip, log_port);
}
}
bool hncp_io_init(hncp o)
{
int s;
int on = 1;
int off = 0;
#if 0
/* Could also use usock here; however, it uses getaddrinfo, which
* doesn't seem to work when e.g. default routes aren't currently
* set up. Too bad. */
char buf[6];
sprintf(buf, "%d", HNCP_PORT);
s = usock(USOCK_IPV6ONLY|USOCK_UDP|USOCK_SERVER|USOCK_NONBLOCK, NULL, buf);
if (s < 0)
return false;
#else
struct sockaddr_in6 addr;
s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (s<0) {
L_ERR("unable to create IPv6 UDP socket");
return false;
}
fcntl(s, F_SETFL, O_NONBLOCK);
memset(&addr, 0, sizeof(addr));
addr.sin6_family = AF_INET6;
addr.sin6_port = htons(HNCP_PORT);
const int one = 1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
if (bind(s, (struct sockaddr *)&addr, sizeof(addr))<0) {
L_ERR("unable to bind to port %d", HNCP_PORT);
return false;
}
#endif
if (setsockopt(s, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on, sizeof(on)) < 0)
{
L_ERR("unable to setsockopt IPV6_RECVPKTINFO:%s", strerror(errno));
return false;
}
if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &off, sizeof(off)) < 0)
{
L_ERR("unable to setsockopt IPV6_MULTICAST_LOOP:%s", strerror(errno));
return false;
}
o->udp_socket = s;
o->timeout.cb = _timeout;
memset(&o->ufd, 0, sizeof(o->ufd));
o->ufd.fd = o->udp_socket;
o->ufd.cb = _fd_callback;
uloop_fd_add(&o->ufd, ULOOP_READ);
return true;
}
void u_tcp_connect()
{
usfd.stream.write_error = 1;
ufd.fd = usock(USOCK_TCP, u_tcp_host, u_tcp_port);
if (ufd.fd < 0) {
_debug("connection to sysrepo failed");
uloop_timeout_set(&reconnect_timer, 1000);
}
ufd.cb = connect_cb;
uloop_fd_add(&ufd, ULOOP_WRITE | ULOOP_EDGE_TRIGGER);
}
int dl_send_msg(char *msg)
{
int sockfd;
struct sockaddr_un servaddr;
sockfd = usock(USOCK_UNIX, DIGILED_UNIX_SOCKET, NULL);
if (write(sockfd, msg, strlen(msg) + 1) < 0) {
perror("write");
return errno;
}
close(sockfd);
}
static int syslog_open(void)
{
int fd;
DEBUG(1, "Opening %s\n", log_dev);
unlink(log_dev);
fd = usock(USOCK_UNIX | USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK, log_dev, NULL);
if (fd < 0) {
ERROR("Failed to open %s\n", log_dev);
return -1;
}
chmod(log_dev, 0666);
ustream_fd_init(&slog, fd);
return 0;
}
static void
reconnect_socket6(struct uloop_timeout *timeout)
{
struct interface *iface = container_of(timeout, struct interface, reconnect);
char mcast_addr[128];
int ttl = 255;
int yes = 1;
snprintf(mcast_addr, sizeof(mcast_addr), "%s%%%s", (iface->multicast) ? (iface->mcast_addr) : (iface->v6_addrs), iface->name);
iface->fd.fd = usock(USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK | USOCK_IPV6ONLY, mcast_addr, "5353");
if (iface->fd.fd < 0) {
fprintf(stderr, "failed to add listener %s: %s\n", mcast_addr, strerror(errno));
goto retry;
}
if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_BINDTODEVICE, iface->name, strlen(iface->name) < 0))
fprintf(stderr, "ioctl failed: SO_BINDTODEVICE\n");
if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) < 0)
fprintf(stderr, "ioctl failed: IPV6_UNICAST_HOPS\n");
if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &yes, sizeof(yes)) < 0)
fprintf(stderr, "ioctl failed: IPV6_RECVPKTINFO\n");
if (setsockopt(iface->fd.fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &yes, sizeof(yes)) < 0)
fprintf(stderr, "ioctl failed: IPV6_RECVHOPLIMIT\n");
if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
fprintf(stderr, "ioctl failed: SO_REUSEADDR\n");
if (iface->multicast && interface_socket_setup6(iface)) {
iface->fd.fd = -1;
goto retry;
}
uloop_fd_add(&iface->fd, ULOOP_READ);
if (iface->multicast) {
dns_send_question(iface, "_services._dns-sd._udp.local", TYPE_PTR, 1);
announce_init(iface);
}
return;
retry:
uloop_timeout_set(timeout, 1000);
}
static int _ubus_cli_js_connect(ubus_client_t socket, const char *_address){
struct ubus_cli_js *self = container_of(socket, struct ubus_cli_js, api);
int flags = 0;
int addrlen = strlen(_address);
char *address = alloca(addrlen);
strcpy(address, _address);
char *port = NULL;
if(address[0] == '/' || address[0] == '.') flags |= USOCK_UNIX;
else _split_address_port(address, addrlen, &port);
int fd = usock(flags, address, port);
if (fd < 0)
return -1;
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK | O_CLOEXEC);
self->fd = fd;
return 0;
}
void
http_server_init(void)
{
http_digest_init_nonce_priv_key();
http_s.http_event.cb = http_new_client;
http_s.http_event.fd = usock(USOCK_TCP | USOCK_SERVER, "0.0.0.0", config->local->port);
uloop_fd_add(&http_s.http_event, ULOOP_READ | ULOOP_EDGE_TRIGGER);
DDF("+++ HTTP SERVER CONFIGURATION +++\n");
if (config->local->ip)
DDF("ip: '%s'\n", config->local->ip);
else
DDF("NOT BOUND TO IP\n");
DDF("port: '%s'\n", config->local->port);
DDF("--- HTTP SERVER CONFIGURATION ---\n");
log_message(NAME, L_NOTICE, "http server initialized\n");
}
static void
reconnect_socket4(struct uloop_timeout *timeout)
{
struct interface *iface = container_of(timeout, struct interface, reconnect);
int yes = 1;
iface->fd.fd = usock(USOCK_UDP | USOCK_SERVER | USOCK_NONBLOCK | USOCK_IPV4ONLY,
(iface->multicast) ? (iface->mcast_addr) : (iface->v4_addrs), "5353");
if (iface->fd.fd < 0) {
fprintf(stderr, "failed to add listener %s: %s\n", iface->mcast_addr, strerror(errno));
goto retry;
}
if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_BINDTODEVICE, iface->name, strlen(iface->name) < 0))
fprintf(stderr, "ioctl failed: SO_BINDTODEVICE\n");
if (setsockopt(iface->fd.fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
fprintf(stderr, "ioctl failed: SO_REUSEADDR\n");
if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_RECVTTL, &yes, sizeof(yes)) < 0)
fprintf(stderr, "ioctl failed: IP_RECVTTL\n");
if (setsockopt(iface->fd.fd, IPPROTO_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0)
fprintf(stderr, "ioctl failed: IP_PKTINFO\n");
if (iface->multicast && interface_mcast_setup4(iface)) {
iface->fd.fd = -1;
goto retry;
}
uloop_fd_add(&iface->fd, ULOOP_READ);
if (iface->multicast) {
dns_send_question(iface, "_services._dns-sd._udp.local", TYPE_PTR, 1);
announce_init(iface);
}
return;
retry:
uloop_timeout_set(timeout, 1000);
}
int main(int argc, char **argv)
{
const char *ubus_socket = UBUS_UNIX_SOCKET;
int ret = 0;
int ch;
signal(SIGPIPE, SIG_IGN);
signal(SIGHUP, sighup_handler);
openlog("ubusd", LOG_PID, LOG_DAEMON);
uloop_init();
while ((ch = getopt(argc, argv, "s:")) != -1) {
switch (ch) {
case 's':
ubus_socket = optarg;
break;
default:
return usage(argv[0]);
}
}
unlink(ubus_socket);
umask(0111);
server_fd.fd = usock(USOCK_UNIX | USOCK_SERVER | USOCK_NONBLOCK, ubus_socket, NULL);
if (server_fd.fd < 0) {
perror("usock");
ret = -1;
goto out;
}
uloop_fd_add(&server_fd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
ubusd_acl_load();
uloop_run();
unlink(ubus_socket);
out:
uloop_done();
return ret;
}
int main(int argc, char **argv)
{
const char *ubus_socket = UBUS_UNIX_SOCKET;//定义在cmake中，UBUS_UNIX_SOCKET="/var/run/ubus.sock"
int ret = 0;
int ch;
signal(SIGPIPE, SIG_IGN);//入参:信号类型；处理函数handler。
uloop_init();
while ((ch = getopt(argc, argv, "s:")) != -1) {
switch (ch) {
case 's':
ubus_socket = optarg;
break;
default:
return usage(argv[0]);
}
}
unlink(ubus_socket);//unlink，删除/var/run/ubus.sock文件
umask(0177);//umask,设置用户创建新文件时文件的默认权限。
server_fd.fd = usock(USOCK_UNIX | USOCK_SERVER | USOCK_NONBLOCK, ubus_socket, NULL);
if (server_fd.fd < 0) {//usock,首参为套接字类型，ubus_socket可为"127.0.0.1"或var/run/ubus.sock,最后一个为服务端口号"22"或NULL
perror("usock");
ret = -1;
goto out;
}
uloop_fd_add(&server_fd, ULOOP_READ | ULOOP_EDGE_TRIGGER);
uloop_run();//调用uloop_run()，ubusd进程不会再退出--->ubusd通过select方法监听套接字/var/run/ubus.sock，接收ubus发出的服务查询/请求，并将服务请求转发给netifd等提供服务的进程。
unlink(ubus_socket);
out:
uloop_done();
return ret;
}
int jrpc_server_init(struct jrpc_server *server, char *host, char *port)
{
char *debug_level_env = getenv("JRPC_DEBUG");
if (debug_level_env == NULL) {
server->debug_level = 0;
} else {
server->debug_level = strtol(debug_level_env, NULL, 10);
dlog("JSONRPC-C Debug level %d\n", server->debug_level);
}
server->sock.cb = server_cb;
server->sock.fd =
usock(USOCK_TCP | USOCK_SERVER | USOCK_IPV4ONLY | USOCK_NUMERIC,
host, port);
if (server->sock.fd < 0) {
perror("usock");
return 1;
}
system_fd_set_cloexec(server->sock.fd);
uloop_fd_add(&server->sock, ULOOP_READ | ULOOP_EDGE_TRIGGER);
return 0;
}
static int
rpc_rrdns_lookup(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
int port = 53, limit = RRDNS_DEF_LIMIT, timeout = RRDNS_DEF_TIMEOUT;
struct blob_attr *tb[__RPC_L_MAX];
struct rrdns_context *rctx;
const char *server = NULL;
blobmsg_parse(rpc_lookup_policy, __RPC_L_MAX, tb,
blob_data(msg), blob_len(msg));
if (tb[RPC_L_PORT])
port = blobmsg_get_u16(tb[RPC_L_PORT]);
if (tb[RPC_L_LIMIT])
limit = blobmsg_get_u32(tb[RPC_L_LIMIT]);
if (tb[RPC_L_TIMEOUT])
timeout = blobmsg_get_u32(tb[RPC_L_TIMEOUT]);
if (tb[RPC_L_SERVER])
server = blobmsg_get_string(tb[RPC_L_SERVER]);
if (!tb[RPC_L_ADDRS])
return UBUS_STATUS_INVALID_ARGUMENT;
if (port <= 0)
return UBUS_STATUS_INVALID_ARGUMENT;
if (limit <= 0 || limit > RRDNS_MAX_LIMIT)
return UBUS_STATUS_INVALID_ARGUMENT;
if (timeout <= 0 || timeout > RRDNS_MAX_TIMEOUT)
return UBUS_STATUS_INVALID_ARGUMENT;
if (!server || !*server)
server = rrdns_find_nameserver();
if (!server)
return UBUS_STATUS_NOT_FOUND;
rctx = calloc(1, sizeof(*rctx));
if (!rctx)
return UBUS_STATUS_UNKNOWN_ERROR;
rctx->socket.fd = usock(USOCK_UDP, server, usock_port(port));
if (rctx->socket.fd < 0) {
free(rctx);
return UBUS_STATUS_UNKNOWN_ERROR;
}
rctx->context = ctx;
rctx->addr_cur = blobmsg_data(tb[RPC_L_ADDRS]);
rctx->addr_rem = blobmsg_data_len(tb[RPC_L_ADDRS]);
avl_init(&rctx->request_ids, rrdns_cmp_id, false, NULL);
avl_init(&rctx->request_addrs, rrdns_cmp_addr, false, NULL);
rctx->timeout.cb = rrdns_handle_timeout;
uloop_timeout_set(&rctx->timeout, timeout);
rctx->socket.cb = rrdns_handle_response;
uloop_fd_add(&rctx->socket, ULOOP_READ);
blob_buf_init(&rctx->blob, 0);
while (limit--)
rrdns_next_query(rctx);
ubus_defer_request(ctx, req, &rctx->request);
return UBUS_STATUS_OK;
}
