Merge pull request #1 from openziti/initial-implementation

initial ziti-sdk-c wrap

Author: ekoby

.github/CODEOWNERS

@@ -0,0 +1,3 @@
+# see:
+# https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/about-code-owners
+* @openziti/maintainers

.github/workflows/mattermost-ziti-webhook.yml

@@ -0,0 +1,23 @@
+name: mattermost-ziti-webhook
+on: 
+  create:
+  delete:
+  issues:
+  issue_comment:
+  pull_request_review:
+  pull_request_review_comment:
+  pull_request:
+  push:
+  fork:
+  release:
+
+jobs:
+  mattermost-ziti-webhook:
+    runs-on: macos-latest
+    name: POST Webhook
+    steps:
+    - uses: openziti/ziti-webhook-action@main
+      with:
+        ziti-id: ${{ secrets.ZITI_MATTERMOST_IDENTITY }}
+        webhook-url: ${{ secrets.ZITI_MATTERMOST_WEBHOOK_URL }}
+        webhook-secret: ${{ secrets.ZITI_MATTERMOSTI_WEBHOOK_SECRET }}

.gitignore

@@ -127,3 +127,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+.idea/

setup.py

@@ -0,0 +1,47 @@
+#  Copyright (c) 2022.  NetFoundry, Inc.
+#
+#  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
+#
+#  https://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 setuptools
+from setuptools import setup
+
+setup(
+    name='openziti',
+    version='0.1.0',
+    description='Ziti Python SDK',
+    url='https://github.com/openziti/ziti-sdk-py',
+    author='Eugene Kobyakov',
+    author_email='eugene@openziti.org',
+    license='Apache 2.0',
+    packages=['ziti'],
+    install_requires=[],
+    include_package_data=True,
+    package_data={
+        "": ["libziti.so"],
+    },
+    ext_modules=[
+        setuptools.Extension("zitilib", [])
+    ],
+
+    classifiers=[
+        'Development Status :: 1 - Planning',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: POSIX :: Linux',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+    ],
+)

ziti/__init__.py

@@ -0,0 +1,53 @@
+#  Copyright (c) 2022.  NetFoundry, Inc.
+#
+#  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
+#
+#  https://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 os.path
+from ziti import zitilib
+from ziti import context
+from ziti import zitisock
+import socket
+
+_ziti_identities = (os.getenv('ZITI_IDENTITIES') or "").split(';')
+_id_map = dict()
+
+zitilib.init()
+
+version = zitilib.version
+shutdown = zitilib.shutdown
+load = context.load_identity
+
+for id in _ziti_identities:
+    if id != '':
+        load(id)
+
+_patch_methods = dict(
+    create_connection = zitisock.create_ziti_connection,
+    getaddrinfo = zitisock.ziti_getaddrinfo
+)
+
+
+class monkeypatch(object):
+    def __init__(self):
+        self.orig_socket = socket.socket
+        socket.socket = zitisock.ZitiSocket
+        self.orig_methods = dict((m, socket.__dict__[m]) for m in _patch_methods)
+        for m in _patch_methods:
+            socket.__dict__[m] = _patch_methods[m]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        for m in self.orig_methods:
+            socket.__dict__[m] = self.orig_methods[m]

ziti/context.py

@@ -0,0 +1,30 @@
+#  Copyright (c) 2022.  NetFoundry, Inc.
+#
+#  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
+#
+#  https://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 socket
+from ziti import zitilib
+
+class ZitiContext:
+    def __init__(self, ctx_p):
+        self._ctx = ctx_p
+
+    def connect(self, addr):
+        fd = zitilib.ziti_socket(socket.SOCK_STREAM)
+        service = bytes(addr, encoding = "utf-8")
+        zitilib.ziti_connect(fd, self._ctx, service)
+        return socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0, fd)
+
+
+def load_identity(path) -> ZitiContext:
+    return ZitiContext(zitilib.load(path))

ziti/zitilib.py

@@ -0,0 +1,71 @@
+#  Copyright (c) 2022.  NetFoundry, Inc.
+#
+#  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
+#
+#  https://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 ctypes
+import os
+from typing import Tuple
+
+_mod_path = os.path.dirname(__file__)
+ziti = ctypes.CDLL(_mod_path + '/libziti.so')
+
+
+class _Ver(ctypes.Structure):
+    _fields_ = [('version', ctypes.c_char_p), ('revision', ctypes.c_char_p)]
+
+    def __repr__(self):
+        return '({0}, {1})'.format(self.version, self.revision)
+
+
+_ziti_version = ziti.ziti_get_version
+_ziti_version.restype = ctypes.POINTER(_Ver)
+
+_load_ctx = ziti.Ziti_load_context
+_load_ctx.argtypes = [ctypes.POINTER(ctypes.c_char), ]
+_load_ctx.restype = ctypes.c_void_p
+
+ziti_socket = ziti.Ziti_socket
+ziti_socket.argtypes = [ctypes.c_int]
+ziti_socket.restype = ctypes.c_int
+
+ziti_connect = ziti.Ziti_connect
+ziti_connect.argtypes = [ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p]
+
+
+_ziti_connect_addr = ziti.Ziti_connect_addr
+_ziti_connect_addr.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int]
+_ziti_connect_addr.restype = ctypes.c_int
+
+
+def version():
+    ver = _ziti_version().contents
+    return ver
+
+
+def init():
+    ziti.Ziti_lib_init()
+
+
+def shutdown():
+    ziti.Ziti_lib_shutdown()
+
+
+def load(path):
+    b = bytes(path, encoding = "utf-8")
+    return _load_ctx(b)
+
+
+def connect(fd, addr: Tuple[str, int]):
+    host = bytes(addr[0], encoding = 'utf-8')
+    port = addr[1]
+    return _ziti_connect_addr(fd, host, port)

ziti/zitisock.py

@@ -0,0 +1,68 @@
+#  Copyright (c) 2022.  NetFoundry, Inc.
+#
+#  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
+#
+#  https://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 socket
+from typing import Tuple
+from ziti import zitilib
+
+py_socket = socket.socket
+
+class ZitiSocket(py_socket):
+    def __init__(self, af = -1, type = -1, proto = -1, fileno = None):
+        self._ziti_af = af
+        self._ziti_type = type
+        self._ziti_proto = proto
+        if fileno:
+            py_socket.__init__(self, af, type, proto, fileno)
+            return
+
+        self._zitifd = zitilib.ziti_socket(type)
+        py_socket.__init__(self, af, type, proto, self._zitifd)
+
+    def connect(self, addr) -> None:
+        if self._zitifd is None:
+            pass
+
+        if isinstance(addr, Tuple):
+            rc = zitilib.connect(self._zitifd, addr)
+            if rc != 0:
+                py_socket.close(self)
+                self._zitifd = None
+                py_socket.__init__(self, self._ziti_af, self._ziti_type, self._ziti_proto)
+                py_socket.connect(self, addr)
+
+    def setsockopt(self, __level: int, __optname: int, __value: int | bytes) -> None:
+        try:
+            py_socket.setsockopt(self, __level, __optname, __value)
+        except:
+            pass
+
+
+def create_ziti_connection(address,
+                      timeout= socket._GLOBAL_DEFAULT_TIMEOUT,
+                      source_address=None):
+    s = ZitiSocket(socket.SOCK_STREAM)
+    s.connect(address)
+    return s
+
+
+def ziti_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
+    addrlist = []
+    addr = (
+        socket._intenum_converter(socket.AF_INET, socket.AddressFamily),
+        socket._intenum_converter(type, socket.SocketKind),
+        proto, '', (host,port))
+
+    addrlist.append(addr)
+    return addrlist