diff options
Diffstat (limited to 'vpp-api')
47 files changed, 6149 insertions, 0 deletions
diff --git a/vpp-api/Makefile.am b/vpp-api/Makefile.am new file mode 100644 index 00000000000..5b3265404ea --- /dev/null +++ b/vpp-api/Makefile.am @@ -0,0 +1,2 @@ +AUTOMAKE_OPTIONS = foreign +SUBDIRS = java python diff --git a/vpp-api/configure.ac b/vpp-api/configure.ac new file mode 100644 index 00000000000..31ee6656533 --- /dev/null +++ b/vpp-api/configure.ac @@ -0,0 +1,15 @@ +AC_INIT(vpp-api, 1.0.0) +LT_INIT +AC_CONFIG_MACRO_DIR([m4]) +AC_CONFIG_SUBDIRS([java]) +AM_INIT_AUTOMAKE +AM_SILENT_RULES + +AM_PROG_AS +AC_PROG_CC +AM_PROG_CC_C_O + +AC_OUTPUT([python/Makefile]) +AC_CONFIG_FILES([Makefile]) +AC_OUTPUT + diff --git a/vpp-api/java/Makefile.am b/vpp-api/java/Makefile.am new file mode 100644 index 00000000000..0e16b72b38f --- /dev/null +++ b/vpp-api/java/Makefile.am @@ -0,0 +1,93 @@ +# Copyright (c) 2015 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +AUTOMAKE_OPTIONS = foreign subdir-objects +ACLOCAL_AMFLAGS = -I m4 +AM_CFLAGS = -Wall + +noinst_PROGRAMS = +BUILT_SOURCES = +bin_PROGRAMS = +CLEANFILES = +lib_LTLIBRARIES = + +nobase_include_HEADERS = \ + japi/org_openvpp_vppjapi_vppApi.h \ + japi/org_openvpp_vppjapi_vppConn.h + +lib_LTLIBRARIES += libvppjni.la + +libvppjni_la_SOURCES = japi/vppjni.c japi/vppapi.c japi/vppjni_env.h japi/vppjni_env.c +libvppjni_la_LIBADD = -lvlibmemoryclient -lvlibapi -lsvm -lvppinfra \ + -lpthread -lm -lrt +libvppjni_la_LDFLAGS = -module +libvppjni_la_CPPFLAGS = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/linux + +jarfile = vppjapi-$(PACKAGE_VERSION).jar +packagedir = org/openvpp/vppjapi +JAVAROOT = . + +$(jarfile): libvppjni.la + cd .libs ; $(JAR) cf $(JARFLAGS) ../$@ libvppjni.so.0.0.0 ../$(packagedir)/*.class ; cd .. + +BUILT_SOURCES += japi/org_openvpp_vppjapi_vppConn.h japi/vppapi.c + +japi/org_openvpp_vppjapi_vppConn.h: \ + japi/org/openvpp/vppjapi/vppVersion.java \ + japi/org/openvpp/vppjapi/vppInterfaceDetails.java \ + japi/org/openvpp/vppjapi/vppInterfaceCounters.java \ + japi/org/openvpp/vppjapi/vppBridgeDomainDetails.java \ + japi/org/openvpp/vppjapi/vppBridgeDomainInterfaceDetails.java \ + japi/org/openvpp/vppjapi/vppL2Fib.java \ + japi/org/openvpp/vppjapi/vppIPv4Address.java \ + japi/org/openvpp/vppjapi/vppIPv6Address.java \ + japi/org/openvpp/vppjapi/vppVxlanTunnelDetails.java \ + japi/org/openvpp/vppjapi/vppConn.java \ + japi/org/openvpp/vppjapi/vppApiCallbacks.java \ + ../../vpp/api/vpe.api.h + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppVersion.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppVersion ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppInterfaceDetails.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppInterfaceDetails ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppInterfaceCounters.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppInterfaceCounters ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppBridgeDomainInterfaceDetails.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppBridgeDomainInterfaceDetails ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppBridgeDomainDetails.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppBridgeDomainDetails ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppL2Fib.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppL2Fib ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppIPv4Address.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppIPv4Address ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppIPv6Address.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppIPv6Address ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppVxlanTunnelDetails.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppVxlanTunnelDetails ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppConn.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppConn ; + +japi/vppapi.c: japi/org_openvpp_vppjapi_vppConn.h + pushd .. ; dir=`pwd` ; popd ; \ + instdir=`echo $${dir} | sed -e 's:build-root/build:build-root/install:'` ; \ + vppapigen --input $${instdir}/../vpp/api/vpe.api --jni japi/vppapi.c --app vpe ; \ + vppapigen --input $${instdir}/../vpp/api/vpe.api --java japi/vppApi.java --app vpe ; \ + $(JAVAC) -classpath . -d . japi/vppApi.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppApi ; \ + $(JAVAC) -classpath . -d . @srcdir@/japi/org/openvpp/vppjapi/vppApiCallbacks.java ; \ + $(JAVAH) -classpath . -d japi org.openvpp.vppjapi.vppApiCallbacks ; + +demo = japi/test/demo.class +$(demo): $(jarfile) + $(JAVAC) -cp $(jarfile) -d $(JAVAROOT) @srcdir@/japi/test/demo.java + +all-local: $(jarfile) $(demo) diff --git a/vpp-api/java/configure.ac b/vpp-api/java/configure.ac new file mode 100644 index 00000000000..1607061d326 --- /dev/null +++ b/vpp-api/java/configure.ac @@ -0,0 +1,19 @@ +AC_INIT(vpp-japi, 1.0.0) +LT_INIT +AC_CONFIG_MACRO_DIR([m4]) +AM_INIT_AUTOMAKE +AM_SILENT_RULES + +AM_PROG_AS +AC_PROG_CC +AM_PROG_CC_C_O + +AX_PROG_JAVAC +AX_PROG_JAVAH +AX_PROG_JAR +AX_PROG_JAVADOC +AX_PROG_JAVA +AX_CHECK_JAVA_HOME + +AC_OUTPUT([Makefile]) + diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppApiCallbacks.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppApiCallbacks.java new file mode 100644 index 00000000000..df5b953300e --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppApiCallbacks.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +import java.io.IOException; +import org.openvpp.vppjapi.vppApi; + +public abstract class vppApiCallbacks extends vppApi { + public vppApiCallbacks(String clientName) throws IOException { + super(clientName); + } +/* Disabled! + * + * public abstract void interfaceDetails( + int ifIndex, String interfaceName, int supIfIndex, byte[] physAddr, + byte adminUp, byte linkUp, byte linkDuplex, byte linkSpeed, + int subId, byte subDot1ad, byte subNumberOfTags, int subOuterVlanId, int subInnerVlanId, + byte subExactMatch, byte subDefault, byte subOuterVlanIdAny, byte subInnerVlanIdAny, + int vtrOp, int vtrPushDot1q, int vtrTag1, int vtrTag2); + */ + +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppBridgeDomainDetails.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppBridgeDomainDetails.java new file mode 100644 index 00000000000..db859a07204 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppBridgeDomainDetails.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +import org.openvpp.vppjapi.vppBridgeDomainInterfaceDetails; + +public final class vppBridgeDomainDetails { + public String name; + public int bdId; + public boolean flood; + public boolean uuFlood; + public boolean forward; + public boolean learn; + public boolean arpTerm; + public String bviInterfaceName; + public vppBridgeDomainInterfaceDetails[] interfaces; +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppBridgeDomainInterfaceDetails.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppBridgeDomainInterfaceDetails.java new file mode 100644 index 00000000000..ab99ee45347 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppBridgeDomainInterfaceDetails.java @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppBridgeDomainInterfaceDetails { + public String interfaceName; + public byte splitHorizonGroup; +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppConn.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppConn.java new file mode 100644 index 00000000000..3e8c12a93f9 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppConn.java @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; +import java.nio.file.attribute.PosixFilePermission; +import java.nio.file.attribute.PosixFilePermissions; +import java.util.Set; + +import org.openvpp.vppjapi.vppVersion; +import org.openvpp.vppjapi.vppInterfaceDetails; +import org.openvpp.vppjapi.vppInterfaceCounters; +import org.openvpp.vppjapi.vppBridgeDomainDetails; +import org.openvpp.vppjapi.vppIPv4Address; +import org.openvpp.vppjapi.vppIPv6Address; +import org.openvpp.vppjapi.vppVxlanTunnelDetails; + +public class vppConn implements AutoCloseable { + private static final String LIBNAME = "libvppjni.so.0.0.0"; + + static { + try { + loadLibrary(); + } catch (Exception e) { + System.out.printf("Can't find vpp jni library: %s\n", LIBNAME); + throw new ExceptionInInitializerError(e); + } + } + + private static void loadStream(final InputStream is) throws IOException { + final Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxr-x---"); + final Path p = Files.createTempFile(LIBNAME, null, PosixFilePermissions.asFileAttribute(perms)); + try { + Files.copy(is, p, StandardCopyOption.REPLACE_EXISTING); + + try { + Runtime.getRuntime().load(p.toString()); + } catch (UnsatisfiedLinkError e) { + throw new IOException(String.format("Failed to load library %s", p), e); + } + } finally { + try { + Files.deleteIfExists(p); + } catch (IOException e) { + } + } + } + + private static void loadLibrary() throws IOException { + try (final InputStream is = vppConn.class.getResourceAsStream('/' + LIBNAME)) { + if (is == null) { + throw new IOException(String.format("Failed to open library resource %s", + LIBNAME)); + } + loadStream(is); + } + } + + private static vppConn currentConnection = null; + private final String clientName; + private volatile boolean disconnected = false; + + // Hidden on purpose to prevent external instantiation + vppConn(final String clientName) throws IOException { + this.clientName = clientName; + + synchronized (vppConn.class) { + if (currentConnection != null) { + throw new IOException("Already connected as " + currentConnection.clientName); + } + + final int ret = clientConnect(clientName); + if (ret != 0) { + throw new IOException("Connection returned error " + ret); + } + + currentConnection = this; + } + } + + @Override + public synchronized final void close() { + if (!disconnected) { + disconnected = true; + + synchronized (vppConn.class) { + clientDisconnect(); + currentConnection = null; + } + } + } + + /** + * Check if this instance is connected. + * + * @throws IllegalStateException if this instance was disconnected. + */ + protected final void checkConnected() { + if (disconnected) { + throw new IllegalStateException("Disconnected client " + clientName); + } + } + + public final int getRetval(int context, int release) { + checkConnected(); + return getRetval0(context, release); + } + + public final String getInterfaceList (String nameFilter) { + checkConnected(); + return getInterfaceList0(nameFilter); + } + + public final int swIfIndexFromName (String interfaceName) { + checkConnected(); + return swIfIndexFromName0(interfaceName); + } + + public final String interfaceNameFromSwIfIndex (int swIfIndex) { + checkConnected(); + return interfaceNameFromSwIfIndex0(swIfIndex); + } + + public final void clearInterfaceTable () { + checkConnected(); + clearInterfaceTable0(); + } + + public final vppInterfaceDetails[] swInterfaceDump (byte nameFilterValid, byte [] nameFilter) { + checkConnected(); + return swInterfaceDump0(nameFilterValid, nameFilter); + } + + public final int bridgeDomainIdFromName(String bridgeDomain) { + checkConnected(); + return bridgeDomainIdFromName0(bridgeDomain); + } + + public final int findOrAddBridgeDomainId(String bridgeDomain) { + checkConnected(); + return findOrAddBridgeDomainId0(bridgeDomain); + } + + public final vppVersion getVppVersion() { + checkConnected(); + return getVppVersion0(); + } + + public final vppInterfaceCounters getInterfaceCounters(int swIfIndex) { + checkConnected(); + return getInterfaceCounters0(swIfIndex); + } + + public final int[] bridgeDomainDump(int bdId) { + checkConnected(); + return bridgeDomainDump0(bdId); + } + + public final vppBridgeDomainDetails getBridgeDomainDetails(int bdId) { + checkConnected(); + return getBridgeDomainDetails0(bdId); + } + + public final vppL2Fib[] l2FibTableDump(int bdId) { + checkConnected(); + return l2FibTableDump0(bdId); + } + + public final int bridgeDomainIdFromInterfaceName(String interfaceName) { + checkConnected(); + return bridgeDomainIdFromInterfaceName0(interfaceName); + } + + public final vppIPv4Address[] ipv4AddressDump(String interfaceName) { + checkConnected(); + return ipv4AddressDump0(interfaceName); + } + + public final vppIPv6Address[] ipv6AddressDump(String interfaceName) { + checkConnected(); + return ipv6AddressDump0(interfaceName); + } + + public final vppVxlanTunnelDetails[] vxlanTunnelDump(int swIfIndex) { + checkConnected(); + return vxlanTunnelDump0(swIfIndex); + } + + public final int setInterfaceDescription(String ifName, String ifDesc) { + checkConnected(); + return setInterfaceDescription0(ifName, ifDesc); + } + + public final String getInterfaceDescription(String ifName) { + checkConnected(); + return getInterfaceDescription0(ifName); + } + + private static native int clientConnect(String clientName); + private static native void clientDisconnect(); + private static native int getRetval0(int context, int release); + private static native String getInterfaceList0(String nameFilter); + private static native int swIfIndexFromName0(String interfaceName); + private static native String interfaceNameFromSwIfIndex0(int swIfIndex); + private static native void clearInterfaceTable0(); + private static native vppInterfaceDetails[] swInterfaceDump0(byte nameFilterValid, byte [] nameFilter); + private static native int bridgeDomainIdFromName0(String bridgeDomain); + private static native int findOrAddBridgeDomainId0(String bridgeDomain); + private static native vppVersion getVppVersion0(); + private static native vppInterfaceCounters getInterfaceCounters0(int swIfIndex); + private static native int[] bridgeDomainDump0(int bdId); + private static native vppBridgeDomainDetails getBridgeDomainDetails0(int bdId); + private static native vppL2Fib[] l2FibTableDump0(int bdId); + private static native int bridgeDomainIdFromInterfaceName0(String interfaceName); + private static native vppIPv4Address[] ipv4AddressDump0(String interfaceName); + private static native vppIPv6Address[] ipv6AddressDump0(String interfaceName); + private static native vppVxlanTunnelDetails[] vxlanTunnelDump0(int swIfIndex); + private static native int setInterfaceDescription0(String ifName, String ifDesc); + private static native String getInterfaceDescription0(String ifName); +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppIPv4Address.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppIPv4Address.java new file mode 100644 index 00000000000..046ceab52f0 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppIPv4Address.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppIPv4Address { + public final int ip; + public final byte prefixLength; + + public vppIPv4Address(int ip, byte prefixLength) { + this.ip = ip; + this.prefixLength = prefixLength; + } +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppIPv6Address.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppIPv6Address.java new file mode 100644 index 00000000000..6690a5db981 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppIPv6Address.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public class vppIPv6Address { + // FIXME: this is dangerous + public final byte[] ip; + public final byte prefixLength; + + public vppIPv6Address(byte[] ip, byte prefixLength) { + this.ip = ip; + this.prefixLength = prefixLength; + } +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppInterfaceCounters.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppInterfaceCounters.java new file mode 100644 index 00000000000..b2687fb8efb --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppInterfaceCounters.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppInterfaceCounters { + + public final long rxOctets; + public final long rxIp4; + public final long rxIp6; + public final long rxUnicast; + public final long rxMulticast; + public final long rxBroadcast; + public final long rxDiscard; + public final long rxFifoFull; + public final long rxError; + public final long rxUnknownProto; + public final long rxMiss; + + public final long txOctets; + public final long txIp4; + public final long txIp6; + public final long txUnicast; + public final long txMulticast; + public final long txBroadcast; + public final long txDiscard; + public final long txFifoFull; + public final long txError; + public final long txUnknownProto; + public final long txMiss; + + public vppInterfaceCounters( + long rxOctets, long rxIp4, long rxIp6, long rxUni, long rxMulti, + long rxBcast, long rxDiscard, long rxFifoFull, long rxError, + long rxUnknownProto, long rxMiss, + long txOctets, long txIp4, long txIp6, long txUni, long txMulti, + long txBcast, long txDiscard, long txFifoFull, long txError, + long txUnknownProto, long txMiss) + { + this.rxOctets = rxOctets; + this.rxIp4 = rxIp4; + this.rxIp6 = rxIp6; + this.rxUnicast = rxUni; + this.rxMulticast = rxMulti; + this.rxBroadcast = rxBcast; + this.rxDiscard = rxDiscard; + this.rxFifoFull = rxFifoFull; + this.rxError = rxError; + this.rxUnknownProto = rxUnknownProto; + this.rxMiss = rxMiss; + + this.txOctets = txOctets; + this.txIp4 = txIp4; + this.txIp6 = txIp6; + this.txUnicast = txUni; + this.txMulticast = txMulti; + this.txBroadcast = txBcast; + this.txDiscard = txDiscard; + this.txFifoFull = txFifoFull; + this.txError = txError; + this.txUnknownProto = txUnknownProto; + this.txMiss = txMiss; + } +} + diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppInterfaceDetails.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppInterfaceDetails.java new file mode 100644 index 00000000000..742dd25ad1c --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppInterfaceDetails.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppInterfaceDetails { + public final int ifIndex; + public final String interfaceName; + public final int supIfIndex; + // FIXME: this is dangerous + public final byte[] physAddr; + public final byte adminUp; + public final byte linkUp; + public final byte linkDuplex; + public final byte linkSpeed; + public final int subId; + public final byte subDot1ad; + public final byte subNumberOfTags; + public final int subOuterVlanId; + public final int subInnerVlanId; + public final byte subExactMatch; + public final byte subDefault; + public final byte subOuterVlanIdAny; + public final byte subInnerVlanIdAny; + public final int vtrOp; + public final int vtrPushDot1q; + public final int vtrTag1; + public final int vtrTag2; + public final int linkMtu; + + public vppInterfaceDetails(int ifIndex, String interfaceName, int supIfIndex, byte[] physAddr, byte adminUp, + byte linkUp, byte linkDuplex, byte linkSpeed, int subId, byte subDot1ad, byte subNumberOfTags, + int subOuterVlanId, int subInnerVlanId, byte subExactMatch, byte subDefault, byte subOuterVlanIdAny, + byte subInnerVlanIdAny, int vtrOp, int vtrPushDot1q, int vtrTag1, int vtrTag2, int linkMtu) + { + this.ifIndex = ifIndex; + this.interfaceName = interfaceName; + this.supIfIndex = supIfIndex; + this.physAddr = physAddr; + this.adminUp = adminUp; + this.linkUp = linkUp; + this.linkDuplex = linkDuplex; + this.linkSpeed = linkSpeed; + this.subId = subId; + this.subDot1ad = subDot1ad; + this.subNumberOfTags = subNumberOfTags; + this.subOuterVlanId = subOuterVlanId; + this.subInnerVlanId = subInnerVlanId; + this.subExactMatch = subExactMatch; + this.subDefault = subDefault; + this.subOuterVlanIdAny = subOuterVlanIdAny; + this.subInnerVlanIdAny = subInnerVlanIdAny; + this.vtrOp = vtrOp; + this.vtrPushDot1q = vtrPushDot1q; + this.vtrTag1 = vtrTag1; + this.vtrTag2 = vtrTag2; + this.linkMtu = linkMtu; + } +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppL2Fib.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppL2Fib.java new file mode 100644 index 00000000000..b38d801e9e0 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppL2Fib.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppL2Fib { + // FIXME: this is dangerous + public final byte[] physAddress; + public final boolean staticConfig; + public final String outgoingInterface; + public final boolean filter; + public final boolean bridgedVirtualInterface; + + public vppL2Fib(byte[] physAddress, boolean staticConfig, + String outgoingInterface, boolean filter, + boolean bridgedVirtualInterface) { + this.physAddress = physAddress; + this.staticConfig = staticConfig; + this.outgoingInterface = outgoingInterface; + this.filter = filter; + this.bridgedVirtualInterface = bridgedVirtualInterface; + } +} diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppVersion.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppVersion.java new file mode 100644 index 00000000000..6408dee2754 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppVersion.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppVersion { + public final String programName; + public final String buildDirectory; + public final String gitBranch; + public final String buildDate; + + public vppVersion(String progName, String buildDir, String gitBranch, String buildDate) { + this.programName = progName; + this.buildDirectory = buildDir; + this.gitBranch = gitBranch; + this.buildDate = buildDate; + } +} + diff --git a/vpp-api/java/japi/org/openvpp/vppjapi/vppVxlanTunnelDetails.java b/vpp-api/java/japi/org/openvpp/vppjapi/vppVxlanTunnelDetails.java new file mode 100644 index 00000000000..dd81e98cf27 --- /dev/null +++ b/vpp-api/java/japi/org/openvpp/vppjapi/vppVxlanTunnelDetails.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.openvpp.vppjapi; + +public final class vppVxlanTunnelDetails { + public final int srcAddress; + public final int dstAddress; + public final int encapVrfId; + public final int vni; + public final int decapNextIndex; + + public vppVxlanTunnelDetails(int srcAddress, int dstAddress, + int encapVrfId, int vni, int decapNextIndex) { + this.srcAddress = srcAddress; + this.dstAddress = dstAddress; + this.encapVrfId = encapVrfId; + this.vni = vni; + this.decapNextIndex = decapNextIndex; + } +} diff --git a/vpp-api/java/japi/test/demo.java b/vpp-api/java/japi/test/demo.java new file mode 100644 index 00000000000..ea1db84bda2 --- /dev/null +++ b/vpp-api/java/japi/test/demo.java @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import org.openvpp.vppjapi.*; + +public class demo { + public static void main (String[] args) throws Exception { + vppApi api = new vppApi ("JavaTest"); + System.out.printf ("Connected OK..."); + + String intlist; + int [] contexts; + int i, limit; + int trips; + int rv, errors, saved_error; + long before, after; + + if (false) + { + intlist = api.getInterfaceList (""); + System.out.printf ("Unfiltered interface list:\n%s", intlist); + + trips = 0; + + contexts = new int[6]; + + for (i = 0; i < 6; i++) + { + contexts[i] = api.swInterfaceSetFlags + (5 + i /* sw_if_index */, + (byte)1 /* admin_up */, + (byte)1 /* link_up (ignored) */, + (byte)0 /* deleted */); + } + + /* Thread.sleep (1); */ + errors = 0; + saved_error = 0; + + for (i = 0; i < 6; i ++) + { + while (true) + { + rv = api.getRetval (contexts[i], 1 /* release */); + if (rv != -77) + break; + Thread.sleep (1); + trips++; + } + if (rv < 0) + { + saved_error = rv; + errors++; + } + } + + if (errors == 0) + System.out.printf ("intfcs up...\n"); + else + System.out.printf + ("%d errors, last error %d...\n", errors, saved_error); + } + + limit = 250000; + saved_error = 0; + errors = 0; + contexts = new int [limit]; + byte [] address = new byte [4]; + byte [] zeros = new byte [4]; + + address[0] = (byte)192; + address[1] = (byte)168; + address[2] = (byte)2; + address[3] = (byte)1; + + for (i = 0; i < 4; i++) + zeros[i] = 0; + + System.out.printf ("start %d route ops ...", limit); + + before = System.currentTimeMillis(); + + for (i = 0; i < limit; i++) { + contexts[i] = api.ipAddDelRoute + (0 /* int nextHopSwIfIndex */, + 0 /* int vrfId */, + 0 /* int lookupInVrf */, + 0 /* int resolveAttempts */, + 0 /* int classifyTableIndex */, + (byte)0 /* byte createVrfIfNeeded */, + (byte)0 /* byte resolveIfNeeded */, + (byte)1 /* byte isAdd */, + (byte)1 /* byte isDrop */, + (byte)0 /* byte isIpv6 */, + (byte)0 /* byte isLocal */, + (byte)0 /* byte isClassify */, + (byte)0 /* byte isMultipath */, + (byte)0 /* byte notLast */, + (byte)0 /* byte nextHopWeight */, + (byte)32 /* byte dstAddressLength */, + address, + zeros); + + address[3] += 1; + if (address[3] == 0) + { + address[2] += 1; + if (address[2] == 0) + { + address[1] += 1; + { + if (address[1] == 0) + { + address[0] += 1; + } + } + } + } + } + + trips = 0; + + for (i = 0; i < limit; i++) + { + while (true) + { + rv = api.getRetval (contexts[i], 1 /* release */); + if (rv != -77) + break; + Thread.sleep (1); + trips++; + } + if (rv < 0) + { + saved_error = rv; + errors++; + } + } + + after = System.currentTimeMillis(); + + + if (errors == 0) + System.out.printf ("done %d route ops (all OK)...\n", limit); + else + System.out.printf + ("%d errors, last error %d...\n", errors, saved_error); + + System.out.printf ("result in %d trips\n", trips); + + System.out.printf ("%d routes in %d milliseconds, %d routes/msec\n", + limit, after - before, + limit / (after - before)); + + api.close(); + System.out.printf ("Done...\n"); + } +} diff --git a/vpp-api/java/japi/test/vppApi.java b/vpp-api/java/japi/test/vppApi.java new file mode 100644 index 00000000000..87af3292449 --- /dev/null +++ b/vpp-api/java/japi/test/vppApi.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.net.InetAddress; +import org.openvpp.vppjapi.*; + +public class vppApi { + + native int controlPing(); + native void test (byte[] array, byte[] array2); + + public static void main (String[] args) throws Exception { + vppConn api = new vppConn (); + String ipv6 = "db01::feed"; + String ipv4 = "192.168.1.1"; + InetAddress addr6 = InetAddress.getByName(ipv6); + InetAddress addr4 = InetAddress.getByName(ipv4); + byte[] ip4bytes = addr4.getAddress(); + byte[] ip6bytes = addr6.getAddress(); + int rv; + + api.test(ip4bytes,ip6bytes); + + rv = api.clientConnect ("JavaTest"); + if (rv == 0) + System.out.printf ("Connected OK..."); + else + { + System.out.printf ("clientConnect returned %d\n", rv); + System.exit (1); + } + rv = api.controlPing(); + System.out.printf ("data plane pid is %d\n", rv); + + Thread.sleep (5000); + + api.clientDisconnect(); + System.out.printf ("Done...\n"); + } +} diff --git a/vpp-api/java/japi/vppjni.c b/vpp-api/java/japi/vppjni.c new file mode 100644 index 00000000000..9c9437d2f46 --- /dev/null +++ b/vpp-api/java/japi/vppjni.c @@ -0,0 +1,1900 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#define _GNU_SOURCE /* for strcasestr(3) */ +#include <vnet/vnet.h> + +#define vl_api_version(n,v) static u32 vpe_api_version = (v); +#include <api/vpe.api.h> +#undef vl_api_version + +#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_msg_enum.h> +#define vl_typedefs /* define message structures */ +#include <api/vpe_all_api_h.h> +#undef vl_typedefs + +#define vl_endianfun +#include <api/vpe_all_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) +#define vl_printfun +#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); + +/* + * The Java runtime isn't compile w/ -fstack-protector, + * so we have to supply missing external references for the + * regular vpp libraries. Weak reference in case folks get religion + * at a later date... + */ +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[BBBBBIBBIIBBBBIIIII)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) +{ + /* + * Send the main API signature in slot 0. This bit of code must + * match the checks in ../vpe/api/api.c: vl_msg_api_version_check(). + */ + mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version); +} + +/* Note: non-static, called once to set up the initial intfc table */ +static int sw_interface_dump (vppjni_main_t * jm) +{ + vl_api_sw_interface_dump_t *mp; + f64 timeout; + hash_pair_t * p; + name_sort_t * nses = 0, * ns; + sw_interface_subif_t * sub = NULL; + + /* Toss the old name table */ + hash_foreach_pair (p, jm->sw_if_index_by_interface_name, + ({ + vec_add2 (nses, ns, 1); + ns->name = (u8 *)(p->key); + ns->value = (u32) p->value[0]; + })); + + hash_free (jm->sw_if_index_by_interface_name); + + vec_foreach (ns, nses) + vec_free (ns->name); + + vec_free (nses); + + vec_foreach (sub, jm->sw_if_subif_table) { + vec_free (sub->interface_name); + } + vec_free (jm->sw_if_subif_table); + + /* recreate the interface name hash table */ + jm->sw_if_index_by_interface_name + = hash_create_string (0, sizeof(uword)); + + /* Get list of ethernets */ + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->name_filter_valid = 1; + strncpy ((char *) mp->name_filter, "Ether", sizeof(mp->name_filter-1)); + S; + + /* and local / loopback interfaces */ + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->name_filter_valid = 1; + strncpy ((char *) mp->name_filter, "lo", sizeof(mp->name_filter-1)); + S; + + /* and vxlan tunnel interfaces */ + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->name_filter_valid = 1; + strncpy ((char *) mp->name_filter, "vxlan", sizeof(mp->name_filter-1)); + S; + + /* and tap tunnel interfaces */ + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->name_filter_valid = 1; + strncpy ((char *) mp->name_filter, "tap", sizeof(mp->name_filter-1)); + S; + + /* and host (af_packet) interfaces */ + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->name_filter_valid = 1; + strncpy ((char *) mp->name_filter, "host", sizeof(mp->name_filter-1)); + S; + + /* and l2tpv3 tunnel interfaces */ + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->name_filter_valid = 1; + strncpy ((char *) mp->name_filter, "l2tpv3_tunnel", + sizeof(mp->name_filter-1)); + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + } + W; +} + +JNIEXPORT jobject JNICALL Java_org_openvpp_vppjapi_vppConn_getVppVersion0 + (JNIEnv *env, jobject obj) +{ + vppjni_main_t * jm = &vppjni_main; + + vppjni_lock (jm, 11); + jstring progName = (*env)->NewStringUTF(env, (char *)jm->program_name); + jstring buildDir = (*env)->NewStringUTF(env, (char *)jm->build_directory); + jstring version = (*env)->NewStringUTF(env, (char *)jm->version); + jstring buildDate = (*env)->NewStringUTF(env, (char *)jm->build_date); + vppjni_unlock (jm); + + return vppVersionObject(env, progName, buildDir, version, buildDate); +} + +static int jm_show_version (vppjni_main_t *jm) +{ + int rv; + vl_api_show_version_t *mp; + f64 timeout; + + vppjni_lock (jm, 10); + M(SHOW_VERSION, show_version); + + S; + vppjni_unlock (jm); + WNR; + return rv; +} + +static int jm_stats_enable_disable (vppjni_main_t *jm, u8 enable) +{ + vl_api_want_stats_t * mp; + f64 timeout; + int rv; + + vppjni_lock (jm, 13); + + M(WANT_STATS, want_stats); + + mp->enable_disable = enable; + + S; + vppjni_unlock (jm); + WNR; + + // already subscribed / already disabled (it's ok) + if (rv == -2 || rv == -3) + rv = 0; + return rv; +} + +JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_setInterfaceDescription0 + (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_getInterfaceDescription0 +(JNIEnv * env, jobject obj, jstring ifName) +{ + vppjni_main_t * jm = &vppjni_main; + u32 sw_if_index = ~0; + uword * p; + jstring ifDesc = NULL; + const char *if_name_str = (*env)->GetStringUTFChars (env, ifName, 0); + if (!if_name_str) + return 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) +{ + int rv; + const char *client_name; + void vl_msg_reply_handler_hookup(void); + vppjni_main_t * jm = &vppjni_main; + api_main_t * am = &api_main; + u8 * heap; + mheap_t * h; + f64 timeout; + + /* + * Bail out now if we're not running as root + */ + if (geteuid() != 0) + return -1; + + if (jm->is_connected) + return -2; + + client_name = (*env)->GetStringUTFChars(env, clientName, 0); + if (!client_name) + return -3; + + if (jm->heap == 0) + clib_mem_init (0, 128<<20); + + heap = clib_mem_get_per_cpu_heap(); + h = mheap_header (heap); + + clib_time_init (&jm->clib_time); + + rv = connect_to_vpe ((char *) client_name); + + if (rv < 0) + clib_warning ("connection failed, rv %d", rv); + + (*env)->ReleaseStringUTFChars (env, clientName, client_name); + + if (rv == 0) { + vl_msg_reply_handler_hookup (); + jm->is_connected = 1; + /* make the main heap thread-safe */ + 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->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 + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + WNR; + + if (rv != 0) { + clib_warning ("first control ping failed: %d", rv); + } + } + rv = jm_show_version(jm); + if (rv != 0) + clib_warning ("unable to retrieve vpp version (rv: %d)", rv); + rv = sw_interface_dump(jm); + if (rv != 0) + clib_warning ("unable to retrieve interface list (rv: %d)", rv); + rv = jm_stats_enable_disable(jm, 1); + if (rv != 0) + clib_warning ("unable to subscribe to stats (rv: %d)", rv); + } + DEBUG_LOG ("clientConnect result: %d", rv); + + return rv; +} + +JNIEXPORT void JNICALL Java_org_openvpp_vppjapi_vppConn_clientDisconnect + (JNIEnv *env, jobject obj) +{ + u8 *save_heap; + vppjni_main_t * jm = &vppjni_main; + vl_client_disconnect_from_vlib(); + + save_heap = jm->heap; + memset (jm, 0, sizeof (*jm)); + jm->heap = save_heap; +} + +void vl_api_generic_reply_handler (vl_api_generic_reply_t *mp) +{ + api_main_t * am = &api_main; + u16 msg_id = clib_net_to_host_u16 (mp->_vl_msg_id); + trace_cfg_t *cfgp; + i32 retval = clib_net_to_host_u32 (mp->retval); + int total_bytes = sizeof(mp); + vppjni_main_t * jm = &vppjni_main; + u8 * saved_reply = 0; + u32 context = clib_host_to_net_u32 (mp->context); + + cfgp = am->api_trace_cfg + msg_id; + + if (!cfgp) + clib_warning ("msg id %d: no trace configuration\n", msg_id); + else + total_bytes = cfgp->size; + + jm->context_id_received = context; + + 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)) + return; + + /* Save the reply */ + vec_validate (saved_reply, total_bytes - 1); + memcpy (saved_reply, mp, total_bytes); + + vppjni_lock (jm, 2); + hash_set (jm->reply_hash, context, saved_reply); + jm->saved_reply_count ++; + vppjni_unlock (jm); +} + +JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_getRetval0 +(JNIEnv * env, jobject obj, jint context, jint release) +{ + vppjni_main_t * jm = &vppjni_main; + vl_api_generic_reply_t * mp; + uword * p; + int rv = 0; + + /* Dunno yet? */ + if (context > jm->context_id_received) + return (VNET_API_ERROR_RESPONSE_NOT_READY); + + vppjni_lock (jm, 1); + p = hash_get (jm->reply_hash, context); + + /* + * Two cases: a generic "yes" reply - won't be in the hash table + * or "no", or "more data" which will be in the table. + */ + if (p == 0) + goto out; + + mp = (vl_api_generic_reply_t *) (p[0]); + rv = clib_net_to_host_u32 (mp->retval); + + if (release) { + u8 * free_me = (u8 *) mp; + vec_free (free_me); + hash_unset (jm->reply_hash, context); + jm->saved_reply_count --; + } + +out: + vppjni_unlock (jm); + return (rv); +} + +static int +name_sort_cmp (void * a1, void * a2) +{ + name_sort_t * n1 = a1; + name_sort_t * n2 = a2; + + return strcmp ((char *)n1->name, (char *)n2->name); +} + +JNIEXPORT jstring JNICALL Java_org_openvpp_vppjapi_vppConn_getInterfaceList0 + (JNIEnv * env, jobject obj, jstring name_filter) +{ + vppjni_main_t * jm = &vppjni_main; + jstring rv; + hash_pair_t * p; + name_sort_t * nses = 0, * ns; + const char *this_name; + u8 * s = 0; + const char * nf = (*env)->GetStringUTFChars (env, name_filter, NULL); + if (!nf) + return NULL; + + vppjni_lock (jm, 4); + + hash_foreach_pair (p, jm->sw_if_index_by_interface_name, + ({ + this_name = (const char *)(p->key); + if (strlen (nf) == 0 || strcasestr (this_name, nf)) { + vec_add2 (nses, ns, 1); + ns->name = (u8 *)(p->key); + ns->value = (u32) p->value[0]; + } + })); + + vec_sort_with_function (nses, name_sort_cmp); + + vec_foreach (ns, nses) + s = format (s, "%s: %d, ", ns->name, ns->value); + + _vec_len (s) = vec_len (s) - 2; + vec_terminate_c_string (s); + vppjni_unlock (jm); + + vec_free (nses); + + (*env)->ReleaseStringUTFChars (env, name_filter, nf); + + rv = (*env)->NewStringUTF (env, (char *) s); + vec_free (s); + + return rv; +} + +JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_swIfIndexFromName0 + (JNIEnv * env, jobject obj, jstring interfaceName) +{ + vppjni_main_t * jm = &vppjni_main; + jint rv = -1; + const char * if_name = (*env)->GetStringUTFChars (env, interfaceName, NULL); + if (if_name) { + uword * p; + + vppjni_lock (jm, 5); + + p = hash_get_mem (jm->sw_if_index_by_interface_name, if_name); + + if (p != 0) + rv = (jint) p[0]; + + vppjni_unlock (jm); + + (*env)->ReleaseStringUTFChars (env, interfaceName, if_name); + } + + return rv; +} + +JNIEXPORT jobject JNICALL Java_org_openvpp_vppjapi_vppConn_getInterfaceCounters0 +(JNIEnv * env, jobject obj, jint swIfIndex) +{ + vppjni_main_t * jm = &vppjni_main; + sw_interface_stats_t *s; + u32 sw_if_index = swIfIndex; + jobject result = NULL; + + vppjni_lock (jm, 16); + + if (sw_if_index >= vec_len(jm->sw_if_stats_by_sw_if_index)) { + goto out; + } + s = &jm->sw_if_stats_by_sw_if_index[sw_if_index]; + if (!s->valid) { + goto out; + } + + 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, + s->rx.pkts.miss, + s->tx.octets, s->tx.pkts.ip4, s->tx.pkts.ip6, s->tx.pkts.unicast, + s->tx.pkts.multicast, s->tx.pkts.broadcast, s->tx.pkts.discard, + s->tx.pkts.fifo_full, s->tx.pkts.error, s->tx.pkts.unknown_proto, + s->tx.pkts.miss); + +out: + vppjni_unlock (jm); + return result; +} + +JNIEXPORT jstring JNICALL Java_org_openvpp_vppjapi_vppConn_interfaceNameFromSwIfIndex0 +(JNIEnv * env, jobject obj, jint swIfIndex) +{ + vppjni_main_t * jm = &vppjni_main; + sw_interface_details_t *sw_if_details; + u32 sw_if_index; + jstring ifname = NULL; + + vppjni_lock (jm, 8); + + sw_if_index = swIfIndex; + + if (sw_if_index >= vec_len(jm->sw_if_table)) { + goto out; + } + sw_if_details = &jm->sw_if_table[sw_if_index]; + if (!sw_if_details->valid) { + goto out; + } + + u8 * s = format (0, "%s%c", sw_if_details->interface_name, 0); + ifname = (*env)->NewStringUTF(env, (char *)s); + +out: + vppjni_unlock (jm); + + return ifname; +} + +JNIEXPORT void JNICALL Java_org_openvpp_vppjapi_vppConn_clearInterfaceTable0 +(JNIEnv * env, jobject obj) +{ + vppjni_main_t * jm = &vppjni_main; + + vppjni_lock (jm, 21); + + vec_reset_length(jm->sw_if_table); + + vppjni_unlock (jm); +} + +static jobjectArray sw_if_dump_get_interfaces (); + +JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_swInterfaceDump0 +(JNIEnv * env, jobject obj, jbyte name_filter_valid, jbyteArray name_filter) +{ + vppjni_main_t *jm = &vppjni_main; + f64 timeout; + vl_api_sw_interface_dump_t * mp; + u32 my_context_id; + int rv; + rv = vppjni_sanity_check (jm); + if (rv) { + clib_warning("swInterfaceDump sanity_check rv = %d", rv); + return NULL; + } + + vppjni_lock (jm, 7); + my_context_id = vppjni_get_context_id (jm); + jsize cnt = (*env)->GetArrayLength (env, name_filter); + + M(SW_INTERFACE_DUMP, sw_interface_dump); + mp->context = clib_host_to_net_u32 (my_context_id); + mp->name_filter_valid = name_filter_valid; + + if (cnt > sizeof(mp->name_filter)) + cnt = sizeof(mp->name_filter); + + (*env)->GetByteArrayRegion(env, name_filter, 0, cnt, (jbyte *)mp->name_filter); + + DEBUG_LOG ("interface filter (%d, %s, len: %d)", mp->name_filter_valid, (char *)mp->name_filter, cnt); + + jm->collect_indices = 1; + + S; + { + // now send control ping so we know when it ends + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + mp->context = clib_host_to_net_u32 (my_context_id); + + S; + } + vppjni_unlock (jm); + WNR; + + vppjni_lock (jm, 7); + jobjectArray result = sw_if_dump_get_interfaces(env); + vppjni_unlock (jm); + return result; +} + +static jobjectArray sw_if_dump_get_interfaces (JNIEnv * env) +{ + vppjni_main_t * jm = &vppjni_main; + sw_interface_details_t *sw_if_details; + u32 i; + + int len = vec_len(jm->sw_if_dump_if_indices); + + 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]; + ASSERT(sw_if_details->valid); + + u8 * s = format (0, "%s%c", sw_if_details->interface_name, 0); + + jstring ifname = (*env)->NewStringUTF(env, (char *)s); + jint ifIndex = sw_if_details->sw_if_index; + jint supIfIndex = sw_if_details->sup_sw_if_index; + jbyteArray physAddr = (*env)->NewByteArray(env, + sw_if_details->l2_address_length); + (*env)->SetByteArrayRegion(env, physAddr, 0, + sw_if_details->l2_address_length, + (signed char*)sw_if_details->l2_address); + jint subId = sw_if_details->sub_id; + jint subOuterVlanId = sw_if_details->sub_outer_vlan_id; + jint subInnerVlanId = sw_if_details->sub_inner_vlan_id; + jint vtrOp = sw_if_details->vtr_op; + jint vtrPushDot1q = sw_if_details->vtr_push_dot1q; + jint vtrTag1 = sw_if_details->vtr_tag1; + jint vtrTag2 = sw_if_details->vtr_tag2; + jint linkMtu = sw_if_details->link_mtu; + + jbyte adminUpDown = sw_if_details->admin_up_down; + jbyte linkUpDown = sw_if_details->link_up_down; + jbyte linkDuplex = sw_if_details->link_duplex; + jbyte linkSpeed = sw_if_details->link_speed; + jbyte subDot1ad = sw_if_details->sub_dot1ad; + jbyte subNumberOfTags = sw_if_details->sub_number_of_tags; + jbyte subExactMatch = sw_if_details->sub_exact_match; + jbyte subDefault = sw_if_details->sub_default; + jbyte subOuterVlanIdAny = sw_if_details->sub_outer_vlan_id_any; + jbyte subInnerVlanIdAny = sw_if_details->sub_inner_vlan_id_any; + + 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, linkMtu); + (*env)->SetObjectArrayElement(env, ifArray, i, ifObj); + } + + jm->collect_indices = 0; + vec_reset_length(jm->sw_if_dump_if_indices); + return ifArray; +} + +JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_findOrAddBridgeDomainId0 + (JNIEnv * env, jobject obj, jstring bridgeDomain) +{ + vppjni_main_t * jm = &vppjni_main; + jint rv = -1; + const char * bdName = (*env)->GetStringUTFChars (env, bridgeDomain, NULL); + if (bdName) { + static u8 * bd_name = 0; + + 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); + + _vec_len(bd_name) = 0; + } + return rv; +} + +JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_bridgeDomainIdFromName0 + (JNIEnv * env, jobject obj, jstring bridgeDomain) +{ + vppjni_main_t * jm = &vppjni_main; + jint rv = -1; + const char * bdName = (*env)->GetStringUTFChars (env, bridgeDomain, NULL); + if (bdName) { + static u8 * bd_name = 0; + + 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); + + _vec_len(bd_name) = 0; + } + + return rv; +} + +JNIEXPORT jint JNICALL Java_org_openvpp_vppjapi_vppConn_bridgeDomainIdFromInterfaceName0 + (JNIEnv * env, jobject obj, jstring interfaceName) +{ + vppjni_main_t * jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + u32 sw_if_index; + jint rv = -1; + const char * if_name; + uword * p; + + if_name = (*env)->GetStringUTFChars (env, interfaceName, NULL); + + vppjni_lock (jm, 14); + + p = hash_get_mem (jm->sw_if_index_by_interface_name, if_name); + + if (p != 0) { + sw_if_index = (jint) p[0]; + p = hash_get (bdm->bd_id_by_sw_if_index, sw_if_index); + if (p != 0) { + rv = (jint) p[0]; + } + } + + vppjni_unlock (jm); + + (*env)->ReleaseStringUTFChars (env, interfaceName, if_name); + + return rv; +} + +/* + * Special-case: build the interface table, maintain + * the next loopback sw_if_index vbl. + */ +static void vl_api_sw_interface_details_t_handler +(vl_api_sw_interface_details_t * mp) +{ + vppjni_main_t * jm = &vppjni_main; + static sw_interface_details_t empty_sw_if_details = {0,}; + sw_interface_details_t *sw_if_details; + u32 sw_if_index; + + vppjni_lock (jm, 1); + + sw_if_index = ntohl (mp->sw_if_index); + + u8 * s = format (0, "%s%c", mp->interface_name, 0); + + if (jm->collect_indices) { + u32 pos = vec_len(jm->sw_if_dump_if_indices); + vec_validate(jm->sw_if_dump_if_indices, pos); + jm->sw_if_dump_if_indices[pos] = sw_if_index; + } + + vec_validate_init_empty(jm->sw_if_table, sw_if_index, empty_sw_if_details); + sw_if_details = &jm->sw_if_table[sw_if_index]; + sw_if_details->valid = 1; + + snprintf((char *)sw_if_details->interface_name, + sizeof(sw_if_details->interface_name), "%s", (char *)s); + sw_if_details->sw_if_index = sw_if_index; + sw_if_details->sup_sw_if_index = ntohl(mp->sup_sw_if_index); + sw_if_details->l2_address_length = ntohl (mp->l2_address_length); + ASSERT(sw_if_details->l2_address_length <= sizeof(sw_if_details->l2_address)); + memcpy(sw_if_details->l2_address, mp->l2_address, + sw_if_details->l2_address_length); + sw_if_details->sub_id = ntohl (mp->sub_id); + sw_if_details->sub_outer_vlan_id = ntohl (mp->sub_outer_vlan_id); + sw_if_details->sub_inner_vlan_id = ntohl (mp->sub_inner_vlan_id); + sw_if_details->vtr_op = ntohl (mp->vtr_op); + sw_if_details->vtr_push_dot1q = ntohl (mp->vtr_push_dot1q); + sw_if_details->vtr_tag1 = ntohl (mp->vtr_tag1); + sw_if_details->vtr_tag2 = ntohl (mp->vtr_tag2); + + sw_if_details->admin_up_down = mp->admin_up_down; + sw_if_details->link_up_down = mp->link_up_down; + sw_if_details->link_duplex = mp->link_duplex; + sw_if_details->link_speed = mp->link_speed; + sw_if_details->sub_dot1ad = mp->sub_dot1ad; + sw_if_details->sub_number_of_tags = mp->sub_number_of_tags; + sw_if_details->sub_exact_match = mp->sub_exact_match; + sw_if_details->sub_default = mp->sub_default; + sw_if_details->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any; + 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); + 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) { + sw_interface_subif_t * sub = NULL; + + vec_add2(jm->sw_if_subif_table, sub, 1); + + vec_validate(sub->interface_name, strlen((char *)s) + 1); + strncpy((char *)sub->interface_name, (char *)s, + vec_len(sub->interface_name)); + sub->sw_if_index = ntohl(mp->sw_if_index); + sub->sub_id = ntohl(mp->sub_id); + + sub->sub_dot1ad = mp->sub_dot1ad; + sub->sub_number_of_tags = mp->sub_number_of_tags; + sub->sub_outer_vlan_id = ntohs(mp->sub_outer_vlan_id); + sub->sub_inner_vlan_id = ntohs(mp->sub_inner_vlan_id); + sub->sub_exact_match = mp->sub_exact_match; + sub->sub_default = mp->sub_default; + sub->sub_outer_vlan_id_any = mp->sub_outer_vlan_id_any; + sub->sub_inner_vlan_id_any = mp->sub_inner_vlan_id_any; + + /* vlan tag rewrite */ + sub->vtr_op = ntohl(mp->vtr_op); + sub->vtr_push_dot1q = ntohl(mp->vtr_push_dot1q); + sub->vtr_tag1 = ntohl(mp->vtr_tag1); + sub->vtr_tag2 = ntohl(mp->vtr_tag2); + } + vppjni_unlock (jm); +} + +static void vl_api_sw_interface_set_flags_t_handler +(vl_api_sw_interface_set_flags_t * mp) +{ + /* $$$ nothing for the moment */ +} + +static jintArray create_array_of_bd_ids(JNIEnv * env, jint bd_id) +{ + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + u32 *buf = NULL; + u32 i; + + if (bd_id != ~0) { + vec_add1(buf, bd_id); + } else { + for (i = 0; i < vec_len(bdm->bd_oper); i++) { + u32 bd_id = bdm->bd_oper[i].bd_id; + vec_add1(buf, bd_id); + } + } + + jintArray bdidArray = (*env)->NewIntArray(env, vec_len(buf)); + if (!bdidArray) { + goto out; + } + + (*env)->SetIntArrayRegion(env, bdidArray, 0, vec_len(buf), (int*)buf); + +out: + vec_free(buf); + return bdidArray; +} + +static void bridge_domain_oper_free(void) +{ + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t *bdm = &jm->vjbd_main; + u32 i; + + for (i = 0; i < vec_len(bdm->bd_oper); i++) { + vec_free(bdm->bd_oper->l2fib_oper); + } + vec_reset_length(bdm->bd_oper); + hash_free(bdm->bd_id_by_sw_if_index); + hash_free(bdm->oper_bd_index_by_bd_id); +} + +JNIEXPORT jintArray JNICALL Java_org_openvpp_vppjapi_vppConn_bridgeDomainDump0 +(JNIEnv * env, jobject obj, jint bd_id) +{ + vppjni_main_t *jm = &vppjni_main; + vl_api_bridge_domain_dump_t * mp; + u32 my_context_id; + f64 timeout; + int rv; + rv = vppjni_sanity_check (jm); + if (rv) return NULL; + + vppjni_lock (jm, 15); + + if (~0 == bd_id) { + bridge_domain_oper_free(); + } + + my_context_id = vppjni_get_context_id (jm); + M(BRIDGE_DOMAIN_DUMP, bridge_domain_dump); + mp->context = clib_host_to_net_u32 (my_context_id); + mp->bd_id = clib_host_to_net_u32(bd_id); + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + } + + WNR; + if (0 != rv) { + return NULL; + } + + jintArray ret = create_array_of_bd_ids(env, bd_id); + + vppjni_unlock (jm); + + return ret; +} + +static void +vl_api_bridge_domain_details_t_handler (vl_api_bridge_domain_details_t * mp) +{ + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + vjbd_oper_t * bd_oper; + u32 bd_id, bd_index; + + bd_id = ntohl (mp->bd_id); + + bd_index = vec_len(bdm->bd_oper); + vec_validate (bdm->bd_oper, bd_index); + bd_oper = vec_elt_at_index(bdm->bd_oper, bd_index); + + hash_set(bdm->oper_bd_index_by_bd_id, bd_id, bd_index); + + bd_oper->bd_id = bd_id; + bd_oper->flood = mp->flood != 0; + bd_oper->forward = mp->forward != 0; + bd_oper->learn = mp->learn != 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); + + bd_oper->bd_sw_if_oper = 0; +} + +static void +vl_api_bridge_domain_sw_if_details_t_handler +(vl_api_bridge_domain_sw_if_details_t * mp) +{ + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + bd_sw_if_oper_t * bd_sw_if_oper; + u32 bd_id, sw_if_index; + + bd_id = ntohl (mp->bd_id); + sw_if_index = ntohl (mp->sw_if_index); + + uword *p; + p = hash_get (bdm->oper_bd_index_by_bd_id, bd_id); + if (p == 0) { + clib_warning("Invalid bd_id %d in bridge_domain_sw_if_details_t_handler", bd_id); + return; + } + u32 oper_bd_index = (jint) p[0]; + vjbd_oper_t *bd_oper = vec_elt_at_index(bdm->bd_oper, oper_bd_index); + + u32 len = vec_len(bd_oper->bd_sw_if_oper); + vec_validate(bd_oper->bd_sw_if_oper, len); + bd_sw_if_oper = &bd_oper->bd_sw_if_oper[len]; + bd_sw_if_oper->bd_id = bd_id; + bd_sw_if_oper->sw_if_index = sw_if_index; + bd_sw_if_oper->shg = mp->shg; + + hash_set(bdm->bd_id_by_sw_if_index, sw_if_index, bd_id); +} + +static const char* interface_name_from_sw_if_index(u32 sw_if_index) +{ + vppjni_main_t *jm = &vppjni_main; + + if (sw_if_index >= vec_len(jm->sw_if_table)) { + return NULL; + } + if (!jm->sw_if_table[sw_if_index].valid) { + return NULL; + } + return (const char*)jm->sw_if_table[sw_if_index].interface_name; +} + +JNIEXPORT jobject JNICALL Java_org_openvpp_vppjapi_vppConn_getBridgeDomainDetails0 +(JNIEnv * env, jobject obj, jint bdId) +{ + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + u32 oper_bd_index; + u32 bd_id = bdId; + jobject rv = NULL; + uword *p; + + vppjni_lock (jm, 16); + + p = hash_get (bdm->oper_bd_index_by_bd_id, bd_id); + if (p == 0) { + rv = NULL; + goto out; + } + oper_bd_index = (jint) p[0]; + + vjbd_oper_t *bd_oper = vec_elt_at_index(bdm->bd_oper, oper_bd_index); + + + /* setting BridgeDomainDetails */ + + 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; + } + char *str_bd_name = (char*)format (0, "%s%c", vec_bd_name, 0); + vec_free(vec_bd_name); + jstring bdName = (*env)->NewStringUTF(env, str_bd_name); + vec_free(str_bd_name); + if (NULL == bdName) { + rv = NULL; + goto out; + } + + 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) { + const char *str_if_name = interface_name_from_sw_if_index(bd_oper->bvi_sw_if_index); + if (NULL == str_if_name) { + clib_warning("Could not get interface name for sw_if_index %d", bd_oper->bvi_sw_if_index); + rv = NULL; + goto out; + } + bviInterfaceName = (*env)->NewStringUTF(env, str_if_name); + if (NULL == bviInterfaceName) { + rv = NULL; + goto out; + } + } + + set_vppBridgeDomainDetails_bviInterfaceName(env, bddObj, bviInterfaceName); + + /* setting BridgeDomainInterfaceDetails */ + + u32 len = vec_len(bd_oper->bd_sw_if_oper); + ASSERT(len == bd_oper->n_sw_ifs); + + 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]; + + jobject bdidObj = vppBridgeDomainInterfaceDetailsObject(env); + (*env)->SetObjectArrayElement(env, bdidArray, i, bdidObj); + + u32 sw_if_index = sw_if_oper->sw_if_index; + const char *str_if_name = interface_name_from_sw_if_index(sw_if_index); + if (NULL == str_if_name) { + rv = NULL; + goto out; + } + jstring interfaceName = (*env)->NewStringUTF(env, str_if_name); + if (NULL == interfaceName) { + rv = NULL; + goto out; + } + + set_vppBridgeDomainInterfaceDetails_interfaceName(env, bdidObj, interfaceName); + set_vppBridgeDomainInterfaceDetails_splitHorizonGroup(env, bdidObj, (jbyte)sw_if_oper->shg); + } + + set_vppBridgeDomainDetails_interfaces(env, bddObj, bdidArray); + + rv = bddObj; + +out: + + vppjni_unlock (jm); + + return rv; +} + +static jobject l2_fib_create_object(JNIEnv *env, bd_l2fib_oper_t *l2_fib) +{ + 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) { + return NULL; + } + jstring interfaceName = (*env)->NewStringUTF(env, str_if_name); + if (NULL == interfaceName) { + return NULL; + } + + jbyteArray physAddr = (*env)->NewByteArray(env, 6); + (*env)->SetByteArrayRegion(env, physAddr, 0, 6, + (signed char*)l2_fib->mac_addr.fields.mac); + jboolean staticConfig = !l2_fib->learned; + jstring outgoingInterface = interfaceName; + jboolean filter = l2_fib->filter; + jboolean bridgedVirtualInterface = l2_fib->bvi; + + return vppL2FibObject(env, physAddr, staticConfig, outgoingInterface, filter, bridgedVirtualInterface); +} + +JNIEXPORT jobjectArray JNICALL Java_org_openvpp_vppjapi_vppConn_l2FibTableDump0 +(JNIEnv * env, jobject obj, jint bd_id) +{ + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + vl_api_l2_fib_table_dump_t *mp; + jobjectArray l2FibArray = NULL; + vjbd_oper_t *bd_oper; + u32 oper_bd_index; + uword *p; + f64 timeout; + int rv; + u32 i; + + vppjni_lock (jm, 17); + + //vjbd_l2fib_oper_reset (bdm); + + p = hash_get (bdm->oper_bd_index_by_bd_id, bd_id); + if (p == 0) { + goto done; + } + oper_bd_index = p[0]; + bd_oper = vec_elt_at_index(bdm->bd_oper, oper_bd_index); + vec_reset_length (bd_oper->l2fib_oper); + + /* Get list of l2 fib table entries */ + M(L2_FIB_TABLE_DUMP, l2_fib_table_dump); + mp->bd_id = ntohl(bd_id); + 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(bd_oper->l2fib_oper); + bd_l2fib_oper_t *l2fib_oper = bd_oper->l2fib_oper; + + l2FibArray = vppL2FibArray(env, count); + for (i = 0; i < count; i++) { + bd_l2fib_oper_t *l2_fib = &l2fib_oper[i]; + jobject l2FibObj = l2_fib_create_object(env, l2_fib); + (*env)->SetObjectArrayElement(env, l2FibArray, i, l2FibObj); + } + +done: + vppjni_unlock (jm); + + return l2FibArray; +} + +static void +vl_api_l2_fib_table_entry_t_handler (vl_api_l2_fib_table_entry_t * mp) +{ + //static u8 * mac_addr; + vppjni_main_t *jm = &vppjni_main; + vjbd_main_t * bdm = &jm->vjbd_main; + vjbd_oper_t * bd_oper; + u32 bd_id, oper_bd_index; + //uword mhash_val_l2fi; + bd_l2fib_oper_t * l2fib_oper; + l2fib_u64_mac_t * l2fe_u64_mac = (l2fib_u64_mac_t *)&mp->mac; + + bd_id = ntohl (mp->bd_id); + + uword *p = hash_get (bdm->oper_bd_index_by_bd_id, bd_id); + if (p == 0) { + return; + } + oper_bd_index = (jint) p[0]; + bd_oper = vec_elt_at_index(bdm->bd_oper, oper_bd_index); + +#if 0 + vec_validate (mac_addr, MAC_ADDRESS_SIZE); + memcpy (mac_addr, l2fe_u64_mac->fields.mac, MAC_ADDRESS_SIZE); + mhash_val_l2fi = vec_len (bd_oper->l2fib_oper); + if (mhash_elts (&bd_oper->l2fib_index_by_mac) == 0) + mhash_init (&bd_oper->l2fib_index_by_mac, sizeof (u32), MAC_ADDRESS_SIZE); + mhash_set_mem (&bd_oper->l2fib_index_by_mac, mac_addr, &mhash_val_l2fi, 0); +#endif + + vec_add2 (bd_oper->l2fib_oper, l2fib_oper, 1); + + l2fib_oper->bd_id = bd_id; + l2fib_oper->mac_addr.raw = l2fib_mac_to_u64 (l2fe_u64_mac->fields.mac); + l2fib_oper->sw_if_index = ntohl (mp->sw_if_index); + l2fib_oper->learned = !mp->static_mac; + l2fib_oper->filter = mp->filter_mac; + 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); + if (!if_name) { + return -1; + } + + 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_ipv4AddressDump0 +(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_ipv6AddressDump0 +(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_vxlanTunnelDump0 +(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 */ +static void cleanup_rx_thread(void *arg) +{ + vppjni_main_t * jm = &vppjni_main; + + vppjni_lock (jm, 99); + + int getEnvStat = (*jm->jvm)->GetEnv(jm->jvm, (void **)&(jm->jenv), JNI_VERSION_1_6); + if (getEnvStat == JNI_EVERSION) { + clib_warning ("Unsupported JNI version\n"); + jm->retval = -999; + goto out; + } else if (getEnvStat != JNI_EDETACHED) { + (*jm->jvm)->DetachCurrentThread(jm->jvm); + } +out: + vppjni_unlock (jm); +} + +static void +vl_api_show_version_reply_t_handler (vl_api_show_version_reply_t * mp) +{ + vppjni_main_t * jm = &vppjni_main; + i32 retval = ntohl(mp->retval); + + if (retval >= 0) { + 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; + + strncpy((char*)jm->build_directory, (const char*)mp->build_directory, + sizeof(jm->build_directory)-1); + jm->build_directory[sizeof(jm->build_directory)-1] = 0; + + strncpy((char*)jm->version, (const char*)mp->version, + sizeof(jm->version)-1); + jm->version[sizeof(jm->version)-1] = 0; + + strncpy((char*)jm->build_date, (const char*)mp->build_date, + sizeof(jm->build_date)-1); + jm->build_date[sizeof(jm->build_date)-1] = 0; + } else { + clib_error ("show version request failed(%d)", retval); + } + jm->retval = retval; + jm->result_ready = 1; +} + +static void vl_api_want_stats_reply_t_handler (vl_api_want_stats_reply_t * mp) +{ + vppjni_main_t * jm = &vppjni_main; + jm->retval = mp->retval; // FIXME: vpp api does not do ntohl on this retval + jm->result_ready = 1; +} + +// control ping needs to be very first thing called +// to attach rx thread to java thread +static void vl_api_control_ping_reply_t_handler +(vl_api_control_ping_reply_t * mp) +{ + vppjni_main_t * jm = &vppjni_main; + i32 retval = ntohl(mp->retval); + jm->retval = retval; + + // attach to java thread if not attached + int getEnvStat = (*jm->jvm)->GetEnv(jm->jvm, (void **)&(jm->jenv), JNI_VERSION_1_6); + if (getEnvStat == JNI_EDETACHED) { + if ((*jm->jvm)->AttachCurrentThread(jm->jvm, (void **)&(jm->jenv), NULL) != 0) { + clib_warning("Failed to attach thread\n"); + jm->retval = -999; + goto out; + } + + // workaround as we can't use pthread_cleanup_push + pthread_key_create(&jm->cleanup_rx_thread_key, cleanup_rx_thread); + // destructor is only called if the value of key is non null + pthread_setspecific(jm->cleanup_rx_thread_key, (void *)1); + } else if (getEnvStat == JNI_EVERSION) { + clib_warning ("Unsupported JNI version\n"); + jm->retval = -999; + goto out; + } + // 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 + JNIEnv *env = jm->jenv; + u16 msg_id = (u16)p[0]; + + // we will no longer need this + hash_unset (jm->ping_hash, context); + + // get original caller obj + p = hash_get (jm->callback_hash, context); + + if (p == 0) // don't have callback stored + goto out; + + jobject obj = (jobject)p[0]; // object that called original call + + switch (msg_id) { + case VL_API_SW_INTERFACE_DUMP: + if (0 != sw_if_dump_call_all_callbacks(obj)) { + goto out2; + } + break; + default: + clib_warning("Unhandled control ping issuer msg-id: %d", msg_id); + goto out2; + break; + } +out2: + // free the saved obj + hash_unset (jm->callback_hash, context); + // delete global reference + (*env)->DeleteGlobalRef(env, obj); + } +#endif + +out: + jm->result_ready = 1; +} + +#define VPPJNI_DEBUG_COUNTERS 0 + +static void vl_api_vnet_interface_counters_t_handler +(vl_api_vnet_interface_counters_t *mp) +{ + vppjni_main_t *jm = &vppjni_main; + CLIB_UNUSED(char *counter_name); + u32 count, sw_if_index; + int i; + static sw_interface_stats_t empty_stats = {0, }; + + vppjni_lock (jm, 12); + count = ntohl (mp->count); + sw_if_index = ntohl (mp->first_sw_if_index); + if (mp->is_combined == 0) { + u64 * vp, v; + vp = (u64 *) mp->data; + + for (i = 0; i < count; i++) { + sw_interface_details_t *sw_if = NULL; + + v = clib_mem_unaligned (vp, u64); + v = clib_net_to_host_u64 (v); + vp++; + + if (sw_if_index < vec_len(jm->sw_if_table)) + sw_if = vec_elt_at_index(jm->sw_if_table, sw_if_index); + + if (sw_if /* && (sw_if->admin_up_down == 1)*/ && sw_if->interface_name[0] != 0) { + vec_validate_init_empty(jm->sw_if_stats_by_sw_if_index, sw_if_index, empty_stats); + sw_interface_stats_t * s = vec_elt_at_index(jm->sw_if_stats_by_sw_if_index, sw_if_index); + + s->sw_if_index = sw_if_index; + s->valid = 1; + + switch (mp->vnet_counter_type) { + case VNET_INTERFACE_COUNTER_DROP: + counter_name = "drop"; + s->rx.pkts.discard = v; + break; + case VNET_INTERFACE_COUNTER_PUNT: + counter_name = "punt"; + s->rx.pkts.unknown_proto = v; + break; + case VNET_INTERFACE_COUNTER_IP4: + counter_name = "ip4"; + s->rx.pkts.ip4 = v; + break; + case VNET_INTERFACE_COUNTER_IP6: + counter_name = "ip6"; + s->rx.pkts.ip6 = v; + break; + case VNET_INTERFACE_COUNTER_RX_NO_BUF: + counter_name = "rx-no-buf"; + s->rx.pkts.fifo_full = v; + break; + case VNET_INTERFACE_COUNTER_RX_MISS: + counter_name = "rx-miss"; + s->rx.pkts.miss = v; + break; + case VNET_INTERFACE_COUNTER_RX_ERROR: + counter_name = "rx-error"; + s->rx.pkts.error = v; + break; + case VNET_INTERFACE_COUNTER_TX_ERROR: + counter_name = "tx-error (fifo-full)"; + s->tx.pkts.fifo_full = v; + break; + default: + counter_name = "bogus"; + break; + } + +#if VPPJNI_DEBUG_COUNTERS == 1 + clib_warning ("%s (%d): %s (%lld)\n", sw_if->interface_name, s->sw_if_index, + counter_name, v); +#endif + } + sw_if_index++; + } + } else { + vlib_counter_t *vp; + u64 packets, bytes; + vp = (vlib_counter_t *) mp->data; + + for (i = 0; i < count; i++) { + sw_interface_details_t *sw_if = NULL; + + packets = clib_mem_unaligned (&vp->packets, u64); + packets = clib_net_to_host_u64 (packets); + bytes = clib_mem_unaligned (&vp->bytes, u64); + bytes = clib_net_to_host_u64 (bytes); + vp++; + + if (sw_if_index < vec_len(jm->sw_if_table)) + sw_if = vec_elt_at_index(jm->sw_if_table, sw_if_index); + + if (sw_if /* && (sw_if->admin_up_down == 1) */ && sw_if->interface_name[0] != 0) { + vec_validate_init_empty(jm->sw_if_stats_by_sw_if_index, sw_if_index, empty_stats); + sw_interface_stats_t * s = vec_elt_at_index(jm->sw_if_stats_by_sw_if_index, sw_if_index); + + s->valid = 1; + s->sw_if_index = sw_if_index; + + switch (mp->vnet_counter_type) { + case VNET_INTERFACE_COUNTER_RX: + s->rx.pkts.unicast = packets; + s->rx.octets = bytes; + counter_name = "rx"; + break; + + case VNET_INTERFACE_COUNTER_TX: + s->tx.pkts.unicast = packets; + s->tx.octets = bytes; + counter_name = "tx"; + break; + + default: + counter_name = "bogus"; + break; + } + +#if VPPJNI_DEBUG_COUNTERS == 1 + clib_warning ("%s (%d): %s.packets %lld\n", + sw_if->interface_name, + sw_if_index, counter_name, packets); + clib_warning ("%s (%d): %s.bytes %lld\n", + sw_if->interface_name, + sw_if_index, counter_name, bytes); +#endif + } + sw_if_index++; + } + } + vppjni_unlock (jm); +} + +jint JNI_OnLoad(JavaVM *vm, void *reserved) { + vppjni_main_t * jm = &vppjni_main; + JNIEnv* env; + if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_6) != JNI_OK) { + return JNI_ERR; + } + + if (vppjni_init(env) != 0) { + return JNI_ERR; + } + + jm->jvm = vm; + return JNI_VERSION_1_6; +} + +void JNI_OnUnload(JavaVM *vm, void *reserved) { + vppjni_main_t * jm = &vppjni_main; + JNIEnv* env; + if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_6) != JNI_OK) { + return; + } + + vppjni_uninit(env); + + jm->jenv = NULL; + jm->jvm = NULL; +} + +#define foreach_vpe_api_msg \ +_(CONTROL_PING_REPLY, control_ping_reply) \ +_(SW_INTERFACE_DETAILS, sw_interface_details) \ +_(SHOW_VERSION_REPLY, show_version_reply) \ +_(WANT_STATS_REPLY, want_stats_reply) \ +_(VNET_INTERFACE_COUNTERS, vnet_interface_counters) \ +_(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) \ +_(IP_ADDRESS_DETAILS, ip_address_details) \ +_(VXLAN_TUNNEL_DETAILS, vxlan_tunnel_details) + +static int connect_to_vpe(char *name) +{ + vppjni_main_t * jm = &vppjni_main; + api_main_t * am = &api_main; + + if (vl_client_connect_to_vlib("/vpe-api", name, 32) < 0) + return -1; + + jm->my_client_index = am->my_client_index; + jm->vl_input_queue = am->shmem_hdr->vl_input_queue; + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_vpe_api_msg; +#undef _ + + return 0; +} + +/* Format an IP6 address. */ +u8 * format_ip6_address (u8 * s, va_list * args) +{ + ip6_address_t * a = va_arg (*args, ip6_address_t *); + u32 max_zero_run = 0, this_zero_run = 0; + int max_zero_run_index = -1, this_zero_run_index=0; + int in_zero_run = 0, i; + int last_double_colon = 0; + + /* Ugh, this is a pain. Scan forward looking for runs of 0's */ + for (i = 0; i < ARRAY_LEN (a->as_u16); i++) { + if (a->as_u16[i] == 0) { + if (in_zero_run) { + this_zero_run++; + } else { + in_zero_run = 1; + this_zero_run =1; + this_zero_run_index = i; + } + } else { + if (in_zero_run) { + /* offer to compress the biggest run of > 1 zero */ + if (this_zero_run > max_zero_run && this_zero_run > 1) { + max_zero_run_index = this_zero_run_index; + max_zero_run = this_zero_run; + } + } + in_zero_run = 0; + this_zero_run = 0; + } + } + + if (in_zero_run) { + if (this_zero_run > max_zero_run && this_zero_run > 1) { + max_zero_run_index = this_zero_run_index; + max_zero_run = this_zero_run; + } + } + + for (i = 0; i < ARRAY_LEN (a->as_u16); i++) { + if (i == max_zero_run_index) { + s = format (s, "::"); + i += max_zero_run - 1; + last_double_colon = 1; + } else { + s = format (s, "%s%x", + (last_double_colon || i == 0) ? "" : ":", + clib_net_to_host_u16 (a->as_u16[i])); + last_double_colon = 0; + } + } + + return s; +} + +/* Format an IP4 address. */ +u8 * format_ip4_address (u8 * s, va_list * args) +{ + u8 * a = va_arg (*args, u8 *); + return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]); +} + + diff --git a/vpp-api/java/japi/vppjni.h b/vpp-api/java/japi/vppjni.h new file mode 100644 index 00000000000..bd0683ae2c5 --- /dev/null +++ b/vpp-api/java/japi/vppjni.h @@ -0,0 +1,308 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef __included_vppjni_h__ +#define __included_vppjni_h__ + +#include <vnet/vnet.h> +#include <vnet/ip/ip.h> +#include <vnet/api_errno.h> +#include <vlibapi/api.h> +#include <vlibmemory/api.h> +#include <jni.h> +#include <japi/vppjni_bridge_domain.h> + +typedef struct { + u8 * name; + u32 value; +} name_sort_t; + +typedef struct { + u8 valid; // used in a vector of sw_interface_details_t + + u8 interface_name[64]; + u32 sw_if_index; + u32 sup_sw_if_index; + u32 l2_address_length; + u8 l2_address[8]; + u8 admin_up_down; + u8 link_up_down; + u8 link_duplex; + u8 link_speed; + u16 link_mtu; + u32 sub_id; + u8 sub_dot1ad; + u8 sub_number_of_tags; + u16 sub_outer_vlan_id; + u16 sub_inner_vlan_id; + u8 sub_exact_match; + u8 sub_default; + u8 sub_outer_vlan_id_any; + u8 sub_inner_vlan_id_any; + u32 vtr_op; + u32 vtr_push_dot1q; + u32 vtr_tag1; + u32 vtr_tag2; +} sw_interface_details_t; + +typedef struct { + u8 * interface_name; + u32 sw_if_index; + /* + * Subinterface ID. A number 0-N to uniquely identify + * this subinterface under the super interface + */ + u32 sub_id; + + /* 0 = dot1q, 1=dot1ad */ + u8 sub_dot1ad; + + /* Number of tags 0-2 */ + u8 sub_number_of_tags; + u16 sub_outer_vlan_id; + u16 sub_inner_vlan_id; + u8 sub_exact_match; + u8 sub_default; + u8 sub_outer_vlan_id_any; + u8 sub_inner_vlan_id_any; + + /* vlan tag rewrite */ + u32 vtr_op; + u32 vtr_push_dot1q; + u32 vtr_tag1; + u32 vtr_tag2; +} sw_interface_subif_t; + +typedef struct { + u8 *desc; +} sw_if_config_t; + +typedef struct { + u32 ip; + u8 prefix_length; +} ipv4_address_t; + +typedef struct { + u8 ip[16]; + u8 prefix_length; +} ipv6_address_t; + +typedef struct { + u64 ip4; + u64 ip6; + u64 unicast; + u64 multicast; + u64 broadcast; + u64 discard; + u64 fifo_full; + u64 error; + u64 unknown_proto; + u64 miss; +} packet_counters_t; + +typedef struct { + u64 octets; + packet_counters_t pkts; +} if_counters_t; + +typedef struct { + u8 valid; + u32 sw_if_index; + if_counters_t rx; + if_counters_t tx; +} sw_interface_stats_t; + +typedef struct { + u32 src_address; + u32 dst_address; + u32 encap_vrf_id; + u32 vni; + u32 decap_next_index; +} vxlan_tunnel_details_t; + + +typedef struct { + /* Context IDs */ + volatile u32 context_id_sent; + volatile u32 context_id_received; + + /* Spinlock */ + volatile u32 lock; + u32 tag; + + /* To recycle pseudo-synchronous message code from vpp_api_test... */ + volatile u32 result_ready; + volatile i32 retval; + volatile u8 *shmem_result; + + /* thread cleanup */ + pthread_key_t cleanup_rx_thread_key; + /* attachment of rx thread to java thread */ + JNIEnv *jenv; + JavaVM *jvm; + uword *callback_hash; // map context_id => jobject + uword *ping_hash; // map ping context_id => msg type called + + /* Timestamp */ + clib_time_t clib_time; + + /* connected indication */ + u8 is_connected; + + /* context -> non-trivial reply hash */ + uword * reply_hash; + u32 saved_reply_count; + + /* interface name map */ + uword * sw_if_index_by_interface_name; + + /* interface counters */ + sw_interface_stats_t * sw_if_stats_by_sw_if_index; + + /* interface table */ + sw_interface_details_t * sw_if_table; + + uword * sw_if_config_by_sw_if_index; + + /* interface indices of responses to one sw_if_dump request */ + u8 collect_indices; + u32 * sw_if_dump_if_indices; + + /* program name, build_dir, version */ + u8 program_name[32]; + u8 build_directory[256]; + u8 version[32]; + u8 build_date[32]; + + /* subinterface table */ + sw_interface_subif_t * sw_if_subif_table; + + /* used in ip_address_dump request and response handling */ + ipv4_address_t *ipv4_addresses; + ipv6_address_t *ipv6_addresses; + u8 is_ipv6; + + /* used in vxlan_tunnel_dump request and response handling */ + vxlan_tunnel_details_t *vxlan_tunnel_details; + + /* main heap */ + u8 * heap; + + /* convenience */ + unix_shared_memory_queue_t * vl_input_queue; + api_main_t * api_main; + u32 my_client_index; + + vjbd_main_t vjbd_main; +} vppjni_main_t; + +vppjni_main_t vppjni_main __attribute__((aligned (64))); + + +static inline u32 vppjni_get_context_id (vppjni_main_t * jm) +{ + u32 my_context_id; + my_context_id = __sync_add_and_fetch (&jm->context_id_sent, 1); + return my_context_id; +} + +static inline void vppjni_lock (vppjni_main_t * jm, u32 tag) +{ + while (__sync_lock_test_and_set (&jm->lock, 1)) + ; + jm->tag = tag; +} + +static inline void vppjni_unlock (vppjni_main_t * jm) +{ + jm->tag = 0; + CLIB_MEMORY_BARRIER(); + jm->lock = 0; +} + +static inline f64 vppjni_time_now (vppjni_main_t *jm) +{ + return clib_time_now (&jm->clib_time); +} + +static inline int vppjni_sanity_check (vppjni_main_t * jm) +{ + if (!jm->is_connected) + return VNET_API_ERROR_NOT_CONNECTED; + return 0; +} + +#define __PACKED(x) x __attribute__((packed)) + +typedef __PACKED(struct _vl_api_generic_reply { + u16 _vl_msg_id; + u32 context; + i32 retval; + u8 data[0]; +}) vl_api_generic_reply_t; + +void vl_api_generic_reply_handler (vl_api_generic_reply_t *mp); + +/* M: construct, but don't yet send a message */ + +#define M(T,t) \ +do { \ + jm->result_ready = 0; \ + mp = vl_msg_api_alloc(sizeof(*mp)); \ + memset (mp, 0, sizeof (*mp)); \ + mp->_vl_msg_id = ntohs (VL_API_##T); \ + mp->client_index = jm->my_client_index; \ + } while(0); + +#define M2(T,t,n) \ +do { \ + jm->result_ready = 0; \ + mp = vl_msg_api_alloc(sizeof(*mp)+(n)); \ + memset (mp, 0, sizeof (*mp)); \ + mp->_vl_msg_id = ntohs (VL_API_##T); \ + mp->client_index = jm->my_client_index; \ + } while(0); + + +/* S: send a message */ +#define S (vl_msg_api_send_shmem (jm->vl_input_queue, (u8 *)&mp)) + +/* W: wait for results, with timeout */ +#define W \ + do { \ + timeout = vppjni_time_now (jm) + 1.0; \ + \ + while (vppjni_time_now (jm) < timeout) { \ + if (jm->result_ready == 1) { \ + return (jm->retval); \ + } \ + } \ + return -99; \ +} while(0); + +/* WNR: wait for results, with timeout (without returning) */ +#define WNR \ + do { \ + timeout = vppjni_time_now (jm) + 1.0; \ + \ + rv = -99; \ + while (vppjni_time_now (jm) < timeout) { \ + if (jm->result_ready == 1) { \ + rv = (jm->retval); \ + break; \ + } \ + } \ +} while(0); + +#endif /* __included_vppjni_h__ */ diff --git a/vpp-api/java/japi/vppjni_bridge_domain.h b/vpp-api/java/japi/vppjni_bridge_domain.h new file mode 100644 index 00000000000..b614a5becb5 --- /dev/null +++ b/vpp-api/java/japi/vppjni_bridge_domain.h @@ -0,0 +1,510 @@ +/*--------------------------------------------------------------------------- + * Copyright (c) 2009-2014 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *--------------------------------------------------------------------------- + */ + +#ifndef __included_vppjni_bridge_domain_h__ +#define __included_vppjni_bridge_domain_h__ + +#include <vlib/vlib.h> +#include <vppinfra/clib.h> +#include <vppinfra/mhash.h> + +/* + * The L2fib key is the mac address and bridge domain ID + */ +#define MAC_ADDRESS_SIZE 6 + +typedef struct { + union { + struct { + u16 unused1; + u8 mac[MAC_ADDRESS_SIZE]; + } fields; + u64 raw; + }; +} l2fib_u64_mac_t; + +/* + * The l2fib entry results + */ +typedef struct { + u32 bd_id; + l2fib_u64_mac_t mac_addr; + u32 sw_if_index; + u8 learned:1; + u8 bvi:1; + u8 filter:1; // drop packets to/from this mac + u8 unused1:5; +} bd_l2fib_oper_t; + +typedef struct { + u32 bd_id; + u8 * bd_name; +} bd_local_cfg_t; + +typedef struct { + u32 bd_id; + u32 sw_if_index; + u32 shg; +} bd_sw_if_oper_t; + +typedef struct { + u32 bd_id; + u8 flood:1; + u8 forward:1; + u8 learn:1; + u8 uu_flood:1; + u8 arp_term:1; + u8 unused1:3; + u32 bvi_sw_if_index; + u32 n_sw_ifs; + bd_sw_if_oper_t * bd_sw_if_oper; + f64 last_sync_time; + mhash_t l2fib_index_by_mac; + bd_l2fib_oper_t * l2fib_oper; // vector indexed by l2fib_index +} vjbd_oper_t; + +#define BD_OPER_REFRESH_INTERVAL 2.0 +#define BD_OPER_L2FIB_REFRESH_INTERVAL 5.0 + +typedef struct { + u32 next_bd_id; + uword * bd_index_bitmap; + uword * bd_index_by_id; + mhash_t bd_id_by_name; + bd_local_cfg_t * local_cfg; // vector indexed by bd_index + vjbd_oper_t * bd_oper; // vector indexed by oper_bd_index + f64 bd_oper_last_sync_all_time; + bd_sw_if_oper_t * sw_if_oper; // vector indexed by sw_if_index + f64 l2fib_oper_last_sync_time; + uword * bd_id_by_sw_if_index; + uword * oper_bd_index_by_bd_id; +} vjbd_main_t; + +extern vjbd_main_t vjbd_main; + +always_inline +u64 l2fib_mac_to_u64 (u8 * mac_address) { + u64 temp; + + // The mac address in memory is A:B:C:D:E:F + // The bd id in register is H:L +#if CLIB_ARCH_IS_LITTLE_ENDIAN + // Create the in-register key as F:E:D:C:B:A:H:L + // In memory the key is L:H:A:B:C:D:E:F + temp = *((u64 *)(mac_address - 2)); + temp = (temp & ~0xffff); +#else + // Create the in-register key as H:L:A:B:C:D:E:F + // In memory the key is H:L:A:B:C:D:E:F + temp = *((u64 *)(mac_address)) >> 16; +#endif + + return temp; +} + +static_always_inline void vjbd_main_init (vjbd_main_t *bdm) +{ + bdm->bd_index_by_id = hash_create (0, sizeof(uword)); + mhash_init_vec_string (&bdm->bd_id_by_name, sizeof (u32)); + bdm->bd_id_by_sw_if_index = hash_create (0, sizeof (u32)); + bdm->oper_bd_index_by_bd_id = hash_create (0, sizeof (u32)); +} + +static_always_inline u32 vjbd_id_is_valid (vjbd_main_t * bdm, u32 bd_id) +{ + return ((bd_id != 0) && (bd_id != ~0) && (bd_id <= bdm->next_bd_id)); +} + +static_always_inline u32 vjbd_index_is_free (vjbd_main_t * bdm, u16 bd_index) +{ + u32 bd_id = vec_elt_at_index(bdm->local_cfg, bd_index)->bd_id; + + return (!clib_bitmap_get (bdm->bd_index_bitmap, (bd_index)) && + (bd_index < vec_len (bdm->local_cfg)) && + ((bd_id == 0) || (bd_id == ~0))); +} + +static_always_inline u32 vjbd_index_is_valid (vjbd_main_t * bdm, u16 bd_index) +{ + return (clib_bitmap_get (bdm->bd_index_bitmap, bd_index) && + (bd_index < vec_len (bdm->local_cfg))); +} + +static_always_inline u32 vjbd_id_from_name (vjbd_main_t * bdm, + const u8 * bd_name) +{ + u32 bd_id; + uword * p; + + ASSERT (vec_c_string_is_terminated (bd_name)); + + if (bdm->next_bd_id == 0) + return ~0; + + p = mhash_get (&bdm->bd_id_by_name, (void *)bd_name); + if (p) + { + bd_id = p[0]; + ASSERT (vjbd_id_is_valid (bdm, bd_id)); + } + else + bd_id = ~0; + + return bd_id; +} + +static_always_inline u32 vjbd_index_from_id (vjbd_main_t * bdm, u32 bd_id) +{ + uword * p; + u16 bd_index; + + ASSERT (vjbd_id_is_valid (bdm, bd_id)); + + p = hash_get (bdm->bd_index_by_id, bd_id); + + ASSERT (p); // there is always an index associated with a valid bd_id + bd_index = p[0]; + + ASSERT (vjbd_index_is_valid (bdm, bd_index)); + + return bd_index; +} + +static_always_inline u32 vjbd_id_from_index (vjbd_main_t * bdm, u16 bd_index) +{ + u32 bd_id; + + ASSERT (vjbd_index_is_valid (bdm, bd_index)); + + bd_id = vec_elt_at_index(bdm->local_cfg, bd_index)->bd_id; + + ASSERT (vjbd_id_is_valid (bdm, bd_id)); + + return bd_id; +} + +static_always_inline u8 * vjbd_name_from_id (vjbd_main_t * bdm, u32 bd_id) +{ + u16 bd_index = vjbd_index_from_id (bdm, bd_id); + + return vec_elt_at_index(bdm->local_cfg, bd_index)->bd_name; +} + +static_always_inline u8 * vjbd_oper_name_from_id (vjbd_main_t * bdm, u32 bd_id) +{ + if (vjbd_id_is_valid (bdm, bd_id)) { + return format(0, "%s", vjbd_name_from_id(bdm, bd_id)); + } else { + return format(0, "BridgeDomainOper%d", bd_id); + } +} + +static_always_inline vjbd_oper_t * vjbd_oper_from_id (vjbd_main_t * bdm, + u32 bd_id) +{ + u16 bd_index = vjbd_index_from_id (bdm, bd_id); + return vec_elt_at_index (bdm->bd_oper, bd_index); +} + +static_always_inline void vjbd_oper_maybe_sync_from_vpp (vjbd_main_t * bdm, + u32 bd_id) +{ +#ifdef VPPJNI_OPER + vppjni_vpe_api_msg_main_t *ovam = ovam_get_main (); + + if (bd_id == ~0) + { + if ((ovam_time_now (ovam) - bdm->bd_oper_last_sync_all_time) > + BD_OPER_REFRESH_INTERVAL) + { + ovam_bridge_domain_dump (bd_id); + bdm->bd_oper_last_sync_all_time = ovam_time_now (ovam); + } + } + + else + { + vjbd_oper_t * bd_oper = vjbd_oper_from_id (bdm, bd_id); + + if ((ovam_time_now (ovam) - bd_oper->last_sync_time) > + BD_OPER_REFRESH_INTERVAL) + { + ovam_bridge_domain_dump (bd_id); + + bd_oper->last_sync_time = ovam_time_now (ovam); + } + } +#endif +} + +static_always_inline u32 vjbd_id_from_sw_if_index (vjbd_main_t * bdm, + u32 sw_if_index) +{ + bd_sw_if_oper_t * bd_sw_if_oper; + u32 bd_id = ~0; + + vjbd_oper_maybe_sync_from_vpp (bdm, ~0); + if (sw_if_index < vec_len (bdm->sw_if_oper)) + { + bd_sw_if_oper = vec_elt_at_index (bdm->sw_if_oper, sw_if_index); + bd_id = bd_sw_if_oper->bd_id; + } + + return bd_id; +} + +static_always_inline u8 * vjbd_name_from_sw_if_index (vjbd_main_t * bdm, + u32 sw_if_index) +{ + u32 bd_id, bd_index; + u8 * bd_name = 0; + + /* DAW-FIXME: + ASSERT (ovam_sw_if_index_valid (ovam_get_main(), sw_if_index)); + */ + vjbd_oper_maybe_sync_from_vpp (bdm, ~0); + bd_id = vjbd_id_from_sw_if_index (bdm, sw_if_index); + if (vjbd_id_is_valid (bdm, bd_id)) + { + bd_index = vjbd_index_from_id (bdm, bd_id); + bd_name = vec_elt_at_index (bdm->local_cfg, bd_index)->bd_name; + } + + return bd_name; +} + +static_always_inline u32 +vjbd_oper_l2fib_index_from_mac (vjbd_oper_t * bd_oper, u8 * mac) +{ + u32 l2fib_index; + uword * p; + + p = mhash_get (&bd_oper->l2fib_index_by_mac, mac); + if (p) + { + l2fib_index = p[0]; + ASSERT (l2fib_index < vec_len (bd_oper->l2fib_oper)); + } + else + l2fib_index = ~0; + + return l2fib_index; +} + +static_always_inline u32 vjbd_local_cfg_next_id (vjbd_main_t * bdm, + u32 bd_id) +{ + u32 i, end = vec_len (bdm->local_cfg); + u32 next_bd_id = 0; + + if ((bd_id == 0) || vjbd_id_is_valid (bdm, bd_id)) + for (i = 0; i < end; i++) + { + u32 curr_bd_id = bdm->local_cfg[i].bd_id; + if ((curr_bd_id != ~0) && (curr_bd_id > bd_id) && + ((next_bd_id == 0) || (curr_bd_id < next_bd_id))) + next_bd_id = curr_bd_id; + } + + return next_bd_id; +} + +static_always_inline u32 vjbd_sw_if_oper_next_index (vjbd_main_t * bdm, + u32 start, u32 bd_id) +{ + u32 i, end = vec_len (bdm->sw_if_oper); + + if (vjbd_id_is_valid (bdm, bd_id)) + for (i = start; i < end; i++) + if (bdm->sw_if_oper[i].bd_id == bd_id) + return i; + + return ~0; +} + +static_always_inline void +vjbd_oper_l2fib_maybe_sync_from_vpp (vjbd_main_t * bdm) +{ +#ifdef VPPJNI_OPER + vppjni_vpe_api_msg_main_t *ovam = ovam_get_main (); + if ((ovam_time_now (ovam) - bdm->l2fib_oper_last_sync_time) > + BD_OPER_L2FIB_REFRESH_INTERVAL) + { + ovam_l2fib_table_dump (); + bdm->l2fib_oper_last_sync_time = ovam_time_now (ovam); + } +#endif +} + +static_always_inline void vjbd_l2fib_oper_reset (vjbd_main_t * bdm) +{ + vjbd_oper_t * bd_oper; + + vec_foreach (bd_oper, bdm->bd_oper) + { + mhash_init (&bd_oper->l2fib_index_by_mac, sizeof (u32), MAC_ADDRESS_SIZE); + vec_reset_length (bd_oper->l2fib_oper); + } +} + +static_always_inline void vjbd_oper_reset (vjbd_main_t * bdm, u32 bd_id) +{ + u16 bd_index; + u32 si, len; + vjbd_oper_t * bd_oper; + u32 end; + + if (!bdm->bd_oper) + { + ASSERT (vec_len (bdm->sw_if_oper) == 0); + return; + } + + if (bd_id == ~0) + { + bdm->bd_oper_last_sync_all_time = 0.0; + bd_index = 0; + end = vec_len (bdm->bd_oper); + } + else + { + bd_index = vjbd_index_from_id (bdm, bd_id); + end = bd_index + 1; + } + + for (; bd_index < end; bd_index++) + { + bd_oper = vec_elt_at_index (bdm->bd_oper, bd_index); + bd_oper->last_sync_time = 0.0; + + len = vec_len (bdm->sw_if_oper); + for (si = vjbd_sw_if_oper_next_index (bdm, 0, bd_id); + (si != ~0) && (si < len); + si = vjbd_sw_if_oper_next_index (bdm, si + 1, bd_id)) + { + bd_sw_if_oper_t * bd_sw_if_oper; + + bd_sw_if_oper = vec_elt_at_index (bdm->sw_if_oper, si); + bd_sw_if_oper->bd_id = ~0; + } + } +} + +static_always_inline void +vjbd_sw_if_add_del (u32 sw_if_index ,u32 bd_id, u8 bvi, u8 shg, u8 is_add) +{ + vjbd_main_t * bdm = &vjbd_main; + u16 bd_index = vjbd_index_from_id (bdm, bd_id); + vjbd_oper_t * bd_oper = vec_elt_at_index (bdm->bd_oper, bd_index); + bd_sw_if_oper_t * bd_sw_if_oper; + + ASSERT (vjbd_id_is_valid (bdm, bd_id)); + /* DAW-FIXME + ASSERT (ovam_sw_if_index_valid (ovam_get_main (), sw_if_index)); + */ + + vec_validate (bdm->sw_if_oper, sw_if_index); + bd_sw_if_oper = vec_elt_at_index (bdm->sw_if_oper, sw_if_index); + if (is_add) + { + bd_sw_if_oper->bd_id = bd_id; + bd_sw_if_oper->shg = shg; + bd_oper->bvi_sw_if_index = bvi ? sw_if_index : ~0; + } + else + { + bd_sw_if_oper->bd_id = 0; + bd_sw_if_oper->shg = 0; + if (bd_oper->bvi_sw_if_index == sw_if_index) + bd_oper->bvi_sw_if_index = ~0; + } +} + +static_always_inline u32 vjbd_id_sw_if_count (vjbd_main_t * bdm, u32 bd_id) +{ + u32 count = 0, i, end = vec_len (bdm->sw_if_oper); + + if (vjbd_id_is_valid (bdm, bd_id)) + for (count = i = 0; i < end; i++) + if (bdm->sw_if_oper[i].bd_id == bd_id) + count++; + + return count; +} + +static_always_inline u32 vjbd_find_or_add_bd (vjbd_main_t * bdm, u8 * bd_name) +{ + u16 bd_index; + u32 bd_id; + bd_local_cfg_t * bd_local_cfg; + uword mhash_val_bd_id; + + bd_id = vjbd_id_from_name (bdm, bd_name); + if (bd_id != ~0) + return bd_id; + + mhash_val_bd_id = bd_id = ++bdm->next_bd_id; + mhash_set_mem (&bdm->bd_id_by_name, (void *)bd_name, &mhash_val_bd_id, 0); + + bd_index = clib_bitmap_first_clear (bdm->bd_index_bitmap); + vec_validate (bdm->local_cfg, bd_index); + vec_validate (bdm->bd_oper, bd_index); + + ASSERT (vjbd_index_is_free (bdm, bd_index)); + + bd_local_cfg = vec_elt_at_index (bdm->local_cfg, bd_index); + bd_local_cfg->bd_id = bd_id; + vec_validate_init_c_string (bd_local_cfg->bd_name, bd_name, + vec_len (bd_name) - 1); + hash_set (bdm->bd_index_by_id, bd_id, bd_index); + bdm->bd_index_bitmap = clib_bitmap_set (bdm->bd_index_bitmap, + bd_index, 1); + return bd_id; +} + +static_always_inline void vjbd_delete_bd (vjbd_main_t * bdm, u32 bd_id) +{ + u16 bd_index; + bd_local_cfg_t * bd_local_cfg; + + ASSERT (vjbd_id_is_valid (bdm, bd_id)); + + // bd must not have any members before deleting + ASSERT (!vjbd_id_sw_if_count (bdm, bd_id)); + + bd_index = vjbd_index_from_id (bdm, bd_id); + bd_local_cfg = vec_elt_at_index (bdm->local_cfg, bd_index); + vjbd_oper_reset (bdm, bd_id); + + mhash_unset (&bdm->bd_id_by_name, vjbd_name_from_id (bdm, bd_id), 0); + bdm->bd_index_bitmap = clib_bitmap_set (bdm->bd_index_bitmap, + bd_index, 0); + hash_unset (bdm->bd_index_by_id, bd_id); + bd_local_cfg->bd_id = ~0; + vec_validate_init_c_string (bd_local_cfg->bd_name, "", 0); + + if (clib_bitmap_is_zero (bdm->bd_index_bitmap)) + { + vec_reset_length (bdm->local_cfg); + vec_reset_length (bdm->bd_oper); + } + + /* Force a resync of all bd_oper data. */ + bdm->bd_oper_last_sync_all_time = 0.0; + vjbd_oper_maybe_sync_from_vpp (bdm, ~0); +} + +#endif /* __included_vppjni_vpp_bridge_domain_h__ */ diff --git a/vpp-api/java/japi/vppjni_env.c b/vpp-api/java/japi/vppjni_env.c new file mode 100644 index 00000000000..1c4ea6ebe18 --- /dev/null +++ b/vpp-api/java/japi/vppjni_env.c @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <jni.h> + +#include "vppjni_env.h" + +// Head of the class registration list. +static vppjni_class_t *class_head; +// Head of the class registration list. +static vppjni_field_t *field_head; + +void vppjni_register_class(vppjni_class_t *ptr) +{ + vppjni_class_t **where = &class_head; + while (*where != NULL) { + where = &((*where)->next); + } + *where = ptr; +} + +void vppjni_register_field(vppjni_field_t *ptr) { + vppjni_field_t **where = &field_head; + while (*where != NULL) { + where = &((*where)->next); + } + *where = ptr; +} + +jobject vppjni_new_object(JNIEnv *env, const vppjni_class_t *ptr, va_list ap) { + jobject obj = (*env)->NewObjectV(env, ptr->jclass, ptr->jinit, ap); + if ((*env)->ExceptionCheck(env)) { + (*env)->ExceptionDescribe(env); + return NULL; + } + + return obj; +} + +int vppjni_init(JNIEnv *env) +{ + vppjni_class_t *cwlk; + vppjni_field_t *fwlk; + + for (cwlk = class_head; cwlk != NULL; cwlk = cwlk->next) { + jclass cls; + jmethodID method; + + cls = (*env)->FindClass(env, cwlk->fqcn); + if ((*env)->ExceptionCheck(env)) { + (*env)->ExceptionDescribe(env); + vppjni_uninit(env); + return JNI_ERR; + } + + method = (*env)->GetMethodID(env, cls, "<init>", cwlk->init_sig); + if ((*env)->ExceptionCheck(env)) { + (*env)->ExceptionDescribe(env); + vppjni_uninit(env); + return JNI_ERR; + } + + cwlk->jclass = (*env)->NewGlobalRef(env, cls); + if (cwlk->jclass == NULL) { + vppjni_uninit(env); + return JNI_ERR; + } + cwlk->jinit = method; + } + + for (fwlk = field_head; fwlk != NULL; fwlk = fwlk->next) { + fwlk->jfield = (*env)->GetFieldID(env, fwlk->clsref->jclass, fwlk->name, fwlk->type); + if ((*env)->ExceptionCheck(env)) { + (*env)->ExceptionDescribe(env); + vppjni_uninit(env); + return JNI_ERR; + } + } + + return 0; +} + +void vppjni_uninit(JNIEnv *env) { + vppjni_class_t *cwlk; + vppjni_field_t *fwlk; + + for (fwlk = field_head; fwlk != NULL; fwlk = fwlk->next) { + fwlk->jfield = NULL; + } + + for (cwlk = class_head; cwlk != NULL; cwlk = cwlk->next) { + if (cwlk->jclass != NULL ) { + (*env)->DeleteGlobalRef(env, cwlk->jclass); + } + + cwlk->jclass = NULL; + cwlk->jinit = NULL; + } +} + diff --git a/vpp-api/java/japi/vppjni_env.h b/vpp-api/java/japi/vppjni_env.h new file mode 100644 index 00000000000..44029c2c964 --- /dev/null +++ b/vpp-api/java/japi/vppjni_env.h @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Utilities for accessing Java classes/method/fields in an efficient + * manner. + */ + +/* + * A potentially-uninitialized reference to a Java class + */ +typedef struct vppjni_class { + // Fully-Qualified Class Name + const char *fqcn; + // Constructor signature + const char *init_sig; + // Global reference to class handle + jclass jclass; + // Constructor method handle + jmethodID jinit; + // Next item in linked list + struct vppjni_class *next; +} vppjni_class_t; + +typedef struct jenv_field { + // Field name + const char *name; + // Field type + const char *type; + // Defining class reference + const vppjni_class_t *clsref; + // Field handle + jfieldID jfield; + // Next item in linked list + struct jenv_field *next; +} vppjni_field_t; + +#define VPPJNI_CLASS_SYMBOL(name) vppjni_class_##name +#define VPPJNI_CLASS_INIT(name) vppjni_class_##name##_init +#define BIND_JAPI_CLASS(name, sig) \ + static vppjni_class_t VPPJNI_CLASS_SYMBOL(name); \ + static void VPPJNI_CLASS_INIT(name)(void) __attribute__((__constructor__)); \ + static void VPPJNI_CLASS_INIT(name)() \ + { \ + VPPJNI_CLASS_SYMBOL(name).fqcn = "org/openvpp/vppjapi/" #name; \ + VPPJNI_CLASS_SYMBOL(name).init_sig = sig; \ + vppjni_register_class(&VPPJNI_CLASS_SYMBOL(name)); \ + } \ + static __attribute__((unused)) jobject name##Array(JNIEnv *env, jsize length) \ + { \ + return (*env)->NewObjectArray(env, length, VPPJNI_CLASS_SYMBOL(name).jclass, NULL); \ + } \ + static jobject name##Object(JNIEnv *env, ...) \ + { \ + va_list ap; \ + va_start(ap, env); \ + jobject obj = vppjni_new_object(env, &VPPJNI_CLASS_SYMBOL(name), ap); \ + va_end(ap); \ + return obj; \ + } + +#define VPPJNI_FIELD_SYMBOL(cls, name) vppjni_field_##cls##_##name +#define VPPJNI_FIELD_INIT(cls, name) vppjni_field_##cls##_##name##_init +#define BIND_JAPI_FIELD(cls, field, sig) \ + static vppjni_field_t VPPJNI_FIELD_SYMBOL(cls, field); \ + static void VPPJNI_FIELD_INIT(cls, field)(void) __attribute__((__constructor__)); \ + static void VPPJNI_FIELD_INIT(cls, field)() \ + { \ + VPPJNI_FIELD_SYMBOL(cls, field).name = #field; \ + VPPJNI_FIELD_SYMBOL(cls, field).type = sig; \ + VPPJNI_FIELD_SYMBOL(cls, field).clsref = &VPPJNI_CLASS_SYMBOL(cls); \ + vppjni_register_field(&VPPJNI_FIELD_SYMBOL(cls, field)); \ + } +#define BIND_JAPI_BOOL_FIELD(cls, field) \ + BIND_JAPI_FIELD(cls, field, "Z"); \ + static void set_##cls##_##field(JNIEnv *env, jobject obj, jboolean value) \ + { \ + (*env)->SetBooleanField(env, obj, VPPJNI_FIELD_SYMBOL(cls, field).jfield, value); \ + } +#define BIND_JAPI_BYTE_FIELD(cls, field) \ + BIND_JAPI_FIELD(cls, field, "B"); \ + static void set_##cls##_##field(JNIEnv *env, jobject obj, jbyte value) \ + { \ + (*env)->SetByteField(env, obj, VPPJNI_FIELD_SYMBOL(cls, field).jfield, value); \ + } +#define BIND_JAPI_INT_FIELD(cls, field) \ + BIND_JAPI_FIELD(cls, field, "I"); \ + static void set_##cls##_##field(JNIEnv *env, jobject obj, jint value) \ + { \ + (*env)->SetIntField(env, obj, VPPJNI_FIELD_SYMBOL(cls, field).jfield, value); \ + } +#define BIND_JAPI_OBJ_FIELD(cls, field, sig) \ + BIND_JAPI_FIELD(cls, field, sig); \ + static void set_##cls##_##field(JNIEnv *env, jobject obj, jobject value) \ + { \ + (*env)->SetObjectField(env, obj, VPPJNI_FIELD_SYMBOL(cls, field).jfield, value); \ + } +#define BIND_JAPI_STRING_FIELD(cls, field) \ + BIND_JAPI_OBJ_FIELD(cls, field, "Ljava/lang/String;") + +jobject vppjni_new_object(JNIEnv *env, const vppjni_class_t *ptr, va_list ap) __attribute__ ((visibility ("hidden"))); +void vppjni_register_class(vppjni_class_t *ptr) __attribute__ ((visibility ("hidden"))); +void vppjni_register_field(vppjni_field_t *ptr) __attribute__ ((visibility ("hidden"))); +int vppjni_init(JNIEnv *env) __attribute__ ((visibility ("hidden"))); +void vppjni_uninit(JNIEnv *env) __attribute__ ((visibility ("hidden"))); + diff --git a/vpp-api/java/m4/ax_check_java_home.m4 b/vpp-api/java/m4/ax_check_java_home.m4 new file mode 100644 index 00000000000..cfe8f58928d --- /dev/null +++ b/vpp-api/java/m4/ax_check_java_home.m4 @@ -0,0 +1,80 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_check_java_home.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CHECK_JAVA_HOME +# +# DESCRIPTION +# +# Check for Sun Java (JDK / JRE) installation, where the 'java' VM is in. +# If found, set environment variable JAVA_HOME = Java installation home, +# else left JAVA_HOME untouch, which in most case means JAVA_HOME is +# empty. +# +# LICENSE +# +# Copyright (c) 2008 Gleen Salmon <gleensalmon@yahoo.com> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 6 + +AU_ALIAS([AC_CHECK_JAVA_HOME], [AX_CHECK_JAVA_HOME]) + +AC_DEFUN([AX_CHECK_JAVA_HOME], +[AC_MSG_CHECKING([for JAVA_HOME]) +# We used a fake loop so that we can use "break" to exit when the result +# is found. +while true +do + # If the user defined JAVA_HOME, don't touch it. + test "${JAVA_HOME+set}" = set && break + + # On Mac OS X 10.5 and following, run /usr/libexec/java_home to get + # the value of JAVA_HOME to use. + # (http://developer.apple.com/library/mac/#qa/qa2001/qa1170.html). + JAVA_HOME=`/usr/libexec/java_home 2>/dev/null` + test x"$JAVA_HOME" != x && break + + # See if we can find the java executable, and compute from there. + TRY_JAVA_HOME=`ls -dr /usr/java/* 2> /dev/null | head -n 1` + if test x$TRY_JAVA_HOME != x; then + PATH=$PATH:$TRY_JAVA_HOME/bin + fi + AC_PATH_PROG([JAVA_PATH_NAME], [java]) + if test "x$JAVA_PATH_NAME" != x; then + JAVA_HOME=`echo $JAVA_PATH_NAME | sed "s/\(.*\)[[/]]bin[[/]]java.*/\1/"` + break + fi + + AC_MSG_NOTICE([Could not compute JAVA_HOME]) + break +done +AC_MSG_RESULT([$JAVA_HOME]) +]) diff --git a/vpp-api/java/m4/ax_check_java_plugin.m4 b/vpp-api/java/m4/ax_check_java_plugin.m4 new file mode 100644 index 00000000000..920753e5724 --- /dev/null +++ b/vpp-api/java/m4/ax_check_java_plugin.m4 @@ -0,0 +1,101 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_check_java_plugin.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CHECK_JAVA_PLUGIN(<shell-variable>) +# +# DESCRIPTION +# +# This macro sets <shell-variable> to empty on failure and to a compatible +# version of plugin.jar otherwise. Directories searched are /usr/java/* +# and /usr/local/java/*, which are assumed to be j{dk,re} installations. +# Apply the shell variable as you see fit. If sun changes things so +# <jre>/lib/plugin.jar is not the magic file it will stop working. +# +# This macro assumes that unzip, zipinfo or pkzipc is available (and can +# list the contents of the jar archive). The first two are assumed to work +# similarly enough to the infozip versisonms. The pkzipc version is +# assumed to work if I undertstand the documentation on pkware's site but +# YMMV. I do not have access to pwkware's version to test it. +# +# LICENSE +# +# Copyright (c) 2008 Duncan Simpson <dps@simpson.demon.co.uk> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 7 + +AU_ALIAS([DPS_CHECK_PLUGIN], [AX_CHECK_JAVA_PLUGIN]) +AC_DEFUN([AX_CHECK_JAVA_PLUGIN], +[AC_REQUIRE([AC_PROG_AWK]) +AC_REQUIRE([AC_PROG_FGREP]) +AC_CHECK_PROG(ZIPINFO,[zipinfo unzip pkzipc]) +AC_MSG_CHECKING([for the java plugin]) +case "x$ZIPINFO" in +[*/zipinfo)] + zipinf="zipinfo -1" ;; +[*/unzip)] + zipinf="unzip -l";; +[*/pkzipc)] + ziping="unzipc -view";; +[x*)] + AC_MSG_RESULT([skiped, none of zipinfo, unzip and pkzipc found]) + AC_SUBST($1,[]) + zipinf="";; +esac +if test "x$zipinf" != "x"; then +jplugin="" +for jhome in `ls -dr /usr/java/* /usr/local/java/* 2> /dev/null`; do +for jfile in lib/plugin.jar jre/lib/plugin.jar; do +if test "x$jplugin" = "x" && test -f "$jhome/$jfile"; then +eval "$zipinf $jhome/$jfile | $AWK '{ print \$NF; }' | $FGREP netscape/javascript/JSObject" >/dev/null 2>/dev/null +if test $? -eq 0; then +dnl Some version of gcj (and javac) refuse to work with some files +dnl that pass this test. To stop this problem make sure that the compiler +dnl still works with this jar file in the classpath +cat << \EOF > Test.java +/* [#]line __oline__ "configure" */ +public class Test { +} +EOF +if eval "$JAVAC -classpath $jhome/$jfile Test.java 2>/dev/null >/dev/null" && test -f Test.class; then +jplugin="$jhome/$jfile" +fi +rm -f Test.java Test.class +fi; fi; done; done +if test "x$jplugin" != "x"; then +AC_SUBST($1,$jplugin) +AC_MSG_RESULT($jplugin) +else +AC_MSG_RESULT([java plugin not found]) +AC_SUBST($1,[]) +fi +fi +]) diff --git a/vpp-api/java/m4/ax_java_check_class.m4 b/vpp-api/java/m4/ax_java_check_class.m4 new file mode 100644 index 00000000000..917638ae4b9 --- /dev/null +++ b/vpp-api/java/m4/ax_java_check_class.m4 @@ -0,0 +1,85 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_java_check_class.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_JAVA_CHECK_CLASS(<class>,<action-if-found>,<action-if-not-found>) +# +# DESCRIPTION +# +# Test if a Java class is available. Based on AX_PROG_JAVAC_WORKS. This +# version uses a cache variable which is both compiler, options and +# classpath dependent (so if you switch from javac to gcj it correctly +# notices and redoes the test). +# +# The macro tries to compile a minimal program importing <class>. Some +# newer compilers moan about the failure to use this but fail or produce a +# class file anyway. All moaing is sunk to /dev/null since I only wanted +# to know if the class could be imported. This is a recommended followup +# to AX_CHECK_JAVA_PLUGIN with classpath appropriately adjusted. +# +# LICENSE +# +# Copyright (c) 2008 Duncan Simpson <dps@simpson.demon.co.uk> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 9 + +AU_ALIAS([DPS_JAVA_CHECK_CLASS], [AX_JAVA_CHECK_CLASS]) +AC_DEFUN([AX_JAVA_CHECK_CLASS],[ +m4_define([cache_val],[m4_translit(ax_cv_have_java_class_$1, " ." ,"__")]) +if test "x$CLASSPATH" != "x"; then +xtra=" with classpath ${CLASSPATH}" +xopts=`echo ${CLASSPATH} | ${SED} 's/^ *://'` +xopts="-classpath $xopts" +else xtra=""; xopts=""; fi +cache_var="cache_val"AS_TR_SH([_Jc_${JAVAC}_Cp_${CLASSPATH}]) +AC_CACHE_CHECK([if the $1 class is available$xtra], [$cache_var], [ +JAVA_TEST=Test.java +CLASS_TEST=Test.class +cat << \EOF > $JAVA_TEST +/* [#]xline __oline__ "configure" */ +import $1; +public class Test { +} +EOF +if AC_TRY_COMMAND($JAVAC $JAVACFLAGS $xopts $JAVA_TEST) >/dev/null 2>&1; then + eval "${cache_var}=yes" +else + eval "${cache_var}=no" + echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD + cat $JAVA_TEST >&AS_MESSAGE_LOG_FD +fi +rm -f $JAVA_TEST $CLASS_TEST +]) +if eval 'test "x$'${cache_var}'" = "xyes"'; then +$2 +true; else +$3 +false; fi]) diff --git a/vpp-api/java/m4/ax_java_options.m4 b/vpp-api/java/m4/ax_java_options.m4 new file mode 100644 index 00000000000..36c10d922bd --- /dev/null +++ b/vpp-api/java/m4/ax_java_options.m4 @@ -0,0 +1,48 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_java_options.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_JAVA_OPTIONS +# +# DESCRIPTION +# +# AX_JAVA_OPTIONS adds configure command line options used for Java m4 +# macros. This Macro is optional. +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. The +# general documentation, as well as the sample configure.in, is included +# in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Devin Weaver <ktohg@tritarget.com> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 6 + +AU_ALIAS([AC_JAVA_OPTIONS], [AX_JAVA_OPTIONS]) +AC_DEFUN([AX_JAVA_OPTIONS],[ +AC_ARG_WITH(java-prefix, + [ --with-java-prefix=PFX prefix where Java runtime is installed (optional)]) +AC_ARG_WITH(javac-flags, + [ --with-javac-flags=FLAGS flags to pass to the Java compiler (optional)]) +AC_ARG_WITH(java-flags, + [ --with-java-flags=FLAGS flags to pass to the Java VM (optional)]) +JAVAPREFIX=$with_java_prefix +JAVACFLAGS=$with_javac_flags +JAVAFLAGS=$with_java_flags +AC_SUBST(JAVAPREFIX)dnl +AC_SUBST(JAVACFLAGS)dnl +AC_SUBST(JAVAFLAGS)dnl +AC_SUBST(JAVA)dnl +AC_SUBST(JAVAC)dnl +]) diff --git a/vpp-api/java/m4/ax_libgcj_jar.m4 b/vpp-api/java/m4/ax_libgcj_jar.m4 new file mode 100644 index 00000000000..5e942857265 --- /dev/null +++ b/vpp-api/java/m4/ax_libgcj_jar.m4 @@ -0,0 +1,83 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_libgcj_jar.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_LIBGCJ_JAR +# +# DESCRIPTION +# +# Locate libgcj.jar so you can place it before everything else when using +# gcj. +# +# LICENSE +# +# Copyright (c) 2008 Duncan Simpson <dps@simpson.demon.co.uk> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 9 + +AU_ALIAS([DPS_LIBGCJ_JAR], [AX_LIBGCJ_JAR]) +AC_DEFUN([AX_LIBGCJ_JAR], +[ +AC_REQUIRE([AC_EXEEXT]) +AC_REQUIRE([AX_PROG_JAVAC]) +AC_REQUIRE([AC_PROG_FGREP]) +AC_PROG_SED +if test "x$SED" = "x"; then +AC_MSG_WARN([sed not avaiable, so libgcj.jar test skipped]) +else +AC_MSG_CHECKING([if $JAVAC is gcj]); +jc=`eval "[echo x$JAVAC | $SED 's/^x.*\\/\\([^/]*\\)\$/x\\1/;s/^ *\\([^ ]*\\) .*$/\\1/;s/"$EXEEXT"$//']"` +if test "x$jc" != "xxgcj"; then +AC_MSG_RESULT(no) +else +AC_MSG_RESULT(yes) +AC_MSG_CHECKING([libgcj.jar location]) +save_cp="$CLASSPATH"; +unset CLASSPATH; +AC_MSG_CHECKING([gcj default classpath]) +cat << \EOF > Test.java +/* [#]line __oline__ "configure" */ +public class Test { +} +EOF +lgcj=`eval "[$JAVAC -v -C Test.java 2>&1 | $FGREP \\(system\\) | $SED 's/^ *\\([^ ]*\\) .*$/\\1/;s/\\.jar\\//.jar/']"`; +if test -f Test.class && test "x$lgcj" != "x"; then +AC_MSG_RESULT($lgcj) +$1="$lgcj:" +else +AC_MSG_RESULT(failed) +$1="" +fi +if test "x$save_cp" != "x"; then CLASSPATH="$save_cp"; fi +rm -f Test.java Test.class +fi +fi +]) diff --git a/vpp-api/java/m4/ax_prog_jar.m4 b/vpp-api/java/m4/ax_prog_jar.m4 new file mode 100644 index 00000000000..3c60fcaf2d4 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_jar.m4 @@ -0,0 +1,49 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_jar.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAR +# +# DESCRIPTION +# +# AX_PROG_JAR tests for an existing jar program. It uses the environment +# variable JAR then tests in sequence various common jar programs. +# +# If you want to force a specific compiler: +# +# - at the configure.in level, set JAR=yourcompiler before calling +# AX_PROG_JAR +# +# - at the configure level, setenv JAR +# +# You can use the JAR variable in your Makefile.in, with @JAR@. +# +# Note: This macro depends on the autoconf M4 macros for Java programs. It +# is VERY IMPORTANT that you download that whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. +# +# The general documentation of those macros, as well as the sample +# configure.in, is included in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Egon Willighagen <e.willighagen@science.ru.nl> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 7 + +AU_ALIAS([AC_PROG_JAR], [AX_PROG_JAR]) +AC_DEFUN([AX_PROG_JAR],[ +AS_IF([test "x$JAVAPREFIX" = x], + [test "x$JAR" = x && AC_CHECK_PROGS([JAR], [jar])], + [test "x$JAR" = x && AC_CHECK_PROGS([JAR], [jar], [], [$JAVAPREFIX/bin])]) +test "x$JAR" = x && AC_MSG_ERROR([no acceptable jar program found in \$PATH]) +AC_PROVIDE([$0])dnl +]) diff --git a/vpp-api/java/m4/ax_prog_java.m4 b/vpp-api/java/m4/ax_prog_java.m4 new file mode 100644 index 00000000000..03961db5b73 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_java.m4 @@ -0,0 +1,115 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_java.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVA +# +# DESCRIPTION +# +# Here is a summary of the main macros: +# +# AX_PROG_JAVAC: finds a Java compiler. +# +# AX_PROG_JAVA: finds a Java virtual machine. +# +# AX_CHECK_CLASS: finds if we have the given class (beware of CLASSPATH!). +# +# AX_CHECK_RQRD_CLASS: finds if we have the given class and stops +# otherwise. +# +# AX_TRY_COMPILE_JAVA: attempt to compile user given source. +# +# AX_TRY_RUN_JAVA: attempt to compile and run user given source. +# +# AX_JAVA_OPTIONS: adds Java configure options. +# +# AX_PROG_JAVA tests an existing Java virtual machine. It uses the +# environment variable JAVA then tests in sequence various common Java +# virtual machines. For political reasons, it starts with the free ones. +# You *must* call [AX_PROG_JAVAC] before. +# +# If you want to force a specific VM: +# +# - at the configure.in level, set JAVA=yourvm before calling AX_PROG_JAVA +# +# (but after AC_INIT) +# +# - at the configure level, setenv JAVA +# +# You can use the JAVA variable in your Makefile.in, with @JAVA@. +# +# *Warning*: its success or failure can depend on a proper setting of the +# CLASSPATH env. variable. +# +# TODO: allow to exclude virtual machines (rationale: most Java programs +# cannot run with some VM like kaffe). +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. +# +# A Web page, with a link to the latest CVS snapshot is at +# <http://www.internatif.org/bortzmeyer/autoconf-Java/>. +# +# This is a sample configure.in Process this file with autoconf to produce +# a configure script. +# +# AC_INIT(UnTag.java) +# +# dnl Checks for programs. +# AC_CHECK_CLASSPATH +# AX_PROG_JAVAC +# AX_PROG_JAVA +# +# dnl Checks for classes +# AX_CHECK_RQRD_CLASS(org.xml.sax.Parser) +# AX_CHECK_RQRD_CLASS(com.jclark.xml.sax.Driver) +# +# AC_OUTPUT(Makefile) +# +# LICENSE +# +# Copyright (c) 2008 Stephane Bortzmeyer <bortzmeyer@pasteur.fr> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 9 + +AU_ALIAS([AC_PROG_JAVA], [AX_PROG_JAVA]) +AC_DEFUN([AX_PROG_JAVA],[ +m4_define([m4_ax_prog_java_list], [kaffe java])dnl +AS_IF([test "x$JAVAPREFIX" = x], + [test x$JAVA = x && AC_CHECK_PROGS([JAVA], [m4_ax_prog_java_list])], + [test x$JAVA = x && AC_CHECK_PROGS([JAVA], [m4_ax_prog_java_list], [], [$JAVAPREFIX/bin])]) +test x$JAVA = x && AC_MSG_ERROR([no acceptable Java virtual machine found in \$PATH]) +m4_undefine([m4_ax_prog_java_list])dnl +AX_PROG_JAVA_WORKS +AC_PROVIDE([$0])dnl +]) diff --git a/vpp-api/java/m4/ax_prog_java_cc.m4 b/vpp-api/java/m4/ax_prog_java_cc.m4 new file mode 100644 index 00000000000..3df064ff663 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_java_cc.m4 @@ -0,0 +1,104 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_java_cc.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVA_CC +# +# DESCRIPTION +# +# Finds the appropriate java compiler on your path. By preference the java +# compiler is gcj, then jikes then javac. +# +# The macro can take one argument specifying a space separated list of +# java compiler names. +# +# For example: +# +# AX_PROG_JAVA_CC(javac, gcj) +# +# The macro also sets the compiler options variable: JAVA_CC_OPTS to +# something sensible: +# +# - for GCJ it sets it to: @GCJ_OPTS@ +# (if GCJ_OPTS is not yet defined then it is set to "-C") +# +# - no other compiler has applicable options yet +# +# Here's an example configure.in: +# +# AC_INIT(Makefile.in) +# AX_PROG_JAVA_CC() +# AC_OUTPUT(Makefile) +# dnl End. +# +# And here's the start of the Makefile.in: +# +# PROJECT_ROOT := @srcdir@ +# # Tool definitions. +# JAVAC := @JAVA_CC@ +# JAVAC_OPTS := @JAVA_CC_OPTS@ +# JAR_TOOL := @jar_tool@ +# +# LICENSE +# +# Copyright (c) 2008 Nic Ferrier <nferrier@tapsellferrier.co.uk> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 4 + +# AX_PROG_JAVA_CC([COMPILER ...]) +# -------------------------- +# COMPILER ... is a space separated list of java compilers to search for. +# This just gives the user an opportunity to specify an alternative +# search list for the java compiler. +AU_ALIAS([AC_PROG_JAVA_CC], [AX_PROG_JAVA_CC]) +AC_DEFUN([AX_PROG_JAVA_CC], +[AC_ARG_VAR([JAVA_CC], [java compiler command])dnl +AC_ARG_VAR([JAVA_CC_FLAGS], [java compiler flags])dnl +m4_ifval([$1], + [AC_CHECK_TOOLS(JAVA_CC, [$1])], +[AC_CHECK_TOOL(JAVA_CC, gcj) +if test -z "$JAVA_CC"; then + AC_CHECK_TOOL(JAVA_CC, javac) +fi +if test -z "$JAVA_CC"; then + AC_CHECK_TOOL(JAVA_CC, jikes) +fi +]) + +if test "$JAVA_CC" = "gcj"; then + if test "$GCJ_OPTS" = ""; then + AC_SUBST(GCJ_OPTS,-C) + fi + AC_SUBST(JAVA_CC_OPTS, @GCJ_OPTS@, + [Define the compilation options for GCJ]) +fi +test -z "$JAVA_CC" && AC_MSG_ERROR([no acceptable java compiler found in \$PATH]) +])# AX_PROG_JAVA_CC diff --git a/vpp-api/java/m4/ax_prog_java_works.m4 b/vpp-api/java/m4/ax_prog_java_works.m4 new file mode 100644 index 00000000000..54e132afae6 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_java_works.m4 @@ -0,0 +1,134 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_java_works.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVA_WORKS +# +# DESCRIPTION +# +# Internal use ONLY. +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. The +# general documentation, as well as the sample configure.in, is included +# in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Stephane Bortzmeyer <bortzmeyer@pasteur.fr> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 9 + +AU_ALIAS([AC_PROG_JAVA_WORKS], [AX_PROG_JAVA_WORKS]) +AC_DEFUN([AX_PROG_JAVA_WORKS], [ +AC_PATH_PROG(UUDECODE, uudecode, [no]) +if test x$UUDECODE != xno; then +AC_CACHE_CHECK([if uudecode can decode base 64 file], ac_cv_prog_uudecode_base64, [ +dnl /** +dnl * Test.java: used to test if java compiler works. +dnl */ +dnl public class Test +dnl { +dnl +dnl public static void +dnl main( String[] argv ) +dnl { +dnl System.exit (0); +dnl } +dnl +dnl } +cat << \EOF > Test.uue +begin-base64 644 Test.class +yv66vgADAC0AFQcAAgEABFRlc3QHAAQBABBqYXZhL2xhbmcvT2JqZWN0AQAE +bWFpbgEAFihbTGphdmEvbGFuZy9TdHJpbmc7KVYBAARDb2RlAQAPTGluZU51 +bWJlclRhYmxlDAAKAAsBAARleGl0AQAEKEkpVgoADQAJBwAOAQAQamF2YS9s +YW5nL1N5c3RlbQEABjxpbml0PgEAAygpVgwADwAQCgADABEBAApTb3VyY2VG +aWxlAQAJVGVzdC5qYXZhACEAAQADAAAAAAACAAkABQAGAAEABwAAACEAAQAB +AAAABQO4AAyxAAAAAQAIAAAACgACAAAACgAEAAsAAQAPABAAAQAHAAAAIQAB +AAEAAAAFKrcAErEAAAABAAgAAAAKAAIAAAAEAAQABAABABMAAAACABQ= +==== +EOF +if $UUDECODE Test.uue; then + ac_cv_prog_uudecode_base64=yes +else + echo "configure: __oline__: uudecode had trouble decoding base 64 file 'Test.uue'" >&AS_MESSAGE_LOG_FD + echo "configure: failed file was:" >&AS_MESSAGE_LOG_FD + cat Test.uue >&AS_MESSAGE_LOG_FD + ac_cv_prog_uudecode_base64=no +fi +rm -f Test.uue]) +fi +if test x$ac_cv_prog_uudecode_base64 != xyes; then + rm -f Test.class + AC_MSG_WARN([I have to compile Test.class from scratch]) + if test x$ac_cv_prog_javac_works = xno; then + AC_MSG_ERROR([Cannot compile java source. $JAVAC does not work properly]) + fi + if test x$ac_cv_prog_javac_works = x; then + AX_PROG_JAVAC + fi +fi +AC_CACHE_CHECK(if $JAVA works, ac_cv_prog_java_works, [ +JAVA_TEST=Test.java +CLASS_TEST=Test.class +TEST=Test +changequote(, )dnl +cat << \EOF > $JAVA_TEST +/* [#]line __oline__ "configure" */ +public class Test { +public static void main (String args[]) { + System.exit (0); +} } +EOF +changequote([, ])dnl +if test x$ac_cv_prog_uudecode_base64 != xyes; then + if AC_TRY_COMMAND($JAVAC $JAVACFLAGS $JAVA_TEST) && test -s $CLASS_TEST; then + : + else + echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD + cat $JAVA_TEST >&AS_MESSAGE_LOG_FD + AC_MSG_ERROR(The Java compiler $JAVAC failed (see config.log, check the CLASSPATH?)) + fi +fi +if AC_TRY_COMMAND($JAVA -classpath . $JAVAFLAGS $TEST) >/dev/null 2>&1; then + ac_cv_prog_java_works=yes +else + echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD + cat $JAVA_TEST >&AS_MESSAGE_LOG_FD + AC_MSG_ERROR(The Java VM $JAVA failed (see config.log, check the CLASSPATH?)) +fi +rm -fr $JAVA_TEST $CLASS_TEST Test.uue +]) +AC_PROVIDE([$0])dnl +] +) diff --git a/vpp-api/java/m4/ax_prog_javac.m4 b/vpp-api/java/m4/ax_prog_javac.m4 new file mode 100644 index 00000000000..d061243cdb0 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_javac.m4 @@ -0,0 +1,79 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_javac.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVAC +# +# DESCRIPTION +# +# AX_PROG_JAVAC tests an existing Java compiler. It uses the environment +# variable JAVAC then tests in sequence various common Java compilers. For +# political reasons, it starts with the free ones. +# +# If you want to force a specific compiler: +# +# - at the configure.in level, set JAVAC=yourcompiler before calling +# AX_PROG_JAVAC +# +# - at the configure level, setenv JAVAC +# +# You can use the JAVAC variable in your Makefile.in, with @JAVAC@. +# +# *Warning*: its success or failure can depend on a proper setting of the +# CLASSPATH env. variable. +# +# TODO: allow to exclude compilers (rationale: most Java programs cannot +# compile with some compilers like guavac). +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. The +# general documentation, as well as the sample configure.in, is included +# in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Stephane Bortzmeyer <bortzmeyer@pasteur.fr> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 7 + +AU_ALIAS([AC_PROG_JAVAC], [AX_PROG_JAVAC]) +AC_DEFUN([AX_PROG_JAVAC],[ +m4_define([m4_ax_prog_javac_list],["gcj -C" guavac jikes javac])dnl +AS_IF([test "x$JAVAPREFIX" = x], + [test "x$JAVAC" = x && AC_CHECK_PROGS([JAVAC], [m4_ax_prog_javac_list])], + [test "x$JAVAC" = x && AC_CHECK_PROGS([JAVAC], [m4_ax_prog_javac_list], [], [$JAVAPREFIX/bin])]) +m4_undefine([m4_ax_prog_javac_list])dnl +test "x$JAVAC" = x && AC_MSG_ERROR([no acceptable Java compiler found in \$PATH]) +AX_PROG_JAVAC_WORKS +AC_PROVIDE([$0])dnl +]) diff --git a/vpp-api/java/m4/ax_prog_javac_works.m4 b/vpp-api/java/m4/ax_prog_javac_works.m4 new file mode 100644 index 00000000000..7dfa1e37d89 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_javac_works.m4 @@ -0,0 +1,72 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_javac_works.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVAC_WORKS +# +# DESCRIPTION +# +# Internal use ONLY. +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. The +# general documentation, as well as the sample configure.in, is included +# in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Stephane Bortzmeyer <bortzmeyer@pasteur.fr> +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General +# Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program. If not, see <http://www.gnu.org/licenses/>. +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 6 + +AU_ALIAS([AC_PROG_JAVAC_WORKS], [AX_PROG_JAVAC_WORKS]) +AC_DEFUN([AX_PROG_JAVAC_WORKS],[ +AC_CACHE_CHECK([if $JAVAC works], ac_cv_prog_javac_works, [ +JAVA_TEST=Test.java +CLASS_TEST=Test.class +cat << \EOF > $JAVA_TEST +/* [#]line __oline__ "configure" */ +public class Test { +} +EOF +if AC_TRY_COMMAND($JAVAC $JAVACFLAGS $JAVA_TEST) >/dev/null 2>&1; then + ac_cv_prog_javac_works=yes +else + AC_MSG_ERROR([The Java compiler $JAVAC failed (see config.log, check the CLASSPATH?)]) + echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD + cat $JAVA_TEST >&AS_MESSAGE_LOG_FD +fi +rm -f $JAVA_TEST $CLASS_TEST +]) +AC_PROVIDE([$0])dnl +]) diff --git a/vpp-api/java/m4/ax_prog_javadoc.m4 b/vpp-api/java/m4/ax_prog_javadoc.m4 new file mode 100644 index 00000000000..bcb6045a828 --- /dev/null +++ b/vpp-api/java/m4/ax_prog_javadoc.m4 @@ -0,0 +1,50 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_javadoc.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVADOC +# +# DESCRIPTION +# +# AX_PROG_JAVADOC tests for an existing javadoc generator. It uses the +# environment variable JAVADOC then tests in sequence various common +# javadoc generator. +# +# If you want to force a specific compiler: +# +# - at the configure.in level, set JAVADOC=yourgenerator before calling +# AX_PROG_JAVADOC +# +# - at the configure level, setenv JAVADOC +# +# You can use the JAVADOC variable in your Makefile.in, with @JAVADOC@. +# +# Note: This macro depends on the autoconf M4 macros for Java programs. It +# is VERY IMPORTANT that you download that whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. +# +# The general documentation of those macros, as well as the sample +# configure.in, is included in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Egon Willighagen <e.willighagen@science.ru.nl> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 8 + +AU_ALIAS([AC_PROG_JAVADOC], [AX_PROG_JAVADOC]) +AC_DEFUN([AX_PROG_JAVADOC],[ +AS_IF([test "x$JAVAPREFIX" = x], + [test "x$JAVADOC" = x && AC_CHECK_PROGS([JAVADOC], [javadoc])], + [test "x$JAVADOC" = x && AC_CHECK_PROGS([JAVADOC], [javadoc], [], [$JAVAPREFIX/bin])]) +test "x$JAVADOC" = x && AC_MSG_ERROR([no acceptable javadoc generator found in \$PATH]) +AC_PROVIDE([$0])dnl +]) diff --git a/vpp-api/java/m4/ax_prog_javah.m4 b/vpp-api/java/m4/ax_prog_javah.m4 new file mode 100644 index 00000000000..cefc616d4ca --- /dev/null +++ b/vpp-api/java/m4/ax_prog_javah.m4 @@ -0,0 +1,64 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_prog_javah.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PROG_JAVAH +# +# DESCRIPTION +# +# AX_PROG_JAVAH tests the availability of the javah header generator and +# looks for the jni.h header file. If available, JAVAH is set to the full +# path of javah and CPPFLAGS is updated accordingly. +# +# LICENSE +# +# Copyright (c) 2008 Luc Maisonobe <luc@spaceroots.org> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 8 + +AU_ALIAS([AC_PROG_JAVAH], [AX_PROG_JAVAH]) +AC_DEFUN([AX_PROG_JAVAH],[ +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([AC_PROG_CPP])dnl +AC_PATH_PROG(JAVAH,javah) +AS_IF([test -n "$ac_cv_path_JAVAH"], + [ + AC_TRY_CPP([#include <jni.h>],,[ + ac_save_CPPFLAGS="$CPPFLAGS" + _ACJAVAH_FOLLOW_SYMLINKS("$ac_cv_path_JAVAH") + ax_prog_javah_bin_dir=`AS_DIRNAME([$_ACJAVAH_FOLLOWED])` + ac_dir="`AS_DIRNAME([$ax_prog_javah_bin_dir])`/include" + AS_CASE([$build_os], + [cygwin*], + [ac_machdep=win32], + [ac_machdep=`AS_ECHO($build_os) | sed 's,[[-0-9]].*,,'`]) + CPPFLAGS="$ac_save_CPPFLAGS -I$ac_dir -I$ac_dir/$ac_machdep" + AC_TRY_CPP([#include <jni.h>], + ac_save_CPPFLAGS="$CPPFLAGS", + AC_MSG_WARN([unable to include <jni.h>])) + CPPFLAGS="$ac_save_CPPFLAGS"]) + ]) +]) + +AC_DEFUN([_ACJAVAH_FOLLOW_SYMLINKS],[ +# find the include directory relative to the javac executable +_cur="$1" +while ls -ld "$_cur" 2>/dev/null | grep " -> " >/dev/null; do + AC_MSG_CHECKING([symlink for $_cur]) + _slink=`ls -ld "$_cur" | sed 's/.* -> //'` + case "$_slink" in + /*) _cur="$_slink";; + # 'X' avoids triggering unwanted echo options. + *) _cur=`echo "X$_cur" | sed -e 's/^X//' -e 's:[[^/]]*$::'`"$_slink";; + esac + AC_MSG_RESULT([$_cur]) +done +_ACJAVAH_FOLLOWED="$_cur" +]) diff --git a/vpp-api/java/m4/ax_try_compile_java.m4 b/vpp-api/java/m4/ax_try_compile_java.m4 new file mode 100644 index 00000000000..a8ed6b2a368 --- /dev/null +++ b/vpp-api/java/m4/ax_try_compile_java.m4 @@ -0,0 +1,55 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_try_compile_java.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_TRY_COMPILE_JAVA +# +# DESCRIPTION +# +# AX_TRY_COMPILE_JAVA attempt to compile user given source. +# +# *Warning*: its success or failure can depend on a proper setting of the +# CLASSPATH env. variable. +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. The +# general documentation, as well as the sample configure.in, is included +# in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Devin Weaver <ktohg@tritarget.com> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 8 + +AU_ALIAS([AC_TRY_COMPILE_JAVA], [AX_TRY_COMPILE_JAVA]) +AC_DEFUN([AX_TRY_COMPILE_JAVA],[ +AC_REQUIRE([AX_PROG_JAVAC])dnl +cat << \EOF > Test.java +/* [#]line __oline__ "configure" */ +ifelse([$1], , , [import $1;]) +public class Test { +[$2] +} +EOF +if AC_TRY_COMMAND($JAVAC $JAVACFLAGS Test.java) && test -s Test.class +then +dnl Don't remove the temporary files here, so they can be examined. + ifelse([$3], , :, [$3]) +else + echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD + cat Test.java >&AS_MESSAGE_LOG_FD +ifelse([$4], , , [ rm -fr Test.java Test.class + $4 +])dnl +fi +rm -fr Test.java Test.class]) diff --git a/vpp-api/java/m4/ax_try_run_java.m4 b/vpp-api/java/m4/ax_try_run_java.m4 new file mode 100644 index 00000000000..c680f03f2c4 --- /dev/null +++ b/vpp-api/java/m4/ax_try_run_java.m4 @@ -0,0 +1,56 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_try_run_java.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_TRY_RUN_JAVA +# +# DESCRIPTION +# +# AX_TRY_RUN_JAVA attempt to compile and run user given source. +# +# *Warning*: its success or failure can depend on a proper setting of the +# CLASSPATH env. variable. +# +# Note: This is part of the set of autoconf M4 macros for Java programs. +# It is VERY IMPORTANT that you download the whole set, some macros depend +# on other. Unfortunately, the autoconf archive does not support the +# concept of set of macros, so I had to break it for submission. The +# general documentation, as well as the sample configure.in, is included +# in the AX_PROG_JAVA macro. +# +# LICENSE +# +# Copyright (c) 2008 Devin Weaver <ktohg@tritarget.com> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 2 + +AU_ALIAS([AC_TRY_RUN_JAVA], [AX_TRY_RUN_JAVA]) +AC_DEFUN([AX_TRY_RUN_JAVA],[ +AC_REQUIRE([AX_PROG_JAVAC])dnl +AC_REQUIRE([AX_PROG_JAVA])dnl +cat << \EOF > Test.java +/* [#]line __oline__ "configure" */ +ifelse([$1], , , [include $1;]) +public class Test { +[$2] +} +EOF +if AC_TRY_COMMAND($JAVAC $JAVACFLAGS Test.java) && test -s Test.class && ($JAVA $JAVAFLAGS Test; exit) 2>/dev/null +then +dnl Don't remove the temporary files here, so they can be examined. + ifelse([$3], , :, [$3]) +else + echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD + cat Test.java >&AS_MESSAGE_LOG_FD +ifelse([$4], , , [ rm -fr Test.java Test.class + $4 +])dnl +fi +rm -fr Test.java Test.class]) diff --git a/vpp-api/python/Makefile.am b/vpp-api/python/Makefile.am new file mode 100644 index 00000000000..b96ff3d9201 --- /dev/null +++ b/vpp-api/python/Makefile.am @@ -0,0 +1,49 @@ +# Copyright (c) 2016 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +AUTOMAKE_OPTIONS = foreign subdir-objects +ACLOCAL_AMFLAGS = -I m4 +AM_CFLAGS = -Wall + +BUILT_SOURCES = +bin_PROGRAMS = +CLEANFILES = +lib_LTLIBRARIES = +noinst_PROGRAMS = test_pneum +nobase_include_HEADERS = pneum/pneum.h + +# +# Python binding +# +lib_LTLIBRARIES += libpneum.la +libpneum_la_SOURCES = pneum/pneum.c +libpneum_la_LIBADD = -lvlibmemoryclient -lvlibapi -lsvm -lvppinfra -lpthread -lm -lrt +libpneum_la_LDFLAGS = -module +libpneum_la_CPPFLAGS = + +BUILT_SOURCES += vpp_papi.py + +vpp_papi.py: $(prefix)/../vpp/api/vpe.api pneum/api-gen.py + @echo " PYTHON API"; \ + $(CC) $(CPPFLAGS) -E -P -C -x c $< \ + | vppapigen --input - --python defs_$@; \ + echo "#include <api/vpe_msg_enum.h>" \ + | $(CC) $(CPPFLAGS) -E -P -x c - | grep VL_API \ + | @srcdir@/pneum/api-gen.py -i defs_$@ > @srcdir@/vpp_papi/$@ + +# +# Test client +# +noinst_PROGRAMS += test_pneum +test_pneum_SOURCES = pneum/pneum.c pneum/test_pneum.c +test_pneum_LDADD = -lvlibmemoryclient -lvlibapi -lsvm -lvppinfra -lpthread -lm -lrt diff --git a/vpp-api/python/README.rst b/vpp-api/python/README.rst new file mode 100644 index 00000000000..e69de29bb2d --- /dev/null +++ b/vpp-api/python/README.rst diff --git a/vpp-api/python/pneum/api-gen.py b/vpp-api/python/pneum/api-gen.py new file mode 100755 index 00000000000..bbc9c3290ac --- /dev/null +++ b/vpp-api/python/pneum/api-gen.py @@ -0,0 +1,337 @@ +#!/usr/bin/env python +# +# Copyright (c) 2016 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +import argparse, sys, os, importlib, pprint + +parser = argparse.ArgumentParser(description='VPP Python API generator') +parser.add_argument('-i', action="store", dest="inputfile") +parser.add_argument('-c', '--cfile', action="store") +args = parser.parse_args() + +sys.path.append(".") + +inputfile = args.inputfile.replace('.py', '') +cfg = importlib.import_module(inputfile, package=None) + +# https://docs.python.org/3/library/struct.html +format_struct = {'u8': 'B', + 'u16' : 'H', + 'u32' : 'I', + 'i32' : 'i', + 'u64' : 'Q', + 'f64' : 'd', + 'vl_api_ip4_fib_counter_t' : 'IBQQ', + 'vl_api_ip6_fib_counter_t' : 'QQBQQ', + }; +type_size = {'u8': 1, + 'u16' : 2, + 'u32' : 4, + 'i32' : 4, + 'u64' : 8, + 'f64' : 8, + 'vl_api_ip4_fib_counter_t' : 21, + 'vl_api_ip6_fib_counter_t' : 33, +}; + +def get_args(t): + args = None + for i in t: + arg = i[1] + arg = arg.replace('_','') + if args == None: + args = arg + continue + args = args + ', ' + arg + return args + +def get_pack(t): + bytecount = 0 + pack = '>' + tup = u'' + j = -1 + for i in t: + j += 1 + if len(i) is 3: + size = type_size[i[0]] + bytecount += size * int(i[2]) + if i[2] == '0': + tup += 'msg[' + str(bytecount) + ':],' + continue + if size == 1: + n = i[2] * size + pack += str(n) + 's' + tup += 'tr[' + str(j) + '],' + continue + pack += format_struct[i[0]] * int(i[2]) + tup += 'tr[' + str(j) + ':' + str(j + int(i[2])) + '],' + j += int(i[2]) - 1 + else: + bytecount += type_size[i[0]] + pack += format_struct[i[0]] + tup += 'tr[' + str(j) + '],' + return pack, bytecount, tup + +def get_reply_func(f): + if f['name']+'_reply' in func_name: + return func_name[f['name']+'_reply'] + if f['name'].find('_dump') > 0: + r = f['name'].replace('_dump','_details') + if r in func_name: + return func_name[r] + return None + +def get_enums(): + # Read enums from stdin + enums_by_name = {} + enums_by_index = {} + i = 1 + for l in sys.stdin: + l = l.replace(',\n','') + print l, "=", i + + l = l.replace('VL_API_','').lower() + enums_by_name[l] = i + enums_by_index[i] = l + + i += 1 + return enums_by_name, enums_by_index + +def get_definitions(): + # Pass 1 + func_list = [] + func_name = {} + i = 1 + for a in cfg.vppapidef: + pack, packlen, tup = get_pack(a[1:]) + func_name[a[0]] = dict([('name', a[0]), ('args', get_args(a[4:])), ('full_args', get_args(a[1:])), ('pack', pack), ('packlen', packlen), ('tup', tup)]) + func_list.append(func_name[a[0]]) # Indexed by name + return func_list, func_name + +def generate_c_macros(func_list, enums_by_name): + file = open(args.cfile, 'w+') + print >>file, "#define foreach_api_msg \\" + for f in func_list: + if not f['name'] in enums_by_name: + continue + print >>file, "_(" + f['name'].upper() + ", " + f['name'] + ") \\" + print >>file, ''' +void pneum_set_handlers(void) { +#define _(N,n) \\ + api_func_table[VL_API_##N] = sizeof(vl_api_##n##_t); + foreach_api_msg; +#undef _ +} + ''' + +# +# XXX:Deal with empty arrays +# Print array with a hash of 'decode' and 'multipart' +# Simplify to do only decode for now. And deduce multipart from _dump? +# +def decode_function_print(name, args, pack, packlen, tup): + + print(u'def ' + name + u'_decode(msg):') + print(u" n = namedtuple('" + name + "', '" + args + "')" + + ''' + if not n: + return None + ''') + print(u" tr = unpack('" + pack + "', msg[:" + str(packlen) + "])") + print(u" r = n._make((" + tup + "))" + + ''' + if not r: + return None + return r + ''') + +def function_print(name, id, args, pack, multipart): + if not args: + args = "" + print "def", name + "(async = False):" + else: + print "def", name + "(" + args + ",async = False):" + print " global waiting_for_reply" + print " context = get_context(" + id + ")" + + print ''' + results[context] = {} + results[context]['e'] = threading.Event() + results[context]['e'].clear() + results[context]['r'] = [] + waiting_for_reply = True + ''' + if multipart == True: + print " results[context]['m'] = True" + + print " vpp_api.write(pack('" + pack + "', " + id + ", 0, context, " + args + "))" + + if multipart == True: + print " vpp_api.write(pack('>HII', VL_API_CONTROL_PING, 0, context))" + + print ''' + if not async: + results[context]['e'].wait(5) + return results[context]['r'] + return context + ''' + +# +# Should dynamically create size +# +def api_table_print (name, msg_id): + f = name + '_decode' + print('api_func_table[' + msg_id + '] = ' + f) + +# +# Generate the main Python file +# + +print '''#!/usr/bin/env python3 + +import sys, time, threading, signal, os, logging +from struct import * +from collections import namedtuple + +# +# Import C API shared object +# +import vpp_api + +context = 0 +results = {} +waiting_for_reply = False + +# +# XXX: Make this return a unique number +# +def get_context(id): + global context + context += 1 + return context + +def msg_handler(msg): + global result, context, event_callback, waiting_for_reply + if not msg: + logging.warning('vpp_api.read failed') + return + + id = unpack('>H', msg[0:2]) + logging.debug('Received message', id[0]) + if id[0] == VL_API_RX_THREAD_EXIT: + logging.info("We got told to leave") + return; + + # + # Decode message and returns a tuple. + # + logging.debug('api_func', api_func_table[id[0]]) + r = api_func_table[id[0]](msg) + if not r: + logging.warning('Message decode failed', id[0]) + return + + if 'context' in r._asdict(): + if r.context > 0: + context = r.context + + # + # XXX: Call provided callback for event + # Are we guaranteed to not get an event during processing of other messages? + # How to differentiate what's a callback message and what not? Context = 0? + # + logging.debug('R:', context, r, waiting_for_reply) + if waiting_for_reply == False: + event_callback(r) + return + + # + # Collect results until control ping + # + if id[0] == VL_API_CONTROL_PING_REPLY: + results[context]['e'].set() + waiting_for_reply = False + return + if not context in results: + logging.warning('Not expecting results for this context', context) + return + if 'm' in results[context]: + results[context]['r'].append(r) + return + + results[context]['r'] = r + results[context]['e'].set() + waiting_for_reply = False + +def connect(name): + signal.alarm(3) # 3 second + rv = vpp_api.connect(name, msg_handler) + signal.alarm(0) + logging.info("Connect:", rv) + return rv + +def disconnect(): + rv = vpp_api.disconnect() + logging.info("Disconnected") + return rv + +def register_event_callback(callback): + global event_callback + event_callback = callback +''' + +enums_by_name, enums_by_index = get_enums() +func_list, func_name = get_definitions() + +# +# Not needed with the new msg_size field. +# generate_c_macros(func_list, enums_by_name) +# + +pp = pprint.PrettyPrinter(indent=4) +#print 'enums_by_index =', pp.pprint(enums_by_index) +#print 'func_name =', pp.pprint(func_name) + +# Pass 2 + +# +# 1) The VPE API lacks a clear definition of what messages are reply messages +# 2) Length is missing, and has to be pre-known or in case of variable sized ones calculated per message type +# +for f in func_list: + #if f['name'].find('_reply') > 0 or f['name'].find('_details') > 0: + decode_function_print(f['name'], f['full_args'], f['pack'], f['packlen'], f['tup']) + + #r = get_reply_func(f) + #if not r: + # # + # # XXX: Functions here are not taken care of. E.g. events + # # + # print('Missing function', f) + # continue + + if f['name'].find('_dump') > 0: + f['multipart'] = True + else: + f['multipart'] = False + msg_id_in = 'VL_API_' + f['name'].upper() + function_print(f['name'], msg_id_in, f['args'], f['pack'], f['multipart']) + + +print "api_func_table = [0] * 10000" +for f in func_list: + # if f['name'].find('_reply') > 0 or f['name'].find('_details') > 0: + msg_id_in = 'VL_API_' + f['name'].upper() + api_table_print(f['name'], msg_id_in) diff --git a/vpp-api/python/pneum/pneum.c b/vpp-api/python/pneum/pneum.c new file mode 100644 index 00000000000..971c79bf6aa --- /dev/null +++ b/vpp-api/python/pneum/pneum.c @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <stdio.h> +#include <stdlib.h> +#include <stddef.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <netinet/in.h> +#include <netdb.h> +#include <signal.h> +#include <setjmp.h> +#include <stdbool.h> + +#include <vnet/vnet.h> +#include <vlib/vlib.h> +#include <vlib/unix/unix.h> +#include <vlibapi/api.h> +#include <vlibmemory/api.h> + +#include <api/vpe_msg_enum.h> + +#include "pneum.h" + +#define vl_typedefs /* define message structures */ +#include <api/vpe_all_api_h.h> +#undef vl_typedefs + +#define vl_endianfun /* define message structures */ +#include <api/vpe_all_api_h.h> +#undef vl_endianfun + +typedef struct { + u8 rx_thread_jmpbuf_valid; + u8 connected_to_vlib; + jmp_buf rx_thread_jmpbuf; + pthread_t rx_thread_handle; +} pneum_main_t; + +pneum_main_t pneum_main; + +extern int wrap_pneum_callback(char *data, int len); + +/* + * Satisfy external references when -lvlib is not available. + */ +void vlib_cli_output (struct vlib_main_t * vm, char * fmt, ...) +{ + clib_warning ("vlib_cli_output callled..."); +} + +#define vl_api_version(n,v) static u32 vpe_api_version = v; +#include <api/vpe.api.h> +#undef vl_api_version +void +vl_client_add_api_signatures (vl_api_memclnt_create_t *mp) +{ + /* + * Send the main API signature in slot 0. This bit of code must + * match the checks in ../vpe/api/api.c: vl_msg_api_version_check(). + */ + mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version); +} + +static void +pneum_api_handler (void *msg) +{ + u16 id = ntohs(*((u16 *)msg)); + + if (id == VL_API_RX_THREAD_EXIT) { + pneum_main_t *pm = &pneum_main; + vl_msg_api_free(msg); + longjmp(pm->rx_thread_jmpbuf, 1); + } + msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data)); + int l = ntohl(msgbuf->data_len); + if (l == 0) + clib_warning("Message ID %d has wrong length: %d\n", id, l); + + /* Call Python callback */ + (void)wrap_pneum_callback(msg, l); + vl_msg_api_free(msg); +} + +static void * +pneum_rx_thread_fn (void *arg) +{ + unix_shared_memory_queue_t *q; + pneum_main_t *pm = &pneum_main; + api_main_t *am = &api_main; + uword msg; + + q = am->vl_input_queue; + + /* So we can make the rx thread terminate cleanly */ + if (setjmp(pm->rx_thread_jmpbuf) == 0) { + pm->rx_thread_jmpbuf_valid = 1; + while (1) + while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0)) + pneum_api_handler((void *)msg); + } + pthread_exit(0); +} + +int +pneum_connect (char *name) +{ + int rv = 0; + pneum_main_t *pm = &pneum_main; + + /* + * Bail out now if we're not running as root + */ + if (geteuid() != 0) + return (-1); + + if ((rv = vl_client_api_map("/vpe-api"))) { + clib_warning ("vl_client_api map rv %d", rv); + return rv; + } + + if (vl_client_connect(name, 0, 32) < 0) { + vl_client_api_unmap(); + return (-1); + } + + /* Start the rx queue thread */ + rv = pthread_create(&pm->rx_thread_handle, NULL, pneum_rx_thread_fn, 0); + if (rv) { + clib_warning("pthread_create returned %d", rv); + vl_client_api_unmap(); + return (-1); + } + + pm->connected_to_vlib = 1; + + return (0); +} + +int +pneum_disconnect (void) +{ + api_main_t *am = &api_main; + pneum_main_t *pm = &pneum_main; + + fformat (stdout,"disconnecting from vpe \n"); + + if (pm->rx_thread_jmpbuf_valid) { + vl_api_rx_thread_exit_t *ep; + uword junk; + ep = vl_msg_api_alloc (sizeof (*ep)); + ep->_vl_msg_id = ntohs(VL_API_RX_THREAD_EXIT); + vl_msg_api_send_shmem(am->vl_input_queue, (u8 *)&ep); + pthread_join(pm->rx_thread_handle, (void **) &junk); + } + if (pm->connected_to_vlib) { + vl_client_disconnect(); + vl_client_api_unmap(); + } + memset (pm, 0, sizeof (*pm)); + + return (0); +} + +int +pneum_read (char **p, int *l) +{ + unix_shared_memory_queue_t *q; + api_main_t *am = &api_main; + uword msg; + + *l = 0; + + if (am->our_pid == 0) return (-1); + + q = am->vl_input_queue; + int rv = unix_shared_memory_queue_sub(q, (u8 *)&msg, 0); + if (rv == 0) { + u16 msg_id = ntohs(*((u16 *)msg)); + msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data)); + *l = ntohl(msgbuf->data_len); + if (*l == 0) { + printf("Unregistered API message: %d\n", msg_id); + return (-1); + } + *p = (char *)msg; + } else { + printf("Read failed with %d\n", rv); + } + return (rv); +} + +/* + * XXX: Makes the assumption that client_index is the first member + */ +typedef VL_API_PACKED(struct _vl_api_header { + u16 _vl_msg_id; + u32 client_index; +}) vl_api_header_t; + +static unsigned int +pneum_client_index (void) +{ + return (api_main.my_client_index); +} + +int +pneum_write (char *p, int l) +{ + int rv = -1; + api_main_t *am = &api_main; + vl_api_header_t *mp = vl_msg_api_alloc(l); + unix_shared_memory_queue_t *q; + + if (!mp) return (-1); + memcpy(mp, p, l); + mp->client_index = pneum_client_index(); + q = am->shmem_hdr->vl_input_queue; + rv = unix_shared_memory_queue_add(q, (u8 *)&mp, 0); + if (rv != 0) { + printf("vpe_api_write fails: %d\n", rv); + /* Clear message */ + vl_msg_api_free(mp); + } + return (rv); +} diff --git a/vpp-api/python/pneum/pneum.h b/vpp-api/python/pneum/pneum.h new file mode 100644 index 00000000000..b99cbd4e3ec --- /dev/null +++ b/vpp-api/python/pneum/pneum.h @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef __included_pneum_h__ +#define __included_pneum_h__ + +unsigned int vpe_client_index(void); +int pneum_connect(char *name); +int pneum_disconnect(void); +int pneum_read(char **data, int *l); +int pneum_write(char *data, int len); + +#endif diff --git a/vpp-api/python/pneum/test_pneum.c b/vpp-api/python/pneum/test_pneum.c new file mode 100644 index 00000000000..18627b3f2c5 --- /dev/null +++ b/vpp-api/python/pneum/test_pneum.c @@ -0,0 +1,136 @@ +/* + *------------------------------------------------------------------ + * test_pneum.c + * + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------ + */ +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <netinet/in.h> +#include <netdb.h> + +#include <time.h> /* time_t, time (for timestamp in second) */ +#include <sys/timeb.h> /* ftime, timeb (for timestamp in millisecond) */ +#include <sys/time.h> /* gettimeofday, timeval (for timestamp in microsecond) */ + +#include <vnet/vnet.h> +#include <vlib/vlib.h> +#include <vlib/unix/unix.h> +#include <vlibapi/api.h> +#include <vlibmemory/api.h> +#include <vnet/ip/ip.h> + +#include <api/vpe_msg_enum.h> +#include <signal.h> +#include <setjmp.h> +#include "pneum.h" + +#define vl_typedefs /* define message structures */ +#include <api/vpe_all_api_h.h> +#undef vl_typedefs + +volatile int sigterm_received = 0; +volatile u32 result_ready; +volatile u16 result_msg_id; + +/* M_NOALLOC: construct, but don't yet send a message */ + +#define M_NOALLOC(T,t) \ + do { \ + result_ready = 0; \ + memset (mp, 0, sizeof (*mp)); \ + mp->_vl_msg_id = ntohs (VL_API_##T); \ + mp->client_index = am->my_client_index; \ + } while(0); + + + +int +wrap_pneum_callback (char *data, int len) +{ + //printf("Callback %d\n", len); + result_ready = 1; + result_msg_id = ntohs(*((u16 *)data)); + return (0); +} + +int main (int argc, char ** argv) +{ + api_main_t * am = &api_main; + vl_api_show_version_t message; + vl_api_show_version_t *mp; + int async = 1; + int rv = pneum_connect("pneum_client"); + + if (rv != 0) { + printf("Connect failed: %d\n", rv); + exit(rv); + } + + struct timeb timer_msec; + long long int timestamp_msec_start; /* timestamp in millisecond. */ + if (!ftime(&timer_msec)) { + timestamp_msec_start = ((long long int) timer_msec.time) * 1000ll + + (long long int) timer_msec.millitm; + } + else { + timestamp_msec_start = -1; + } + + + /* + * Test vpe_api_write and vpe_api_read to send and recv message for an + * API + */ + int i; + long int no_msgs = 10000; + mp = &message; + + for (i = 0; i < no_msgs; i++) { + /* Construct the API message */ + M_NOALLOC(SHOW_VERSION, show_version); + pneum_write((char *)mp, sizeof(*mp)); + if (!async) + while (result_ready == 0); + } + if (async) { + vl_api_control_ping_t control; + vl_api_control_ping_t *mp; + mp = &control; + M_NOALLOC(CONTROL_PING, control_ping); + pneum_write((char *)mp, sizeof(*mp)); + + while (result_msg_id != VL_API_CONTROL_PING_REPLY); + } + + long long int timestamp_msec_end; /* timestamp in millisecond. */ + if (!ftime(&timer_msec)) { + timestamp_msec_end = ((long long int) timer_msec.time) * 1000ll + + (long long int) timer_msec.millitm; + } + else { + timestamp_msec_end = -1; + } + + printf("Took %lld msec, %lld msgs/msec \n", (timestamp_msec_end - timestamp_msec_start), + no_msgs/(timestamp_msec_end - timestamp_msec_start)); + fformat(stdout, "Exiting...\n"); + pneum_disconnect(); + exit (0); +} diff --git a/vpp-api/python/setup.py b/vpp-api/python/setup.py new file mode 100644 index 00000000000..d890ba709dc --- /dev/null +++ b/vpp-api/python/setup.py @@ -0,0 +1,21 @@ +from distutils.core import setup, Extension + +module1 = Extension('vpp_api', + define_macros = [('MAJOR_VERSION', '1'), + ('MINOR_VERSION', '0')], + include_dirs = ['pneum'], + libraries = ['pneum'], + library_dirs = ['../../build-root/install-vpp_debug-native/vpp-api/lib64'], + sources = ['vpp_papi/pneum_wrap.c']) + +setup (name = 'vpp_papi', + version = '1.0', + description = 'VPP Python binding', + author = 'Ole Troan', + author_email = 'ot@cisco.com', + #url = 'https://docs.python.org/extending/building', + packages=['vpp_papi'], + long_description = ''' +VPP Python language binding. +''', + ext_modules = [module1]) diff --git a/vpp-api/python/tests/test_papi.py b/vpp-api/python/tests/test_papi.py new file mode 100755 index 00000000000..ec51f0936cb --- /dev/null +++ b/vpp-api/python/tests/test_papi.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 + +import vpp_papi +import unittest, sys, time, threading, struct, logging +from ipaddress import * + +papi_event = threading.Event() +def papi_event_handler(result): + if result.vlmsgid == vpp_papi.VL_API_SW_INTERFACE_SET_FLAGS: + papi_event.set() + return + if result.vlmsgid == vpp_papi.VL_API_VNET_INTERFACE_COUNTERS: + format = '>' + str(int(len(result.data) / 8)) + 'Q' + counters = struct.unpack(format, result.data) + print('Counters:', counters) + return + + print('Unknown message id:', result.vlmsgid) + +class TestPAPI(unittest.TestCase): + + def setUp(self): + r = vpp_papi.connect("test_papi") + self.assertEqual(r, 0) + + def tearDown(self): + r = vpp_papi.disconnect() + self.assertEqual(r, 0) + + def test_show_version(self): + t = vpp_papi.show_version() + program = t.program.decode().rstrip('\x00') + self.assertEqual('vpe', program) + + # + # Add a few MAP domains, then dump them later + # + def test_map(self): + t = vpp_papi.map_summary_stats() + print(t) + ip6 = IPv6Address(u'2001:db8::1').packed + ip4 = IPv4Address(u'10.0.0.0').packed + ip6_src = IPv6Address(u'2001:db9::1').packed + t = vpp_papi.map_add_domain(ip6, ip4, ip6_src, 32, 24, 128, 0, 0, 6, 0, 0) + print(t) + self.assertEqual(t.retval, 0) + + ip4 = IPv4Address(u'10.0.1.0').packed + t = vpp_papi.map_add_domain(ip6, ip4, ip6_src, 32, 24, 128, 0, 0, 6, 0, 0) + print(t) + self.assertEqual(t.retval, 0) + + t = vpp_papi.map_summary_stats() + print(t) + self.assertEqual(t.totalbindings, 2) + + t = vpp_papi.map_domain_dump() + print (t) + self.assertEqual(len(t), 2) + + def test_sw_interface_dump(self): + # + # Dump interfaces + # + t = vpp_papi.sw_interface_dump(0, b'ignored') + for interface in t: + if interface.vlmsgid == vpp_papi.VL_API_SW_INTERFACE_DETAILS: + print(interface.interfacename.decode()) + + def test_want_interface_events(self): + pid = 123 + vpp_papi.register_event_callback(papi_event_handler) + papi_event.clear() + t = vpp_papi.want_interface_events(True, pid) + print (t) + print('Setting interface up') + t = vpp_papi.sw_interface_set_flags(0, 1, 1, 0) + print (t) + self.assertEqual(papi_event.wait(5), True) + t = vpp_papi.sw_interface_set_flags(0, 0, 0, 0) + print (t) + self.assertEqual(papi_event.wait(5), True) + + @unittest.skip("not quite ready yet") + def test_want_stats(self): + pid = 123 + vpp_papi.register_event_callback(papi_event_handler) + papi_event.clear() + t = vpp_papi.want_stats(True, pid) + + print (t) + + # + # Wait for some stats + # + self.assertEqual(papi_event.wait(30), True) + t = vpp_papi.want_stats(False, pid) + print (t) + + def test_tap(self): + pid = 123 + vpp_papi.register_event_callback(papi_event_handler) + papi_event.clear() + t = vpp_papi.want_stats(True, pid) + + print (t) + + t = vpp_papi.tap_connect(1, b'tap', b'foo', 1, 0) + print (t) + self.assertEqual(t.retval, 0) + swifindex = t.swifindex + + t = vpp_papi.sw_interface_set_flags(swifindex, 1, 1, 0) + print (t) + self.assertEqual(t.retval, 0) + + ip6 = IPv6Address(u'2001:db8::1').packed + t = vpp_papi.sw_interface_add_del_address(swifindex, 1, 1, 0, 16, ip6) + print (t) + time.sleep(40) + + +if __name__ == '__main__': + #logging.basicConfig(level=logging.DEBUG) + unittest.main() diff --git a/vpp-api/python/vpp_papi/__init__.py b/vpp-api/python/vpp_papi/__init__.py new file mode 100644 index 00000000000..8be644d7cb7 --- /dev/null +++ b/vpp-api/python/vpp_papi/__init__.py @@ -0,0 +1,2 @@ +__import__('pkg_resources').declare_namespace(__name__) +from .vpp_papi import * diff --git a/vpp-api/python/vpp_papi/pneum_wrap.c b/vpp-api/python/vpp_papi/pneum_wrap.c new file mode 100644 index 00000000000..09d972d447c --- /dev/null +++ b/vpp-api/python/vpp_papi/pneum_wrap.c @@ -0,0 +1,120 @@ +#include <Python.h> +#include "pneum.h" + +static PyObject *pneum_callback = NULL; + +int +wrap_pneum_callback (char *data, int len) +{ + PyGILState_STATE gstate; + PyObject *result;//, *arglist; + + gstate = PyGILState_Ensure(); + + /* Time to call the callback */ + result = PyObject_CallFunction(pneum_callback, "y#", data, len); + if (result) + Py_DECREF(result); + else + PyErr_Print(); + + PyGILState_Release(gstate); + return (0); +} + +static PyObject * +wrap_connect (PyObject *self, PyObject *args) +{ + char *name; + int rv; + PyObject *temp; + + if (!PyArg_ParseTuple(args, "sO:set_callback", &name, &temp)) + return (NULL); + + if (!PyCallable_Check(temp)) { + PyErr_SetString(PyExc_TypeError, "parameter must be callable"); + return NULL; + } + + Py_XINCREF(temp); /* Add a reference to new callback */ + Py_XDECREF(pneum_callback); /* Dispose of previous callback */ + pneum_callback = temp; /* Remember new callback */ + + Py_BEGIN_ALLOW_THREADS + rv = pneum_connect(name); + Py_END_ALLOW_THREADS + return PyLong_FromLong(rv); +} + +static PyObject * +wrap_disconnect (PyObject *self, PyObject *args) +{ + int rv; + Py_BEGIN_ALLOW_THREADS + rv = pneum_disconnect(); + Py_END_ALLOW_THREADS + return PyLong_FromLong(rv); +} +static PyObject * +wrap_write (PyObject *self, PyObject *args) +{ + char *data; + int len, rv; + + if (!PyArg_ParseTuple(args, "s#", &data, &len)) + return NULL; + Py_BEGIN_ALLOW_THREADS + rv = pneum_write(data, len); + Py_END_ALLOW_THREADS + + return PyLong_FromLong(rv); +} + +void vl_msg_api_free(void *); + +static PyObject * +wrap_read (PyObject *self, PyObject *args) +{ + char *data; + int len, rv; + + Py_BEGIN_ALLOW_THREADS + rv = pneum_read(&data, &len); + Py_END_ALLOW_THREADS + + if (rv != 0) { Py_RETURN_NONE; } + + PyObject *ret = Py_BuildValue("y#", data, len); + if (!ret) { Py_RETURN_NONE; } + + vl_msg_api_free(data); + return ret; +} + +static PyMethodDef vpp_api_Methods[] = { + {"connect", wrap_connect, METH_VARARGS, "Connect to the VPP API."}, + {"disconnect", wrap_disconnect, METH_VARARGS, "Disconnect from the VPP API."}, + {"write", wrap_write, METH_VARARGS, "Write data to the VPP API."}, + {"read", wrap_read, METH_VARARGS, "Read data from the VPP API."}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +static struct PyModuleDef vpp_api_module = { + PyModuleDef_HEAD_INIT, + "vpp_api", /* name of module */ + NULL, /* module documentation, may be NULL */ + -1, /* size of per-interpreter state of the module, + or -1 if the module keeps state in global variables. */ + vpp_api_Methods +}; + +PyMODINIT_FUNC +PyInit_vpp_api (void) +{ + /* Ensure threading is initialised */ + if (!PyEval_ThreadsInitialized()) { + PyEval_InitThreads(); + } + return PyModule_Create(&vpp_api_module); +} |