bool fw3_ubus_connect(void) { bool status = false; uint32_t id; struct ubus_context *ctx = ubus_connect(NULL); struct blob_buf b = { }; if (!ctx) goto out; if (ubus_lookup_id(ctx, "network.interface", &id)) goto out; if (ubus_invoke(ctx, id, "dump", NULL, dump_cb, NULL, 2000)) goto out; status = true; if (ubus_lookup_id(ctx, "service", &id)) goto out; blob_buf_init(&b, 0); blobmsg_add_string(&b, "type", "firewall"); ubus_invoke(ctx, id, "get_data", b.head, procd_data_cb, NULL, 2000); blob_buf_free(&b); out: if (ctx) ubus_free(ctx); return status; }
int main(int argc, char **argv) { const char *ubus_socket = NULL; int ch; while ((ch = getopt(argc, argv, "cs:")) != -1) { switch (ch) { case 's': ubus_socket = optarg; break; default: break; } } argc -= optind; argv += optind; uloop_init(); //N1. Connect the process to ubus daemon ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } //N2. Add connected fd into epoll fd set ubus_add_uloop(ctx); //N4. Add notify object onto bus ubus_add_object(ctx, & test_object); //N5. Prepare notify type and arguments when actually an event happens …… event_ broadcast(event); ubus_free(ctx); uloop_done(); return 0; }
int main(int argc, char **argv) { while (isStaGetIP("apcli0") == 0) { sleep(1); } uloop_init(); signal(SIGPIPE, SIG_IGN); openlog("checkupgrade", 0, 0); ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } ubus_add_uloop(ctx); server_main(); ubus_free(ctx); uloop_done(); return 0; }
int main(int argc, char **argv) { const char *ubus_socket = "/var/run/ubus.sock"; struct ubus_context *ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } memset(&listener, 0, sizeof(listener)); listener.cb = receive_event; int ret = ubus_register_event_handler(ctx, &listener, "foo"); if (ret) return ret; struct event_base *evloop = event_base_new(); struct event *signal_int = evsignal_new(evloop, SIGINT, signal_cb, evloop); event_add(signal_int, NULL); struct event *e = event_new(evloop, ctx->sock.fd, EV_READ | EV_PERSIST, cb, ctx); event_add(e, NULL); event_base_dispatch(evloop); event_free(signal_int); event_free(e); event_base_free(evloop); ubus_free(ctx); return 0; }
static void ubus_destroy(struct ubus_context *ubus) { // Forces re-initialization when we're reusing the same definitions later on. ubus_object.id = 0; ubus_object_type.id = 0; ubus_free(ubus); daemon->ubus = NULL; }
int main(int argc, char **argv) { struct stat s; const char *hangup; const char *ubus_socket = NULL; int ch; while ((ch = getopt(argc, argv, "s:")) != -1) { switch (ch) { case 's': ubus_socket = optarg; break; default: break; } } if (stat("/var/run/rpcd", &s)) mkdir("/var/run/rpcd", 0700); umask(0077); signal(SIGPIPE, SIG_IGN); signal(SIGHUP, handle_signal); signal(SIGUSR1, handle_signal); uloop_init(); ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } ubus_add_uloop(ctx); rpc_session_api_init(ctx); rpc_uci_api_init(ctx); rpc_plugin_api_init(ctx); hangup = getenv("RPC_HANGUP"); if (!hangup || strcmp(hangup, "1")) rpc_uci_purge_savedirs(); else rpc_session_thaw(); uloop_run(); ubus_free(ctx); uloop_done(); if (respawn) exec_self(argc, argv); return 0; }
int main(int argc, char **argv) { const char *ubus_socket = NULL; static struct ubus_context *ctx; char ubus_event[128] = ""; const char * ubusevent = NULL; char *cmd; int ret = 0; int i, ch; while ((ch = getopt(argc, argv, "r:vs:t:S")) != -1) { switch (ch) { case 's': ubus_socket = optarg; break; case 't': timeout = atoi(optarg); break; case 'S': simple_output = true; break; case 'r': strncpy(ubus_event, optarg, sizeof ubus_event); ubus_event[(sizeof ubus_event) - 1] = '\0'; ubusevent = ubus_event; break; case 'v': verbose++; break; default: return usage("ubus-linknx"); } } ctx = ubus_connect(ubus_socket); if (!ctx) { if (!simple_output) fprintf(stderr, "Failed to connect to ubus\n"); return -1; } ret = -2; ret = ubus_cli_listen(ctx,ubusevent); if (ret > 0) fprintf(stderr, "Command failed: %s\n", ubus_strerror(ret)); ubus_free(ctx); return 0; }
UBusThread::~UBusThread() { ILOG_TRACE(UBUS_THREAD); ubus_free(_ubus); uloop_done(); MGuiRil::Destroy(); MGuiCharger::Destroy(); MGuiWifi::Destroy(); MGuiStats::Destroy(); MGuiHawk::Destroy(); ILOG_DEBUG(UBUS_THREAD, "%s exit\n", __func__); }
static int client_ubus_process(char *ubus_object, char *ubus_method, char *argv) { static struct ubus_request req; uint32_t id; int ret, ret_ubus_invoke; const char *ubus_socket = NULL; struct ubus_context *ctx_local; ctx_local = ubus_connect(ubus_socket); if (!ctx_local) { printf("Failed to connect to ubus\n"); return -1; } if (ubus_lookup_id(ctx_local, ubus_object, &id)) { printf("Failed to look up test object\n"); return -1; } blob_buf_init(&b_local, 0); blobmsg_add_string(&b_local, "cmd", argv); ret_ubus_invoke = ubus_invoke(ctx_local, id, ubus_method, b_local.head, receive_call_result_data, 0, 20000); if(ret_ubus_invoke == 0 || ret_ubus_invoke == 7) { ret = 0; } else { ret = -1; } ubus_free(ctx_local); return ret; }
void ubus_exit(void) { if (ctx) ubus_free(ctx); }
/** * Nodewatcher agent entry point. */ int main(int argc, char **argv) { struct stat s; const char *ubus_socket = NULL; int log_option = 0; int c; while ((c = getopt(argc, argv, "s:")) != -1) { switch (c) { case 's': ubus_socket = optarg; break; case 'f': log_option |= LOG_PERROR; break; default: break; } } /* Open the syslog facility */ openlog("nw-agent", log_option, LOG_DAEMON); /* Create directory for temporary run files */ if (stat("/var/run/nodewatcher-agent", &s)) mkdir("/var/run/nodewatcher-agent", 0700); umask(0077); /* Setup signal handlers */ signal(SIGPIPE, SIG_IGN); /* TODO: Handle SIGHUP to reload? */ /* Seed random generator */ unsigned int seed; int rc = nw_read_random_bytes(&seed, sizeof(seed)); if (rc < 0) { fprintf(stderr, "ERROR: Failed to seed random generator!\n"); return -1; } srandom(seed); /* Initialize event loop */ uloop_init(); /* Attempt to establish connection to ubus daemon */ for (;;) { ubus = ubus_connect(ubus_socket); if (!ubus) { syslog(LOG_WARNING, "Failed to connect to ubus!"); sleep(10); continue; } break; } ubus_add_uloop(ubus); /* Initialize UCI context */ uci = uci_alloc_context(); if (!uci) { syslog(LOG_ERR, "Failed to initialize UCI!"); return -1; } /* Discover and initialize modules */ if (nw_module_init(ubus, uci) != 0) { syslog(LOG_ERR, "Unable to initialize modules!"); return -1; } /* Initialize the scheduler */ if (nw_scheduler_init() != 0) { syslog(LOG_ERR, "Unable to initialize scheduler!"); return -1; } /* Initialize the output exporter */ if (nw_output_init(uci) != 0) { syslog(LOG_ERR, "Unable to initialize output exporter!"); return -1; } /* Enter the event loop */ uloop_run(); ubus_free(ubus); uci_free_context(uci); uloop_done(); return 0; }
void loop_detect_ubus_done(void) { ubus_free(ctx); uloop_done(); }
int main(int argc, char **argv) { static struct ubus_request req; struct ubus_context *ctx; uint32_t id; const char *ubus_socket = NULL; int ch, ret, lines = 0; static struct blob_buf b; int tries = 5; signal(SIGPIPE, SIG_IGN); while ((ch = getopt(argc, argv, "u0fcs:l:r:F:p:S:P:h:")) != -1) { switch (ch) { case 'u': log_udp = 1; break; case '0': log_trailer_null = 1; break; case 's': ubus_socket = optarg; break; case 'r': log_ip = optarg++; log_port = argv[optind++]; break; case 'F': log_file = optarg; break; case 'p': pid_file = optarg; break; case 'P': log_prefix = optarg; break; case 'f': log_follow = 1; break; case 'l': lines = atoi(optarg); break; case 'S': log_size = atoi(optarg); if (log_size < 1) log_size = 1; log_size *= 1024; break; case 'h': hostname = optarg; break; default: return usage(*argv); } } uloop_init(); ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } ubus_add_uloop(ctx); /* ugly ugly ugly ... we need a real reconnect logic */ do { ret = ubus_lookup_id(ctx, "log", &id); if (ret) { fprintf(stderr, "Failed to find log object: %s\n", ubus_strerror(ret)); sleep(1); continue; } blob_buf_init(&b, 0); if (lines) blobmsg_add_u32(&b, "lines", lines); else if (log_follow) blobmsg_add_u32(&b, "lines", 0); if (log_follow) { if (pid_file) { FILE *fp = fopen(pid_file, "w+"); if (fp) { fprintf(fp, "%d", getpid()); fclose(fp); } } } if (log_ip && log_port) { openlog("logread", LOG_PID, LOG_DAEMON); log_type = LOG_NET; sender.cb = log_handle_fd; retry.cb = log_handle_reconnect; uloop_timeout_set(&retry, 1000); } else if (log_file) { log_type = LOG_FILE; sender.fd = open(log_file, O_CREAT | O_WRONLY| O_APPEND, 0600); if (sender.fd < 0) { fprintf(stderr, "failed to open %s: %s\n", log_file, strerror(errno)); exit(-1); } } else { sender.fd = STDOUT_FILENO; } ubus_invoke_async(ctx, id, "read", b.head, &req); req.fd_cb = logread_fd_cb; ubus_complete_request_async(ctx, &req); uloop_run(); ubus_free(ctx); uloop_done(); } while (ret && tries--); return ret; }
int main(int argc, char **argv) { int opt, rc = 0; while ((opt = getopt(argc, argv, "hv")) != -1) { switch (opt) { case 'v': conf.verbosity++; break; case 'h': default: return usage(argv[0]); } } conf.flx_ufd.fd = open(FLX_DEV, O_RDWR); if (conf.flx_ufd.fd < 0) { perror(FLX_DEV); rc = 1; goto finish; } if (!configure_tty(conf.flx_ufd.fd)) { fprintf(stderr, "%s: Failed to configure tty params\n", FLX_DEV); rc = 2; goto finish; } if (!config_init()) { rc = 3; goto oom; } if (!config_load_all()) { rc = 4; goto finish; } conf.ubus_ctx = ubus_connect(NULL); if (!conf.ubus_ctx) { fprintf(stderr, "Failed to connect to ubus\n"); rc = 5; goto finish; } #ifdef WITH_YKW conf.ykw = ykw_new(YKW_DEFAULT_THETA); if (conf.ykw == NULL) { rc = 6; goto oom; } #endif mosquitto_lib_init(); snprintf(conf.mqtt.id, MQTT_ID_LEN, MQTT_ID_TPL, getpid()); conf.mosq = mosquitto_new(conf.mqtt.id, conf.mqtt.clean_session, &conf); if (!conf.mosq) { switch (errno) { case ENOMEM: rc = 7; goto oom; case EINVAL: fprintf(stderr, "mosq_new: Invalid id and/or clean_session.\n"); rc = 8; goto finish; } } rc = mosquitto_loop_start(conf.mosq); switch (rc) { case MOSQ_ERR_INVAL: fprintf(stderr, "mosq_loop_start: Invalid input parameters.\n"); goto finish; case MOSQ_ERR_NOT_SUPPORTED: fprintf(stderr, "mosq_loop_start: No threading support.\n"); goto finish; }; rc = mosquitto_connect_async(conf.mosq, conf.mqtt.host, conf.mqtt.port, conf.mqtt.keepalive); switch (rc) { case MOSQ_ERR_INVAL: fprintf(stderr, "mosq_connect_async: Invalid input parameters.\n"); goto finish; case MOSQ_ERR_ERRNO: perror("mosq_connect_async"); goto finish; } uloop_init(); uloop_fd_add(&conf.flx_ufd, ULOOP_READ); uloop_timeout_set(&conf.timeout, CONFIG_ULOOP_TIMEOUT); ubus_add_uloop(conf.ubus_ctx); ubus_register_event_handler(conf.ubus_ctx, &conf.ubus_ev_sighup, CONFIG_UBUS_EV_SIGHUP); ubus_register_event_handler(conf.ubus_ctx, &conf.ubus_ev_shift_calc, CONFIG_UBUS_EV_SHIFT_CALC); uloop_run(); uloop_done(); goto finish; oom: fprintf(stderr, "error: Out of memory.\n"); finish: mosquitto_disconnect(conf.mosq); mosquitto_loop_stop(conf.mosq, false); mosquitto_destroy(conf.mosq); mosquitto_lib_cleanup(); ykw_free(conf.ykw); if (conf.ubus_ctx != NULL) { ubus_free(conf.ubus_ctx); } close(conf.flx_ufd.fd); uci_free_context(conf.uci_ctx); return rc; }
int callback_lws_mirror(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) { struct per_session_data__lws_mirror *pss = (struct per_session_data__lws_mirror *)user; int m,n; switch (reason) { case LWS_CALLBACK_ESTABLISHED: lwsl_info("callback_lws_mirror: LWS_CALLBACK_ESTABLISHED\n", __func__); pss->ringbuffer_tail = ringbuffer_head; pss->wsi = wsi; break; case LWS_CALLBACK_PROTOCOL_DESTROY: lwsl_notice("mirror protocol cleaning up\n"); for (n = 0; n < sizeof ringbuffer / sizeof ringbuffer[0]; n++) if (ringbuffer[n].payload) free(ringbuffer[n].payload); break; case LWS_CALLBACK_SERVER_WRITEABLE: if (close_testing) break; while (pss->ringbuffer_tail != ringbuffer_head) { m = ringbuffer[pss->ringbuffer_tail].len; n = lws_write(wsi, (unsigned char *) ringbuffer[pss->ringbuffer_tail].payload + LWS_PRE, m, LWS_WRITE_TEXT); if (n < 0) { lwsl_err("ERROR %d writing to mirror socket\n", n); return -1; } if (n < m) lwsl_err("mirror partial write %d vs %d\n", n, m); if (pss->ringbuffer_tail == (MAX_MESSAGE_QUEUE - 1)) pss->ringbuffer_tail = 0; else pss->ringbuffer_tail++; if (((ringbuffer_head - pss->ringbuffer_tail) & (MAX_MESSAGE_QUEUE - 1)) == (MAX_MESSAGE_QUEUE - 15)) lws_rx_flow_allow_all_protocol(lws_get_context(wsi), lws_get_protocol(wsi)); if (lws_send_pipe_choked(wsi)) { lws_callback_on_writable(wsi); break; } /* * for tests with chrome on same machine as client and * server, this is needed to stop chrome choking */ usleep(1); } break; case LWS_CALLBACK_RECEIVE: if (((ringbuffer_head - pss->ringbuffer_tail) & (MAX_MESSAGE_QUEUE - 1)) == (MAX_MESSAGE_QUEUE - 1)) { lwsl_err("dropping!\n"); goto choke; } if (ringbuffer[ringbuffer_head].payload) free(ringbuffer[ringbuffer_head].payload); ringbuffer[ringbuffer_head].payload = malloc(LWS_SEND_BUFFER_PRE_PADDING + len + LWS_SEND_BUFFER_POST_PADDING); ringbuffer[ringbuffer_head].len = len; memcpy((char *)ringbuffer[ringbuffer_head].payload + LWS_SEND_BUFFER_PRE_PADDING, in, len); if (ringbuffer_head == (MAX_MESSAGE_QUEUE - 1)) ringbuffer_head = 0; else ringbuffer_head++; if (((ringbuffer_head - pss->ringbuffer_tail) & (MAX_MESSAGE_QUEUE - 1)) != (MAX_MESSAGE_QUEUE - 2)) goto done; choke: lwsl_debug("LWS_CALLBACK_RECEIVE: throttling %p\n", wsi); lws_rx_flow_control(wsi, 0); done: lws_callback_on_writable_all_protocol(lws_get_context(wsi), lws_get_protocol(wsi)); const char *ubus_socket = NULL; struct ubus_context *ctx; static struct blob_buf b; ctx = ubus_connect(ubus_socket); if (!ctx) { fprintf(stderr, "Failed to connect to ubus\n"); return -1; } blob_buf_init(&b, 0); blobmsg_add_json_from_string(&b, (char *)in); ubus_send_event(ctx, ubusxevent, b.head); ubus_free(ctx); break; /* * this just demonstrates how to use the protocol filter. If you won't * study and reject connections based on header content, you don't need * to handle this callback */ case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION: dump_handshake_info(wsi); /* you could return non-zero here and kill the connection */ break; default: break; } return 0; }
void app_destroy(struct app *self){ ubus_free(self->ctx); }
void ubus_exit(void) { if (ubus) ubus_free(ubus); }