#include <jni.h>
#include <japi/vppjni.h>
#include <japi/vppjni_bridge_domain.h>
+#include <japi/vppjni_env.h>
#include <japi/org_openvpp_vppjapi_vppConn.h>
#include <japi/org_openvpp_vppjapi_vppApi.h>
#include <api/vpe_all_api_h.h>
#undef vl_printfun
+#define VPPJNI_DEBUG 0
+
+#if VPPJNI_DEBUG == 1
+ #define DEBUG_LOG(...) clib_warning(__VA_ARGS__)
+#else
+ #define DEBUG_LOG(...)
+#endif
+
static int connect_to_vpe(char *name);
/*
void __stack_chk_guard (void) __attribute__((weak));
void __stack_chk_guard (void) { }
+BIND_JAPI_CLASS(vppBridgeDomainDetails, "()V");
+BIND_JAPI_BOOL_FIELD(vppBridgeDomainDetails, arpTerm);
+BIND_JAPI_BOOL_FIELD(vppBridgeDomainDetails, flood);
+BIND_JAPI_BOOL_FIELD(vppBridgeDomainDetails, forward);
+BIND_JAPI_BOOL_FIELD(vppBridgeDomainDetails, learn);
+BIND_JAPI_BOOL_FIELD(vppBridgeDomainDetails, uuFlood);
+BIND_JAPI_INT_FIELD(vppBridgeDomainDetails, bdId);
+BIND_JAPI_STRING_FIELD(vppBridgeDomainDetails, name);
+BIND_JAPI_STRING_FIELD(vppBridgeDomainDetails, bviInterfaceName);
+BIND_JAPI_OBJ_FIELD(vppBridgeDomainDetails, interfaces, "[Lorg/openvpp/vppjapi/vppBridgeDomainInterfaceDetails;");
+
+BIND_JAPI_CLASS(vppBridgeDomainInterfaceDetails, "()V");
+BIND_JAPI_BYTE_FIELD(vppBridgeDomainInterfaceDetails, splitHorizonGroup);
+BIND_JAPI_STRING_FIELD(vppBridgeDomainInterfaceDetails, interfaceName);
+
+BIND_JAPI_CLASS(vppInterfaceCounters, "(JJJJJJJJJJJJJJJJJJJJJJ)V");
+BIND_JAPI_CLASS(vppInterfaceDetails, "(ILjava/lang/String;I[BBBBBIBBIIBBBBIIII)V");
+BIND_JAPI_CLASS(vppIPv4Address, "(IB)V");
+BIND_JAPI_CLASS(vppIPv6Address, "([BB)V");
+BIND_JAPI_CLASS(vppL2Fib, "([BZLjava/lang/String;ZZ)V");
+BIND_JAPI_CLASS(vppVersion, "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+BIND_JAPI_CLASS(vppVxlanTunnelDetails, "(IIIII)V");
+
void vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
{
/*
(JNIEnv *env, jobject obj)
{
vppjni_main_t * jm = &vppjni_main;
- jmethodID constr;
- // TODO: cache this
- jclass cls = (*env)->FindClass(env, "org/openvpp/vppjapi/vppVersion");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return NULL;
- }
-
- constr = (*env)->GetMethodID(env, cls, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return NULL;
- }
vppjni_lock (jm, 11);
jstring progName = (*env)->NewStringUTF(env, (char *)jm->program_name);
jstring buildDate = (*env)->NewStringUTF(env, (char *)jm->build_date);
vppjni_unlock (jm);
- return (*env)->NewObject(env, cls, constr, progName, buildDir, version, buildDate);
+ return vppVersionObject(env, progName, buildDir, version, buildDate);
}
static int jm_show_version (vppjni_main_t *jm)
return rv;
}
+JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_setInterfaceDescription
+ (JNIEnv *env, jobject obj, jstring ifName, jstring ifDesc)
+{
+ int rv = 0;
+ vppjni_main_t * jm = &vppjni_main;
+ uword * p;
+ u32 sw_if_index = ~0;
+ sw_if_config_t *cfg;
+
+ const char *if_name_str = (*env)->GetStringUTFChars (env, ifName, 0);
+ const char *if_desc_str = (*env)->GetStringUTFChars (env, ifDesc, 0);
+
+ vppjni_lock (jm, 23);
+
+ p = hash_get_mem (jm->sw_if_index_by_interface_name, if_name_str);
+ if (p == 0) {
+ rv = -1;
+ goto out;
+ }
+ sw_if_index = (jint) p[0];
+
+ u8 *if_desc = 0;
+ vec_validate_init_c_string (if_desc, if_desc_str, strlen(if_desc_str));
+ (*env)->ReleaseStringUTFChars (env, ifDesc, if_desc_str);
+
+ p = hash_get (jm->sw_if_config_by_sw_if_index, sw_if_index);
+ if (p != 0) {
+ cfg = (sw_if_config_t *) (p[0]);
+ if (cfg->desc)
+ vec_free(cfg->desc);
+ }
+ else {
+ cfg = (sw_if_config_t *) clib_mem_alloc(sizeof(sw_if_config_t));
+ hash_set (jm->sw_if_config_by_sw_if_index, sw_if_index, cfg);
+ }
+
+ cfg->desc = if_desc;
+
+out:
+ (*env)->ReleaseStringUTFChars (env, ifName, if_name_str);
+ vppjni_unlock (jm);
+ return rv;
+}
+
+JNIEXPORT jstring JNICALL Java_org_openvpp_vppjapi_vppConn_getInterfaceDescription
+(JNIEnv * env, jobject obj, jstring ifName)
+{
+ vppjni_main_t * jm = &vppjni_main;
+ u32 sw_if_index = ~0;
+ uword * p;
+ const char *if_name_str = (*env)->GetStringUTFChars (env, ifName, 0);
+ jstring ifDesc = NULL;
+
+ vppjni_lock (jm, 24);
+ p = hash_get_mem (jm->sw_if_index_by_interface_name, if_name_str);
+ if (p == 0)
+ goto out;
+
+ sw_if_index = (jint) p[0];
+
+ p = hash_get (jm->sw_if_config_by_sw_if_index, sw_if_index);
+ if (p == 0)
+ goto out;
+
+ sw_if_config_t *cfg = (sw_if_config_t *) (p[0]);
+ u8 * s = format (0, "%s%c", cfg->desc, 0);
+ ifDesc = (*env)->NewStringUTF(env, (char *)s);
+
+out:
+ vppjni_unlock (jm);
+
+ return ifDesc;
+}
+
JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_clientConnect
(JNIEnv *env, jobject obj, jstring clientName)
{
h->flags |= MHEAP_FLAG_THREAD_SAFE;
jm->reply_hash = hash_create (0, sizeof (uword));
- jm->callback_hash = hash_create (0, sizeof (uword));
- jm->ping_hash = hash_create (0, sizeof (uword));
+ //jm->callback_hash = hash_create (0, sizeof (uword));
+ //jm->ping_hash = hash_create (0, sizeof (uword));
jm->api_main = am;
vjbd_main_init(&jm->vjbd_main);
jm->sw_if_index_by_interface_name =
hash_create_string (0, sizeof (uword));
+ jm->sw_if_config_by_sw_if_index =
+ hash_create (0, sizeof (uword));
{
// call control ping first to attach rx thread to java thread
if (rv != 0)
clib_warning ("unable to subscribe to stats (rv: %d)", rv);
}
- clib_warning ("clientConnect result: %d", rv);
+ DEBUG_LOG ("clientConnect result: %d", rv);
return rv;
}
jm->context_id_received = context;
- clib_warning("Received generic reply for msg id %d", msg_id);
+ DEBUG_LOG ("Received generic reply for msg id %d", msg_id);
/* A generic reply, successful, we're done */
if (retval >= 0 && total_bytes == sizeof(*mp))
vppjni_main_t * jm = &vppjni_main;
sw_interface_stats_t *s;
u32 sw_if_index = swIfIndex;
- jmethodID constr;
jobject result = NULL;
- // TODO: cache this
- jclass cls = (*env)->FindClass(env, "org/openvpp/vppjapi/vppInterfaceCounters");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return NULL;
- }
-
- constr = (*env)->GetMethodID(env, cls, "<init>", "(JJJJJJJJJJJJJJJJJJJJJJ)V");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return NULL;
- }
-
vppjni_lock (jm, 16);
if (sw_if_index >= vec_len(jm->sw_if_stats_by_sw_if_index)) {
goto out;
}
- result = (*env)->NewObject(env, cls, constr,
+ result = vppInterfaceCountersObject(env,
s->rx.octets, s->rx.pkts.ip4, s->rx.pkts.ip6, s->rx.pkts.unicast,
s->rx.pkts.multicast, s->rx.pkts.broadcast, s->rx.pkts.discard,
s->rx.pkts.fifo_full, s->rx.pkts.error, s->rx.pkts.unknown_proto,
{
vppjni_main_t * jm = &vppjni_main;
- vppjni_lock (jm, 10);
+ vppjni_lock (jm, 21);
vec_reset_length(jm->sw_if_table);
vppjni_unlock (jm);
}
+static jobjectArray sw_if_dump_get_interfaces ();
-JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_swInterfaceDump
+JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_swInterfaceDump
(JNIEnv * env, jobject obj, jbyte name_filter_valid, jbyteArray name_filter)
{
vppjni_main_t *jm = &vppjni_main;
u32 my_context_id;
int rv;
rv = vppjni_sanity_check (jm);
- if (rv) return rv;
+ if (rv) {
+ clib_warning("swInterfaceDump sanity_check rv = %d", rv);
+ return NULL;
+ }
+
vppjni_lock (jm, 7);
my_context_id = vppjni_get_context_id (jm);
- jbyte * name_filterP = (*env)->GetByteArrayElements (env, name_filter, NULL);
- int cnt = (*env)->GetArrayLength (env, name_filter);
+ jsize cnt = (*env)->GetArrayLength (env, name_filter);
M(SW_INTERFACE_DUMP, sw_interface_dump);
mp->context = clib_host_to_net_u32 (my_context_id);
if (cnt > sizeof(mp->name_filter))
cnt = sizeof(mp->name_filter);
- memcpy ((char *) mp->name_filter, name_filterP, cnt);
- (*env)->ReleaseByteArrayElements (env, name_filter, name_filterP, 0);
+ (*env)->GetByteArrayRegion(env, name_filter, 0, cnt, (jbyte *)mp->name_filter);
- clib_warning("interface filter (%d, %s, len: %d)", mp->name_filter_valid, (char *)mp->name_filter, cnt);
+ DEBUG_LOG ("interface filter (%d, %s, len: %d)", mp->name_filter_valid, (char *)mp->name_filter, cnt);
- hash_set (jm->callback_hash, my_context_id, (*env)->NewGlobalRef(env, obj));
jm->collect_indices = 1;
S;
M(CONTROL_PING, control_ping);
mp->context = clib_host_to_net_u32 (my_context_id);
- // this control ping will mark end of interface dump
- hash_set (jm->ping_hash, my_context_id, VL_API_SW_INTERFACE_DUMP);
-
S;
}
vppjni_unlock (jm);
WNR;
- return my_context_id;
+
+ vppjni_lock (jm, 7);
+ jobjectArray result = sw_if_dump_get_interfaces(env);
+ vppjni_unlock (jm);
+ return result;
}
-static int sw_if_dump_call_all_callbacks (jobject obj)
+static jobjectArray sw_if_dump_get_interfaces (JNIEnv * env)
{
vppjni_main_t * jm = &vppjni_main;
sw_interface_details_t *sw_if_details;
- int rc = 0;
u32 i;
- JNIEnv *env = jm->jenv;
+ int len = vec_len(jm->sw_if_dump_if_indices);
- for (i = 0; i < vec_len(jm->sw_if_dump_if_indices); i++) {
+ jobjectArray ifArray = vppInterfaceDetailsArray(env, len);
+
+ for (i = 0; i < len; i++) {
u32 sw_if_index = jm->sw_if_dump_if_indices[i];
ASSERT(sw_if_index < vec_len(jm->sw_if_table));
sw_if_details = &jm->sw_if_table[sw_if_index];
jint vtrTag1 = sw_if_details->vtr_tag1;
jint vtrTag2 = sw_if_details->vtr_tag2;
- jmethodID jmtdIfDetails = jm->jmtdIfDetails;
-
jbyte adminUpDown = sw_if_details->admin_up_down;
jbyte linkUpDown = sw_if_details->link_up_down;
jbyte linkDuplex = sw_if_details->link_duplex;
jbyte subOuterVlanIdAny = sw_if_details->sub_outer_vlan_id_any;
jbyte subInnerVlanIdAny = sw_if_details->sub_inner_vlan_id_any;
- clib_warning("Method: %p, Calling method", jm->jmtdIfDetails);
- (*env)->CallVoidMethod(env, obj, jmtdIfDetails, ifIndex, ifname,
+ jobject ifObj = vppInterfaceDetailsObject(env,
+ ifIndex, ifname,
supIfIndex, physAddr, adminUpDown, linkUpDown,
linkDuplex, linkSpeed, subId, subDot1ad,
subNumberOfTags, subOuterVlanId, subInnerVlanId,
subExactMatch, subDefault, subOuterVlanIdAny,
subInnerVlanIdAny, vtrOp, vtrPushDot1q, vtrTag1, vtrTag2);
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rc = 1;
- goto out;
- }
- }
- clib_warning("Method: %p, Calling method (null arg)", jm->jmtdIfDetails);
- jmethodID jmtdIfDetails = jm->jmtdIfDetails;
- (*env)->CallVoidMethod(env, obj, jmtdIfDetails, -1, NULL, -1, NULL, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rc = 1;
- goto out;
+ (*env)->SetObjectArrayElement(env, ifArray, i, ifObj);
}
- clib_warning("Done");
-
-out:
jm->collect_indices = 0;
vec_reset_length(jm->sw_if_dump_if_indices);
- return rc;
+ return ifArray;
}
JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_findOrAddBridgeDomainId
(JNIEnv * env, jobject obj, jstring bridgeDomain)
{
vppjni_main_t * jm = &vppjni_main;
+ static u8 * bd_name = 0;
jint rv = -1;
- const char * bd_name = (*env)->GetStringUTFChars (env, bridgeDomain, NULL);
-
- vppjni_lock (jm, 6);
+ const char * bdName = (*env)->GetStringUTFChars (env, bridgeDomain, NULL);
- rv = (jint)vjbd_find_or_add_bd (&jm->vjbd_main, (u8 *)bd_name);
+ vec_validate_init_c_string (bd_name, bdName, strlen(bdName));
+ (*env)->ReleaseStringUTFChars (env, bridgeDomain, bdName);
+ vppjni_lock (jm, 6);
+ rv = (jint)vjbd_find_or_add_bd (&jm->vjbd_main, bd_name);
vppjni_unlock (jm);
- (*env)->ReleaseStringUTFChars (env, bridgeDomain, bd_name);
-
+ _vec_len(bd_name) = 0;
return rv;
}
(JNIEnv * env, jobject obj, jstring bridgeDomain)
{
vppjni_main_t * jm = &vppjni_main;
+ static u8 * bd_name = 0;
jint rv = -1;
- const char * bd_name = (*env)->GetStringUTFChars(env, bridgeDomain, NULL);
+ const char * bdName = (*env)->GetStringUTFChars (env, bridgeDomain, NULL);
- vppjni_lock(jm, 7);
+ vec_validate_init_c_string (bd_name, bdName, strlen(bdName));
+ (*env)->ReleaseStringUTFChars (env, bridgeDomain, bdName);
+ vppjni_lock (jm, 20);
rv = (jint)vjbd_id_from_name(&jm->vjbd_main, (u8 *)bd_name);
+ vppjni_unlock (jm);
- vppjni_unlock(jm);
-
- (*env)->ReleaseStringUTFChars(env, bridgeDomain, bd_name);
+ _vec_len(bd_name) = 0;
return rv;
}
sw_if_details->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any;
hash_set_mem (jm->sw_if_index_by_interface_name, s, sw_if_index);
- clib_warning("Got interface %s", (char *)s);
+ DEBUG_LOG ("Got interface %s", (char *)s);
/* In sub interface case, fill the sub interface table entry */
if (mp->sw_if_index != mp->sup_sw_if_index) {
bd_oper->flood = mp->flood != 0;
bd_oper->forward = mp->forward != 0;
bd_oper->learn = mp->learn != 0;
- bd_oper->uu_flood = mp->flood != 0;
+ bd_oper->uu_flood = mp->uu_flood != 0;
bd_oper->arp_term = mp->arp_term != 0;
bd_oper->bvi_sw_if_index = ntohl (mp->bvi_sw_if_index);
bd_oper->n_sw_ifs = ntohl (mp->n_sw_ifs);
/* setting BridgeDomainDetails */
- jclass bddClass = (*env)->FindClass(env, "org/openvpp/vppjapi/vppBridgeDomainDetails");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
-
- jmethodID midInit = (*env)->GetMethodID(env, bddClass, "<init>", "()V");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- jobject bddObj = (*env)->NewObject(env, bddClass, midInit);
+ jobject bddObj = vppBridgeDomainDetailsObject(env);
u8 *vec_bd_name = vjbd_oper_name_from_id(bdm, bd_id);
if (NULL == vec_bd_name) {
rv = NULL;
goto out;
}
- jfieldID fidName = (*env)->GetFieldID(env, bddClass, "name", "Ljava/lang/String;");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetObjectField(env, bddObj, fidName, bdName);
- jfieldID fidBdId = (*env)->GetFieldID(env, bddClass, "bdId", "I");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetIntField(env, bddObj, fidBdId, bdId);
-
- jboolean flood = bd_oper->flood;
- jfieldID fidFlood = (*env)->GetFieldID(env, bddClass, "flood", "Z");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetBooleanField(env, bddObj, fidFlood, flood);
-
- jboolean uuFlood = bd_oper->uu_flood;
- jfieldID fidUuFlood = (*env)->GetFieldID(env, bddClass, "uuFlood", "Z");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetBooleanField(env, bddObj, fidUuFlood, uuFlood);
-
- jboolean forward = bd_oper->forward;
- jfieldID fidForward = (*env)->GetFieldID(env, bddClass, "forward", "Z");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetBooleanField(env, bddObj, fidForward, forward);
-
- jboolean learn = bd_oper->learn;
- jfieldID fidLearn = (*env)->GetFieldID(env, bddClass, "learn", "Z");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetBooleanField(env, bddObj, fidLearn, learn);
-
- jboolean arpTerm = bd_oper->arp_term;
- jfieldID fidArpTerm = (*env)->GetFieldID(env, bddClass, "arpTerm", "Z");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetBooleanField(env, bddObj, fidArpTerm, arpTerm);
+ set_vppBridgeDomainDetails_name(env, bddObj, bdName);
+ set_vppBridgeDomainDetails_bdId(env, bddObj, bdId);
+ set_vppBridgeDomainDetails_flood(env, bddObj, (jboolean)bd_oper->flood);
+ set_vppBridgeDomainDetails_uuFlood(env, bddObj, (jboolean)bd_oper->uu_flood);
+ set_vppBridgeDomainDetails_forward(env, bddObj, (jboolean)bd_oper->forward);
+ set_vppBridgeDomainDetails_learn(env, bddObj, (jboolean)bd_oper->learn);
+ set_vppBridgeDomainDetails_arpTerm(env, bddObj, (jboolean)bd_oper->arp_term);
jstring bviInterfaceName = NULL;
if (~0 != bd_oper->bvi_sw_if_index) {
goto out;
}
}
- jfieldID fidBviInterfaceName = (*env)->GetFieldID(env, bddClass, "bviInterfaceName", "Ljava/lang/String;");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetObjectField(env, bddObj, fidBviInterfaceName, bviInterfaceName);
+ set_vppBridgeDomainDetails_bviInterfaceName(env, bddObj, bviInterfaceName);
/* setting BridgeDomainInterfaceDetails */
- jclass bdidClass = (*env)->FindClass(env, "org/openvpp/vppjapi/vppBridgeDomainInterfaceDetails");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
-
- jfieldID fidInterfaceName = (*env)->GetFieldID(env, bdidClass, "interfaceName", "Ljava/lang/String;");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
-
- jfieldID fidSHG = (*env)->GetFieldID(env, bdidClass, "splitHorizonGroup", "B");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
-
u32 len = vec_len(bd_oper->bd_sw_if_oper);
ASSERT(len == bd_oper->n_sw_ifs);
- jobjectArray bdidArray = (*env)->NewObjectArray(env, len, bdidClass, NULL);
+ jobjectArray bdidArray = vppBridgeDomainInterfaceDetailsArray(env, len);
u32 i;
for (i = 0; i < len; i++) {
bd_sw_if_oper_t *sw_if_oper = &bd_oper->bd_sw_if_oper[i];
- jmethodID midBdidInit = (*env)->GetMethodID(env, bdidClass, "<init>", "()V");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- jobject bdidObj = (*env)->NewObject(env, bdidClass, midBdidInit);
+ jobject bdidObj = vppBridgeDomainInterfaceDetailsObject(env);
(*env)->SetObjectArrayElement(env, bdidArray, i, bdidObj);
u32 sw_if_index = sw_if_oper->sw_if_index;
rv = NULL;
goto out;
}
- (*env)->SetObjectField(env, bdidObj, fidInterfaceName, interfaceName);
- jbyte shg = sw_if_oper->shg;
- (*env)->SetByteField(env, bdidObj, fidSHG, shg);
+ set_vppBridgeDomainInterfaceDetails_interfaceName(env, bdidObj, interfaceName);
+ set_vppBridgeDomainInterfaceDetails_splitHorizonGroup(env, bdidObj, (jbyte)sw_if_oper->shg);
}
- jfieldID fidInterfaces = (*env)->GetFieldID(env, bddClass, "interfaces",
- "[Lorg/openvpp/vppjapi/vppBridgeDomainInterfaceDetails;");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- rv = NULL;
- goto out;
- }
- (*env)->SetObjectField(env, bddObj, fidInterfaces, bdidArray);
+ set_vppBridgeDomainDetails_interfaces(env, bddObj, bdidArray);
rv = bddObj;
static jobject l2_fib_create_object(JNIEnv *env, bd_l2fib_oper_t *l2_fib)
{
- jclass l2FibClass = (*env)->FindClass(env, "org/openvpp/vppjapi/vppL2Fib");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return NULL;
- }
-
- jmethodID midL2FIbInit = (*env)->GetMethodID(env, l2FibClass, "<init>", "([BZLjava/lang/String;ZZ)V");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return NULL;
- }
-
u32 sw_if_index = l2_fib->sw_if_index;
const char *str_if_name = interface_name_from_sw_if_index(sw_if_index);
if (NULL == str_if_name) {
jboolean filter = l2_fib->filter;
jboolean bridgedVirtualInterface = l2_fib->bvi;
- jobject l2FibObj = (*env)->NewObject(env, l2FibClass, midL2FIbInit,
- physAddr, staticConfig, outgoingInterface, filter,
- bridgedVirtualInterface);
-
- return l2FibObj;
+ return vppL2FibObject(env, physAddr, staticConfig, outgoingInterface, filter, bridgedVirtualInterface);
}
JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_l2FibTableDump
u32 count = vec_len(bd_oper->l2fib_oper);
bd_l2fib_oper_t *l2fib_oper = bd_oper->l2fib_oper;
- jclass l2FibClass = (*env)->FindClass(env, "org/openvpp/vppjapi/vppL2Fib");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- goto done;
- }
-
- l2FibArray = (*env)->NewObjectArray(env, count, l2FibClass, NULL);
-
- u32 pos = 0;
+ l2FibArray = vppL2FibArray(env, count);
for (i = 0; i < count; i++) {
bd_l2fib_oper_t *l2_fib = &l2fib_oper[i];
- if (1) {
- jobject l2FibObj = l2_fib_create_object(env, l2_fib);
- (*env)->SetObjectArrayElement(env, l2FibArray, pos, l2FibObj);
- pos++;
- }
+ jobject l2FibObj = l2_fib_create_object(env, l2_fib);
+ (*env)->SetObjectArrayElement(env, l2FibArray, i, l2FibObj);
}
done:
l2fib_oper->bvi = mp->bvi_mac;
}
+static int ipAddressDump
+(JNIEnv * env, jobject obj, jstring interfaceName, jboolean isIPv6)
+{
+ vppjni_main_t *jm = &vppjni_main;
+ vl_api_ip_address_dump_t * mp;
+ const char *if_name;
+ u32 my_context_id;
+ u32 sw_if_index;
+ f64 timeout;
+ uword *p;
+ int rv = 0;
+
+ if (NULL == interfaceName) {
+ return -1;
+ }
+
+ if_name = (*env)->GetStringUTFChars (env, interfaceName, NULL);
+ p = hash_get_mem (jm->sw_if_index_by_interface_name, if_name);
+ (*env)->ReleaseStringUTFChars (env, interfaceName, if_name);
+ if (p == 0) {
+ return -1;
+ }
+ sw_if_index = (u32) p[0];
+
+ rv = vppjni_sanity_check (jm);
+ if (0 != rv) {
+ return rv;
+ }
+
+ my_context_id = vppjni_get_context_id (jm);
+ M(IP_ADDRESS_DUMP, ip_address_dump);
+ mp->context = clib_host_to_net_u32 (my_context_id);
+ mp->sw_if_index = clib_host_to_net_u32(sw_if_index);
+ mp->is_ipv6 = isIPv6;
+ jm->is_ipv6 = isIPv6;
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+
+ WNR;
+
+ return rv;
+}
+
+JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_ipv4AddressDump
+(JNIEnv * env, jobject obj, jstring interfaceName)
+{
+ vppjni_main_t *jm = &vppjni_main;
+ jobject returnArray = NULL;
+ int i;
+
+ vppjni_lock (jm, 18);
+
+ vec_reset_length(jm->ipv4_addresses);
+
+ if (0 != ipAddressDump(env, obj, interfaceName, 0)) {
+ goto done;
+ }
+
+ u32 count = vec_len(jm->ipv4_addresses);
+ ipv4_address_t *ipv4_address = jm->ipv4_addresses;
+
+ jobjectArray ipv4AddressArray = vppIPv4AddressArray(env, count);
+
+ for (i = 0; i < count; i++) {
+ ipv4_address_t *address = &ipv4_address[i];
+
+ jint ip = address->ip;
+ jbyte prefixLength = address->prefix_length;
+
+ jobject ipv4AddressObj = vppIPv4AddressObject(env, ip, prefixLength);
+
+ (*env)->SetObjectArrayElement(env, ipv4AddressArray, i, ipv4AddressObj);
+ }
+
+ returnArray = ipv4AddressArray;
+
+done:
+ vppjni_unlock (jm);
+ return returnArray;
+}
+
+JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_ipv6AddressDump
+(JNIEnv * env, jobject obj, jstring interfaceName)
+{
+ vppjni_main_t *jm = &vppjni_main;
+ jobject returnArray = NULL;
+ int i;
+
+ vppjni_lock (jm, 19);
+
+ vec_reset_length(jm->ipv6_addresses);
+
+ if (0 != ipAddressDump(env, obj, interfaceName, 1)) {
+ goto done;
+ }
+
+ u32 count = vec_len(jm->ipv6_addresses);
+ ipv6_address_t *ipv6_address = jm->ipv6_addresses;
+
+ jobjectArray ipv6AddressArray = vppIPv6AddressArray(env, count);
+
+ for (i = 0; i < count; i++) {
+ ipv6_address_t *address = &ipv6_address[i];
+
+ jbyteArray ip = (*env)->NewByteArray(env, 16);
+ (*env)->SetByteArrayRegion(env, ip, 0, 16,
+ (signed char*)address->ip);
+
+ jbyte prefixLength = address->prefix_length;
+
+ jobject ipv6AddressObj = vppIPv6AddressObject(env, ip, prefixLength);
+
+ (*env)->SetObjectArrayElement(env, ipv6AddressArray, i, ipv6AddressObj);
+ }
+
+ returnArray = ipv6AddressArray;
+
+done:
+ vppjni_unlock (jm);
+ return returnArray;
+}
+
+static void vl_api_ip_address_details_t_handler (vl_api_ip_address_details_t * mp)
+{
+ vppjni_main_t * jm = &vppjni_main;
+
+ if (!jm->is_ipv6) {
+ ipv4_address_t *address = 0;
+ vec_add2(jm->ipv4_addresses, address, 1);
+ memcpy(&address->ip, mp->ip, 4);
+ address->prefix_length = mp->prefix_length;
+ } else {
+ ipv6_address_t *address = 0;
+ vec_add2(jm->ipv6_addresses, address, 1);
+ memcpy(address->ip, mp->ip, 16);
+ address->prefix_length = mp->prefix_length;
+ }
+}
+
+#define VXLAN_TUNNEL_INTERFACE_NAME_PREFIX "vxlan_tunnel"
+
+JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_vxlanTunnelDump
+(JNIEnv * env, jobject obj, jint swIfIndex)
+{
+ vppjni_main_t *jm = &vppjni_main;
+ vl_api_vxlan_tunnel_dump_t * mp;
+ jobjectArray returnArray = NULL;
+ u32 my_context_id;
+ f64 timeout;
+ int rv = 0;
+ int i;
+
+ vppjni_lock (jm, 22);
+
+ vec_reset_length(jm->vxlan_tunnel_details);
+
+ my_context_id = vppjni_get_context_id (jm);
+ M(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump);
+ mp->context = clib_host_to_net_u32 (my_context_id);
+ mp->sw_if_index = clib_host_to_net_u32 (swIfIndex);
+ S;
+
+ /* Use a control ping for synchronization */
+ {
+ vl_api_control_ping_t * mp;
+ M(CONTROL_PING, control_ping);
+ S;
+ }
+
+ WNR;
+ if (0 != rv) {
+ goto done;
+ }
+
+ u32 count = vec_len(jm->vxlan_tunnel_details);
+
+ jobjectArray vxlanTunnelDetailsArray = vppVxlanTunnelDetailsArray(env, count);
+
+ for (i = 0; i < count; i++) {
+ vxlan_tunnel_details_t *details = &jm->vxlan_tunnel_details[i];
+
+ jint src_address = details->src_address;
+ jint dst_address = details->dst_address;
+ jint encap_vrf_id = details->encap_vrf_id;
+ jint vni = details->vni;
+ jint decap_next_index = details->decap_next_index;
+
+ jobject vxlanTunnelDetailsObj = vppVxlanTunnelDetailsObject(env,
+ src_address, dst_address, encap_vrf_id, vni, decap_next_index);
+
+ (*env)->SetObjectArrayElement(env, vxlanTunnelDetailsArray, i,
+ vxlanTunnelDetailsObj);
+ }
+
+ returnArray = vxlanTunnelDetailsArray;
+
+done:
+ vppjni_unlock (jm);
+ return returnArray;
+}
+
+static void vl_api_vxlan_tunnel_details_t_handler
+(vl_api_vxlan_tunnel_details_t * mp)
+{
+ vppjni_main_t * jm = &vppjni_main;
+ vxlan_tunnel_details_t *tunnel_details;
+
+ vec_add2(jm->vxlan_tunnel_details, tunnel_details, 1);
+ tunnel_details->src_address = ntohl(mp->src_address);
+ tunnel_details->dst_address = ntohl(mp->dst_address);
+ tunnel_details->encap_vrf_id = ntohl(mp->encap_vrf_id);
+ tunnel_details->vni = ntohl(mp->vni);
+ tunnel_details->decap_next_index = ntohl(mp->decap_next_index);
+}
+
/* cleanup handler for RX thread */
void cleanup_rx_thread(void *arg)
{
i32 retval = ntohl(mp->retval);
if (retval >= 0) {
- clib_warning ("show version request succeeded(%d)");
+ DEBUG_LOG ("show version request succeeded(%d)");
strncpy((char*)jm->program_name, (const char*)mp->program,
sizeof(jm->program_name)-1);
jm->program_name[sizeof(jm->program_name)-1] = 0;
{
vppjni_main_t * jm = &vppjni_main;
i32 retval = ntohl(mp->retval);
- u32 context = clib_host_to_net_u32 (mp->context);
- uword *p = NULL;
-
jm->retval = retval;
// attach to java thread if not attached
jm->retval = -999;
goto out;
}
- // jm->jenv is now stable global reference that can be reused
+ // jm->jenv is now stable global reference that can be reused (only within RX thread)
+#if 0
+ // ! callback system removed for now
+ //
// get issuer msg-id
p = hash_get (jm->ping_hash, context);
if (p != 0) { // ping marks end of some dump call
// delete global reference
(*env)->DeleteGlobalRef(env, obj);
}
+#endif
+
out:
jm->result_ready = 1;
}
return JNI_ERR;
}
- jclass cls = (*env)->FindClass(env, "org/openvpp/vppjapi/vppApiCallbacks");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
- return JNI_ERR;
- }
-
- jm->jmtdIfDetails =
- (*env)->GetMethodID(env, cls, "interfaceDetails", "(ILjava/lang/String;I[BBBBBIBBIIBBBBIIII)V");
- if ((*env)->ExceptionCheck(env)) {
- (*env)->ExceptionDescribe(env);
+ if (vppjni_init(env) != 0) {
return JNI_ERR;
}
- // methods are not local references they stay forever
- // jclass is local reference let's hold global ref to it
- jm->jcls = (*env)->NewGlobalRef(env, cls);
-
jm->jvm = vm;
return JNI_VERSION_1_6;
}
return;
}
- if (jm->jcls != NULL) {
- (*env)->DeleteGlobalRef(env, jm->jcls);
- jm->jcls = NULL;
- }
+ vppjni_uninit(env);
jm->jenv = NULL;
jm->jvm = NULL;
_(SW_INTERFACE_SET_FLAGS, sw_interface_set_flags) \
_(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
_(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
-_(L2_FIB_TABLE_ENTRY, l2_fib_table_entry)
+_(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
+_(IP_ADDRESS_DETAILS, ip_address_details) \
+_(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details)
static int connect_to_vpe(char *name)
{
Code Review / vpp.git / blobdiff