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; }