static int
rpc_rrdns_api_init(const struct rpc_daemon_ops *o, struct ubus_context *ctx)
{
static const struct ubus_method rrdns_methods[] = {
UBUS_METHOD("lookup", rpc_rrdns_lookup, rpc_lookup_policy),
};
static struct ubus_object_type rrdns_type =
UBUS_OBJECT_TYPE("luci-rpc-rrdns", rrdns_methods);
static struct ubus_object obj = {
.name = "luci2.network.rrdns",
.type = &rrdns_type,
.methods = rrdns_methods,
.n_methods = ARRAY_SIZE(rrdns_methods),
};
return ubus_add_object(ctx, &obj);
}
struct rpc_plugin rpc_plugin = {
.init = rpc_rrdns_api_init
};
return 0;
error:
blob_buf_free(&b);
return -1;
}
static const struct ubus_method easycwmp_methods[] = {
UBUS_METHOD("notify", easycwmpd_handle_notify, notify_policy),
UBUS_METHOD("inform", easycwmpd_handle_inform, inform_policy),
UBUS_METHOD("command", easycwmpd_handle_command, command_policy),
};
static struct ubus_object_type main_object_type =
UBUS_OBJECT_TYPE("easycwmpd", easycwmp_methods);
static struct ubus_object main_object = {
.name = "tr069",
.type = &main_object_type,
.methods = easycwmp_methods,
.n_methods = ARRAY_SIZE(easycwmp_methods),
};
int
ubus_init(void)
{
ctx = ubus_connect(config->local->ubus_socket);
if (!ctx) return -1;
ubus_add_uloop(ctx);
struct blob_attr *msg)
{
freecwmp_log_message(NAME, L_NOTICE, "triggered ubus reload\n");
freecwmp_reload();
return 0;
}
static const struct ubus_method freecwmp_methods[] = {
UBUS_METHOD("notify", freecwmpd_handle_notify, notify_policy),
UBUS_METHOD("inform", freecwmpd_handle_inform, inform_policy),
{ .name = "reload", .handler = freecwmpd_handle_reload },
};
static struct ubus_object_type main_object_type =
UBUS_OBJECT_TYPE("freecwmpd", freecwmp_methods);
static struct ubus_object main_object = {
.name = "tr069",
.type = &main_object_type,
.methods = freecwmp_methods,
.n_methods = ARRAY_SIZE(freecwmp_methods),
};
int
ubus_init(void)
{
ctx = ubus_connect(config->local->ubus_socket);
if (!ctx) return -1;
ubus_add_uloop(ctx);
}
static struct ubus_method vlan_methods[] = {
UBUS_METHOD("new", vlan_new, vlan_new_policy),
UBUS_METHOD("find", vlan_find, vlan_find_policy),
UBUS_METHOD("delete", vlan_delete, vlan_delete_policy),
UBUS_METHOD("port", vlan_port, vlan_port_policy), //* vlan 中的端口属性 */
UBUS_METHOD("mstp", vlan_mstp, vlan_mstp_policy),/* 802.1q 13章 增加MSTP*/
};
static struct ubus_object_type vlan_object_type =
UBUS_OBJECT_TYPE("vlan", vlan_methods);
static struct ubus_object vlan_object = {
.name = "bridge.swVlan",
.type = &vlan_object_type,
.methods = vlan_methods,
.n_methods = ARRAY_SIZE(vlan_methods),
};
void vlan_add_to_ubus(void)
{
int ret;
ret = ubus_add_object(ctx, &vlan_object);
#include <stdio.h>
#include <unistd.h>
#include <libubus.h>
#include "freenetconfd/freenetconfd.h"
#include "ubus.h"
static struct ubus_context *ubus = NULL;
static struct ubus_object main_object;
static const struct ubus_method fnd_methods[] = {};
static struct ubus_object_type main_object_type =
UBUS_OBJECT_TYPE("freenetconfd", fnd_methods);
static struct ubus_object main_object =
{
.name = "netconf",
.type = &main_object_type,
.methods = fnd_methods,
.n_methods = ARRAY_SIZE(fnd_methods),
};
int
ubus_init(void)
{
ubus = ubus_connect(NULL);
if (!ubus) return -1;
__LOGLEVEL_MAX
};
struct ubus_context *cloudc_ctx;
static const struct blobmsg_policy handle_loglevel_policy[] = {
[LOGLEVEL] = { .name = "loglevel", .type = BLOBMSG_TYPE_STRING },
};
static const struct ubus_method cloudc_object_methods[] = {
//{.name = "disable", .handler = handle_cloudc_feature_down},
UBUS_METHOD("loglevel", handle_loglevel_update, handle_loglevel_policy),
};
static struct ubus_object_type cloudc_object_type =
UBUS_OBJECT_TYPE("cloudc", cloudc_object_methods);
static struct ubus_object cloudc_object = {
.name = "cloudc",
.type = &cloudc_object_type,
.methods = cloudc_object_methods,
.n_methods = ARRAY_SIZE(cloudc_object_methods),
};
static int handle_loglevel_update(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__LOGLEVEL_MAX];
char *log_buf = NULL;
char cmd[128] = {0};
}
ubus_send_reply(ctx, req, buf.head);
return UBUS_STATUS_OK;
}
static const struct ubus_method apClient_methods[] = {
// UBUS_METHOD("scan", apClient_scan, scan_policy),
UBUS_METHOD("connect", apClient_connect, connect_policy),
};
static struct ubus_object_type apClient_object_type =
UBUS_OBJECT_TYPE("rewifi", apClient_methods);
static struct ubus_object apClient_object = {
.name = "rewifi",
.type = &apClient_object_type,
.methods = apClient_methods,
.n_methods = ARRAY_SIZE(apClient_methods),
};
static void server_main(void)
{
int ret;
ret = ubus_add_object(ctx, &apClient_object);
if (ret) fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
.param = UM_PARAM_INITER(umc.policy.radio),
.cfg = LIST_HEAD_INIT(umc.uci.radio.cfg),
.tmp = LIST_HEAD_INIT(umc.uci.radio.tmp),
.uci_type = UM_UCI_INTF_RADIO,
},
.wlan = {
.param = UM_PARAM_INITER(umc.policy.wlan),
.cfg = LIST_HEAD_INIT(umc.uci.wlan.cfg),
.tmp = LIST_HEAD_INIT(umc.uci.wlan.tmp),
.uci_type = UM_UCI_INTF_WLAN,
},
},
.obj = {
.methods= um_user_object_methods,
.type = UBUS_OBJECT_TYPE("umd", um_user_object_methods),
.object = {
.name = "user-manage",
.type = &umc.obj.type,
.methods = um_user_object_methods,
.n_methods = os_count_of(um_user_object_methods),
}
},
};
static void
handle_signal(int signo)
{
uloop_end();
static struct blob_buf b;
static int notify;
static int error_logged = 0;
static int ubus_handle_metrics(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg);
static void ubus_subscribe_cb(struct ubus_context *ctx, struct ubus_object *obj);
static const struct ubus_method ubus_object_methods[] = {
UBUS_METHOD_NOARG("metrics", ubus_handle_metrics),
};
static struct ubus_object_type ubus_object_type =
UBUS_OBJECT_TYPE("dnsmasq", ubus_object_methods);
static struct ubus_object ubus_object = {
.name = "dnsmasq",
.type = &ubus_object_type,
.methods = ubus_object_methods,
.n_methods = ARRAY_SIZE(ubus_object_methods),
.subscribe_cb = ubus_subscribe_cb,
};
static void ubus_subscribe_cb(struct ubus_context *ctx, struct ubus_object *obj)
{
(void)ctx;
my_syslog(LOG_DEBUG, _("UBus subscription callback: %s subscriber(s)"), obj->has_subscribers ? "1" : "0");
notify = obj->has_subscribers;
}
static const struct ubus_method system_methods[] = {
UBUS_METHOD_NOARG("board", system_board),
UBUS_METHOD_NOARG("info", system_info),
UBUS_METHOD_NOARG("upgrade", system_upgrade),
UBUS_METHOD("watchdog", watchdog_set, watchdog_policy),
UBUS_METHOD("signal", proc_signal, signal_policy),
/* must remain at the end as it ia not always loaded */
UBUS_METHOD("nandupgrade", nand_set, nand_policy),
};
static struct ubus_object_type system_object_type =
UBUS_OBJECT_TYPE("system", system_methods);
static struct ubus_object system_object = {
.name = "system",
.type = &system_object_type,
.methods = system_methods,
.n_methods = ARRAY_SIZE(system_methods),
.subscribe_cb = procd_subscribe_cb,
};
void
procd_bcast_event(char *event, struct blob_attr *msg)
{
int ret;
if (!notify)
blobmsg_add_string(&b, "longitude", longitude);
blobmsg_add_string(&b, "elevation", elevation);
blobmsg_add_string(&b, "course", course);
blobmsg_add_string(&b, "speed", speed);
}
ubus_send_reply(ctx, req, b.head);
return UBUS_STATUS_OK;
}
static const struct ubus_method gps_methods[] = {
UBUS_METHOD_NOARG("info", gps_info),
};
static struct ubus_object_type gps_object_type =
UBUS_OBJECT_TYPE("gps", gps_methods);
static struct ubus_object gps_object = {
.name = "gps",
.type = &gps_object_type,
.methods = gps_methods,
.n_methods = ARRAY_SIZE(gps_methods),
};
static void
ubus_connect_handler(struct ubus_context *ctx)
{
int ret;
ret = ubus_add_object(ctx, &gps_object);
if (ret)
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
return UBUS_STATUS_OK;
}
static struct ubus_method lowlevel_methods[] = {
UBUS_METHOD("swRegRD", sw_reg_read, sw_reg_read_policy),
UBUS_METHOD("swRegWR", sw_reg_write, sw_reg_write_policy),
};
static struct ubus_object_type lowlevel_object_type =
UBUS_OBJECT_TYPE("lowlevel", lowlevel_methods);
static struct ubus_object lowlevel_object = {
.name = "lowlevel",
.type = &lowlevel_object_type,
.methods = lowlevel_methods,
.n_methods = ARRAY_SIZE(lowlevel_methods),
};
void lowlevel_add_to_ubus(void)
{
int ret;
ret = ubus_add_object(ctx, &lowlevel_object);
