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;
}
/**
* find all VLAN in database with summary
* used to VLAN module.
*
* */
int ubus_vlan_checkout_message(void)
{
blob_buf_init(&b, 0);
blobmsg_add_u8(&b, "mode", 0);
ubus_invoke(ctx, id, "find", b.head, vlanlist_checkout_callback, NULL, timeout * 1000);
return LR_SUCCESS;
}
int ubus_bind_port(u16 vlanid, u16 portid, bool bind)
{
blob_buf_init(&b, 0);
blobmsg_add_u16(&b, "vid", vlanid);
blobmsg_add_u8(&b, "portid", (u8)portid);
blobmsg_add_u8(&b, "bind", bind ? true : false);
ubus_invoke(ctx, id, "port", b.head, swVlan_result_data, NULL, timeout * 1000);
return LR_SUCCESS;
}
int ubus_find_vlan_message(u16 vlanid)
{
blob_buf_init(&b, 0);
blobmsg_add_u8(&b, "mode", 1);
blobmsg_add_u16(&b, "vid", vlanid);
ubus_invoke(ctx, id, "find", b.head, swVlan_result_data, NULL, timeout * 1000);
return LR_SUCCESS;
}
int ubus_vlan_create_message(u16 vlanid, u8 mstid)
{
blob_buf_init(&b, 0);
blobmsg_add_u16(&b, "vid", vlanid);
if(mstid > 0 && mstid < 64)
blobmsg_add_u8(&b, "mstid", mstid);
ubus_invoke(ctx, id, "new", b.head, create_vlan_callback, NULL, timeout * 1000);
return LR_SUCCESS;
}
int ubus_vlan_delete_message(u16 vlanid, bool all)
{
u8 dsgMode = 1;
blob_buf_init(&b, 0);
if(all){
dsgMode = 0;
}else{
blobmsg_add_u16(&b, "vid", vlanid);
dsgMode = 1;
}
blobmsg_add_u8(&b, "mode", dsgMode);
ubus_invoke(ctx, id, "delete", b.head, delete_vlan_callback, NULL, timeout * 1000);
return LR_SUCCESS;
}
int UBusRequest::Invoke(const char *method, blob_attr *b)
{
int ret = 0;
ILOG_TRACE(UBUS_REQ);
ILOG_DEBUG(UBUS_REQ, "%s enter\n", __func__);
ret = ubus_invoke(_ubus, _id, method, b , data_cb, this, 0);
if (ret) {
ILOG_ERROR(UBUS_REQ,"ubus_invoke failed [id=%d, method=%s, err=%s]\n",
_id, method, ubus_strerror(ret));
return ret;
}
ILOG_DEBUG(UBUS_REQ,"ubus_invoke done [id=%d, method=%s]\n",
_id, method, ubus_strerror(ret));
ILOG_DEBUG(UBUS_REQ, "%s exit\n", __func__);
return 0;
}
/* find all VLAN in database with detail */
int ubus_find_all_vlan_message(bool summary)
{
u8 mode = 3;
if(summary)
mode = 0;
blob_buf_init(&b, 0);
blobmsg_add_u8(&b, "mode", mode);
ubus_invoke(ctx, id, "find", b.head, swVlan_result_data, NULL, timeout * 1000);
/*
struct ubus_request req;
ubus_invoke_async(ctx, id, "find", b.head, &req);
ubus_complete_request_async(ctx,&req);
swVlan_result_data();
*/
return LR_SUCCESS;
}
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;
}
static void init_loop_cb(struct uloop_timeout *timeout)
{
uint32_t id;
// replace *d
char key_iv[32] = {0};
char repeater_pubkey[] = "-----BEGIN PUBLIC KEY-----\n"\
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyUF9+Td53E0lEqP8eRyM\n"\
"DoREPIety4BJscApuPwcGxiVA+75mYw8AFKlTaWlLL7w/qyuxnOiNm6TTFCxJGI1\n"\
"C9GnABm8myC5hnDSC6qE+E1Al6wZgyI4rkC+Qr7GFI9B8r9bM+RdKyMxD9JuXUcx\n"\
"+rx/TPnJttUfAkCloYStd5LiCel6c/bfWiR5hyxLjXC5Cz5cdpzXwvyvgEBvZHxX\n"\
"A5jqPVfWcJ3P3s88ogPxx52iM4dzLtzWB6BOmZA/3SbvZle2Efy7mVAl/9gkwvgf\n"\
"Dm/TSnMbnUBim3H5CIlECsvs2RuvI5og0S3oEO4B8TQQjujSqbA6h+EcZc9Djmh2\n"\
"vQIDAQAB\n"\
"-----END PUBLIC KEY-----\n";
unsigned char *encrypted=malloc(MAX_ALLOC_LEN);
unsigned char *base64=malloc(MAX_ALLOC_LEN);
RAND_seed(rnd_seed, sizeof rnd_seed); /* or RSA_PKCS1_PADDING/OAEP may fail */
random_uuid(repeater_key);
random_uuid(repeater_iv);
memcpy(key_iv, repeater_key, 16);
memcpy(key_iv+16, repeater_iv, 16);
int encrypted_length= public_encrypt(key_iv,
32,
repeater_pubkey,
encrypted);
if(encrypted_length == -1)
{
printLastError("Public Encrypt failed ");
exit(0);
}
printf("Encrypted length =%d\n",encrypted_length);
printf("Try to init_loop_cb...\n");
int base64_length = base64Encode(base64, encrypted, encrypted_length);
// printf("base64 len: %d\n", base64_length);
// printf("base64: %s\n", base64);
if(ubus_lookup_id(sys->tbus_ctx, "netapi", &id)){
dlog("can't lookup netapi\n");
goto fail;
}
blob_buf_init(&traffic_b, 0);
blobmsg_add_field(&traffic_b, BLOBMSG_TYPE_UNSPEC,
"data", base64, base64_length);
ubus_invoke(sys->tbus_ctx, id, "init", traffic_b.head,
receive_call_result_data, NULL, TRAFFICD_INIT_TIMEOUT);
free(encrypted);
free(base64);
return;
fail:
free(encrypted);
free(base64);
uloop_timeout_set(&sd->timeout_init, TRAFFICD_INIT_LOOP_TIME);
}
