测试模块加载

entry/build-profile.json5

@@ -17,7 +17,7 @@
     "arkOptions": {
       "runtimeOnly" : {
         "packages": [
-          "libOCCTRender.so"
+          "libcurl.so"
         ]
       }
     }

entry/oh-package-lock.json5

@@ -6,13 +6,13 @@
   "lockfileVersion": 3,
   "ATTENTION": "THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.",
   "specifiers": {
-    "libOCCTRender.so@src/main/cpp/types/libOCCTRender": "libOCCTRender.so@src/main/cpp/types/libOCCTRender"
+    "libcurl.so@src/main/cpp/types/libcurl": "libcurl.so@src/main/cpp/types/libcurl"
   },
   "packages": {
-    "libOCCTRender.so@src/main/cpp/types/libOCCTRender": {
+    "libcurl.so@src/main/cpp/types/libcurl": {
-      "name": "libOCCTRender.so",
+      "name": "libcurl.so",
       "version": "1.0.0",
-      "resolved": "src/main/cpp/types/libOCCTRender",
+      "resolved": "src/main/cpp/types/libcurl",
       "registryType": "local"
     }
   }

entry/oh-package.json5

@@ -6,6 +6,7 @@
   "author": "",
   "license": "",
   "dependencies": {
-    "libOCCTRender.so": "file:./src/main/cpp/types/libOCCTRender"
+    //"libOCCTRender.so": "file:./src/main/cpp/types/libOCCTRender"
+    "libcurl.so": "file:./src/main/cpp/types/libcurl"
   }
 }

entry/src/main/cpp/CMakeLists.txt

@@ -13,26 +13,62 @@ add_definitions(-DOHOS_PLATFORM)
 include_directories(${NATIVERENDER_ROOT_PATH}
                     ${NATIVERENDER_ROOT_PATH}/include)
 
-# OCCT库配置
+#设定库目录
-set(OCCT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/opencascade)
+set(LIBS_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../../libs)
-set(OCCT_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/${OHOS_ARCH})
+set(CURL_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/curl)
-
+set(CURL_LIB_DIR ${LIBS_ROOT}/${OHOS_ARCH})
-# 添加OCCT库
+link_directories(${CURL_LIB_DIR})
-link_directories(${OCCT_LIB_DIR})
+include_directories(${CURL_INCLUDE_DIR})
-include_directories(${OCCT_INCLUDE_DIR})
+set(CURL_LIBS
-
+    ${CURL_LIB_DIR}/libcrypto.so
-# 添加源文件
+    ${CURL_LIB_DIR}/libssl.so
-add_library(OCCTRender SHARED
+    ${CURL_LIB_DIR}/libz.so.1
-    napi_init.cpp
+    ${CURL_LIB_DIR}/libcurl.so.4.8.0
-    #Header
+)
-    EGLCore/EGLCore.h
+# OCCT库路径配置
-    OCCTRender/OCCTRender.h
+#set(OCCT_NAME "opencascade")
-    OCCTRenderThread/OCCTRenderThread.h
+#set(OCCT_VERSION "7.9")
-    #Cpp Src
+#set(OCCT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/${OCCT_NAME})
-    EGLCore/EGLCore.cpp
+#set(OCCT_LIB_DIR ${LIBS_ROOT}/${OHOS_ARCH})
-    OCCTRender/OCCTRender.cpp
+#link_directories(${OCCT_LIB_DIR})
-    OCCTRenderThread/OCCTRenderThread.cpp
+#include_directories(${OCCT_INCLUDE_DIR})
-    )
+#set(OCCT_LIBS
+#    ${OCCT_LIB_DIR}/libTKernel.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKBRep.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKOpenGles.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKMath.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKG2d.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKG3d.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKGeomBase.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKGeomAlgo.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKTopAlgo.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKMesh.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKService.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKV3d.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKXCAF.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKCAF.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKLCAF.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKCDF.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKFillet.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKDESTEP.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKShHealing.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKHLR.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKVCAF.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKBO.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKPrim.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKBool.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKDE.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libTKXSBase.so.${OCCT_VERSION}
+#    ${OCCT_LIB_DIR}/libfreetype.so.6
+#    ${OCCT_LIB_DIR}/libfontconfig.so.1
+#    ${OCCT_LIB_DIR}/libexpat.so.1
+#    ${OCCT_LIB_DIR}/libz.so.1
+#    ${OCCT_LIB_DIR}/libbz2.so.1.0
+#    ${OCCT_LIB_DIR}/libpng16.so.16
+#    ${OCCT_LIB_DIR}/libbrotlicommon.so.1
+#    ${OCCT_LIB_DIR}/libbrotlidec.so.1
+#    ${OCCT_LIB_DIR}/libbrotlienc.so.1
+#)
 
 find_library(EGL-lib EGL)
 find_library(GLES-lib GLESv3)
@@ -40,53 +76,30 @@ find_library(hilog-lib hilog_ndk.z)
 find_library(libace-lib ace_ndk.z)
 find_library(libuv-lib uv)
 
-set(OCCT_LIBS
+# 添加源文件
-    ${OCCT_LIB_DIR}/libTKernel.so.7.9
+add_library(nativecurl SHARED
-    ${OCCT_LIB_DIR}/libTKBRep.so.7.9
+    #Header
-    ${OCCT_LIB_DIR}/libTKOpenGles.so.7.9
+#    EGLCore/EGLCore.h
-    ${OCCT_LIB_DIR}/libTKMath.so.7.9
+#    OCCTRender/OCCTRender.h
-    ${OCCT_LIB_DIR}/libTKG2d.so.7.9
+#    OCCTRenderThread/OCCTRenderThread.h
-    ${OCCT_LIB_DIR}/libTKG3d.so.7.9
+    #Cpp Src
-    ${OCCT_LIB_DIR}/libTKGeomBase.so.7.9
+#    EGLCore/EGLCore.cpp
-    ${OCCT_LIB_DIR}/libTKGeomAlgo.so.7.9
+#    OCCTRender/OCCTRender.cpp
-    ${OCCT_LIB_DIR}/libTKTopAlgo.so.7.9
+#    OCCTRenderThread/OCCTRenderThread.cpp
-    ${OCCT_LIB_DIR}/libTKMesh.so.7.9
+    #NAPI Src
-    ${OCCT_LIB_DIR}/libTKService.so.7.9
+    napi_init.cpp
-    ${OCCT_LIB_DIR}/libTKV3d.so.7.9
-    ${OCCT_LIB_DIR}/libTKXCAF.so.7.9
-    ${OCCT_LIB_DIR}/libTKCAF.so.7.9
-    ${OCCT_LIB_DIR}/libTKLCAF.so.7.9
-    ${OCCT_LIB_DIR}/libTKCDF.so.7.9
-    ${OCCT_LIB_DIR}/libTKFillet.so.7.9
-    ${OCCT_LIB_DIR}/libTKDESTEP.so.7.9
-    ${OCCT_LIB_DIR}/libTKShHealing.so.7.9
-    ${OCCT_LIB_DIR}/libTKHLR.so.7.9
-    ${OCCT_LIB_DIR}/libTKVCAF.so.7.9
-    ${OCCT_LIB_DIR}/libTKBO.so.7.9
-    ${OCCT_LIB_DIR}/libTKPrim.so.7.9
-    ${OCCT_LIB_DIR}/libTKBool.so.7.9
-    ${OCCT_LIB_DIR}/libTKDE.so.7.9
-    ${OCCT_LIB_DIR}/libTKXSBase.so.7.9
-    ${OCCT_LIB_DIR}/libfreetype.so.6
-    ${OCCT_LIB_DIR}/libfontconfig.so.1
-    ${OCCT_LIB_DIR}/libexpat.so.1
-    ${OCCT_LIB_DIR}/libz.so.1
-    ${OCCT_LIB_DIR}/libbz2.so.1.0
-    ${OCCT_LIB_DIR}/libpng16.so.16
-    ${OCCT_LIB_DIR}/libbrotlicommon.so.1
-    ${OCCT_LIB_DIR}/libbrotlidec.so.1
-    ${OCCT_LIB_DIR}/libbrotlienc.so.1
 )
 
-target_link_libraries(OCCTRender PUBLIC
+target_link_libraries(nativecurl PUBLIC
-    # OCCT核心库
+    libnative_window.so
-    ${OCCT_LIBS}
+    libace_napi.z.so
     #EGL Hilog库
     ${EGL-lib}
     ${GLES-lib}
     ${hilog-lib}
     ${libace-lib}
     ${libuv-lib}
-    libnative_window.so
+    ${CURL_LIBS}
-    libace_napi.z.so
+    # OCCT核心库
+    #${OCCT_LIBS}
 )

entry/src/main/cpp/EGLCore/EGLCore.cpp

@@ -4,71 +4,121 @@
 // Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
 // please include "napi/native_api.h".
 #include "EGLCore.h"
-#include <GLES3/gl3.h>
+#include <cstdio>
-#include <iostream>
+#include <cstring>
 
-EGLCore::EGLCore() : m_display(EGL_NO_DISPLAY), m_context(EGL_NO_CONTEXT), m_surface(EGL_NO_SURFACE) {}
+namespace OCCTRenderer {
+
+EGLCore::EGLCore() 
+    : eglDisplay_(EGL_NO_DISPLAY), 
+      eglContext_(EGL_NO_CONTEXT), 
+      eglSurface_(EGL_NO_SURFACE),
+      nativeWindow_(nullptr) {}
 
 EGLCore::~EGLCore() {
-    release();
+    destroy();
 }
 
-bool EGLCore::init(EGLNativeWindowType window) {
+bool EGLCore::init(OHNativeWindow* window) {
-    m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if (!window) {
-    if (m_display == EGL_NO_DISPLAY) return false;
+        printf("Native window is null\n");
-
+        return false;
-    if (!eglInitialize(m_display, nullptr, nullptr)) return false;
+    }
-
+    
-    const EGLint attribs[] = {
+    nativeWindow_ = window;
-        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
+    
+    // 获取EGL display
+    eglDisplay_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if (eglDisplay_ == EGL_NO_DISPLAY) {
+        printf("eglGetDisplay failed\n");
+        return false;
+    }
+    
+    // 初始化EGL
+    if (!eglInitialize(eglDisplay_, nullptr, nullptr)) {
+        printf("eglInitialize failed\n");
+        return false;
+    }
+    
+    // 配置EGL
+    EGLint attribs[] = {
         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
         EGL_BLUE_SIZE, 8,
         EGL_GREEN_SIZE, 8,
         EGL_RED_SIZE, 8,
         EGL_ALPHA_SIZE, 8,
         EGL_DEPTH_SIZE, 16,
+        EGL_STENCIL_SIZE, 0,
         EGL_NONE
     };
-
+    
-    EGLConfig config;
     EGLint numConfigs;
-    eglChooseConfig(m_display, attribs, &config, 1, &numConfigs);
+    if (!eglChooseConfig(eglDisplay_, attribs, &eglConfig_, 1, &numConfigs) || numConfigs == 0) {
-
+        printf("eglChooseConfig failed\n");
-    const EGLint contextAttribs[] = {
+        return false;
+    }
+    
+    // 创建EGL surface
+    eglSurface_ = eglCreateWindowSurface(eglDisplay_, eglConfig_, (NativeWindowType)nativeWindow_, nullptr);
+    if (eglSurface_ == EGL_NO_SURFACE) {
+        printf("eglCreateWindowSurface failed: 0x%x\n", eglGetError());
+        return false;
+    }
+    
+    // 创建EGL context
+    EGLint contextAttribs[] = {
         EGL_CONTEXT_CLIENT_VERSION, 3,
         EGL_NONE
     };
-    m_context = eglCreateContext(m_display, config, EGL_NO_CONTEXT, contextAttribs);
+    
-    if (m_context == EGL_NO_CONTEXT) return false;
+    eglContext_ = eglCreateContext(eglDisplay_, eglConfig_, EGL_NO_CONTEXT, contextAttribs);
-
+    if (eglContext_ == EGL_NO_CONTEXT) {
-    m_surface = eglCreateWindowSurface(m_display, config, window, nullptr);
+        printf("eglCreateContext failed\n");
-    if (m_surface == EGL_NO_SURFACE) return false;
+        return false;
-
+    }
-    m_initialized = true;
+    
+    // 激活上下文
+    makeCurrent();
+    
+    // 检查GL错误
+    GLenum glError = glGetError();
+    if (glError != GL_NO_ERROR) {
+        printf("OpenGL error after initialization: 0x%x\n", glError);
+        return false;
+    }
+    
+    // 设置GL视口
+    glViewport(0, 0, 1280, 720); // 默认大小，实际会随窗口变化
+    
     return true;
 }
 
 void EGLCore::makeCurrent() {
-    if (m_initialized) {
+    if (!eglMakeCurrent(eglDisplay_, eglSurface_, eglSurface_, eglContext_)) {
-        eglMakeCurrent(m_display, m_surface, m_surface, m_context);
+        printf("eglMakeCurrent failed: 0x%x\n", eglGetError());
     }
 }
 
-void EGLCore::swapBuffers() {
+bool EGLCore::swapBuffers() {
-    if (m_initialized) {
+    return eglSwapBuffers(eglDisplay_, eglSurface_);
-        eglSwapBuffers(m_display, m_surface);
+}
+
+void EGLCore::destroy() {
+    if (eglDisplay_ != EGL_NO_DISPLAY) {
+        if (eglContext_ != EGL_NO_CONTEXT) {
+            eglDestroyContext(eglDisplay_, eglContext_);
+            eglContext_ = EGL_NO_CONTEXT;
+        }
+        
+        if (eglSurface_ != EGL_NO_SURFACE) {
+            eglDestroySurface(eglDisplay_, eglSurface_);
+            eglSurface_ = EGL_NO_SURFACE;
+        }
+        
+        eglTerminate(eglDisplay_);
+        eglDisplay_ = EGL_NO_DISPLAY;
     }
 }
 
-void EGLCore::release() {
+} // namespace OCCTRenderer
-    if (m_display != EGL_NO_DISPLAY) {
-        eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-        if (m_context != EGL_NO_CONTEXT) eglDestroyContext(m_display, m_context);
-        if (m_surface != EGL_NO_SURFACE) eglDestroySurface(m_display, m_surface);
-        eglTerminate(m_display);
-    }
-    m_display = EGL_NO_DISPLAY;
-    m_context = EGL_NO_CONTEXT;
-    m_surface = EGL_NO_SURFACE;
-    m_initialized = false;
-}

entry/src/main/cpp/EGLCore/EGLCore.h

@@ -7,23 +7,29 @@
 #ifndef EGLCORE_H
 #define EGLCORE_H
 #include <EGL/egl.h>
-#include <EGL/eglext.h>
+#include <GLES3/gl3.h>
+#include <native_window/external_window.h>
 
+namespace OCCTRenderer {
 class EGLCore {
 public:
     EGLCore();
     ~EGLCore();
 
-    bool init(EGLNativeWindowType window);
+    bool init(OHNativeWindow* window);
     void makeCurrent();
-    void swapBuffers();
+    bool swapBuffers();
-    void release();
+    void destroy();
+    EGLSurface getSurface() const { return eglSurface_; }
 
 private:
-    EGLDisplay m_display;
+    EGLDisplay eglDisplay_;
-    EGLContext m_context;
+    EGLContext eglContext_;
-    EGLSurface m_surface;
+    EGLSurface eglSurface_;
-    bool m_initialized = false;
+    EGLConfig eglConfig_;
+    OHNativeWindow* nativeWindow_;
 };
+} // namespace OCCTRenderer
+
 
 #endif // EGLCORE_H

entry/src/main/cpp/OCCTRender/OCCTRender.cpp

@@ -4,91 +4,282 @@
 // Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
 // please include "napi/native_api.h".
 #include "OCCTRender.h"
+#include <cstdio>
+#include <cmath>
+#include <OSD_Environment.hxx>
+#include <AIS_InteractiveObject.hxx>
+#include <Prs3d_Drawer.hxx>
+#include <Prs3d_ShadingAspect.hxx>
+#include <Graphic3d_MaterialAspect.hxx>
+#include <Graphic3d_NameOfMaterial.hxx>
+#include <BRepPrimAPI_MakeBox.hxx>
+#include <BRepPrimAPI_MakeSphere.hxx>
+#include <BRepPrimAPI_MakeCylinder.hxx>
+#include <Graphic3d_TextureEnv.hxx>
+#include <V3d_TypeOfOrientation.hxx>
+#include <Aspect_TypeOfTriedronPosition.hxx>
 
-#include <GLES3/gl3.h>          // ← 提供 glViewport, glClear 等
+namespace OCCTRenderer {
-#include <EGL/egl.h>
 
-// OCCT 基础
+OCCTRender::OCCTRender() 
-#include <TDocStd_Document.hxx>
+    : rotationX_(0.0f), 
-#include <TDF_Label.hxx>
+      rotationY_(0.0f), 
-#include <TDF_LabelSequence.hxx>
+      zoomLevel_(1.0f), 
-
+      width_(0), 
-// XCAF 应用框架
+      height_(0), 
-#include <XCAFApp_Application.hxx>
+      clearColor_(Quantity_NOC_BLACK),
-#include <XCAFDoc_DocumentTool.hxx>   // ← 解决当前错误
+      translationX_(0.0f),
-#include <XCAFDoc_ShapeTool.hxx>      // ← 配套使用
+      translationY_(0.0f)
-
-// STEP 导入
-#include <STEPCAFControl_Reader.hxx>
-#include <IFSelect_ReturnStatus.hxx>
-
-// 可视化
-#include <AIS_Shape.hxx>
-#include <AIS_InteractiveContext.hxx>
-#include <V3d_View.hxx>
-
-OCCTRender::OCCTRender(int width, int height)
-    : m_width(width), m_height(height)
 {
-    // 创建一个“虚拟”的 DisplayConnection（HarmonyOS 无 X11/Wayland）
+    setupViewer();
-    Handle(Aspect_DisplayConnection) aDispConnection;
+    setupContext();
-
+    setupView();
-    // 关键：设置 OpenGl_GraphicDriver 复用当前 OpenGL context
-    // 第二个参数 'theIsOwnsContext' 设为 false，表示不创建新 context
-    Handle(OpenGl_GraphicDriver) aDriver = new OpenGl_GraphicDriver(aDispConnection, false);
-
-    m_viewer = new V3d_Viewer(aDriver);
-    m_view = m_viewer->CreateView();
-    m_context = new AIS_InteractiveContext(m_viewer);
-
-    m_view->SetBackgroundColor(Quantity_NOC_BLACK);
-    m_view->Camera()->SetProjectionType(Graphic3d_Camera::Projection_Perspective);
-    m_view->SetImmediateUpdate(false); // 禁用自动 redraw/swap
 }
+
 OCCTRender::~OCCTRender() {
-    // OCCT 对象由 Handle 自动管理，通常无需手动 delete
+    shapes_.clear();
 }
-void OCCTRender::render()
-{
-    if (m_width <= 0 || m_height <= 0) return;
 
-    // 设置 OpenGL viewport（由 EGLCore 控制 surface，此处仅设置视口）
+bool OCCTRender::init(int width, int height) {
-    glViewport(0, 0, m_width, m_height);
+    width_ = width;
-
+    height_ = height;
-    // 更新相机宽高比
+    if (view_.IsNull()) {
-    m_view->Camera()->SetAspect(static_cast<Standard_Real>(m_width) / m_height);
+        return false;
-
+    }
-    // 让 OCCT 渲染到当前 OpenGL context 的 default framebuffer
+    
-    m_view->Redraw();
+    view_->SetBackgroundColor(clearColor_);
-    // 注意：不要调用 RedrawImmediate()，也不要 swap buffer（由 EGLCore 负责）
+    view_->MustBeResized();
+    view_->Redraw();
+    return true;
 }
-void OCCTRender::loadModel(const char* stepPath) {
-    m_context->RemoveAll(false);
 
-    auto app = XCAFApp_Application::GetApplication();
+void OCCTRender::setupViewer() {
-    m_doc = new TDocStd_Document("XmlXCAF"); // ← 关键修改
+    Handle(Aspect_DisplayConnection) displayConnection;
-    app->NewDocument("XmlXCAF", m_doc);      // ← 保持一致
+    
+    // 创建图形驱动
+    static Handle(OpenGl_GraphicDriver) graphicDriver;
+    if (graphicDriver.IsNull()) {
+        graphicDriver = new OpenGl_GraphicDriver(displayConnection, Standard_False);
+        graphicDriver->ChangeOptions().buffersNoSwap = Standard_True;
+    }
+    graphicDriver_ = graphicDriver;
+    
+    // 创建V3d_Viewer
+    viewer_ = new V3d_Viewer(graphicDriver_);
+    viewer_->SetDefaultLights();
+    viewer_->SetLightOn();
+}
 
-    STEPCAFControl_Reader reader;
+void OCCTRender::setupContext() {
-    IFSelect_ReturnStatus status = reader.ReadFile(stepPath);
+    context_ = new AIS_InteractiveContext(viewer_);
-    if (status == IFSelect_RetDone) {
+    context_->SetDisplayMode(AIS_Shaded, Standard_False); // 默认使用着色模式
-        reader.Transfer(m_doc);
+}
-        Handle(XCAFDoc_ShapeTool) shapeTool = XCAFDoc_DocumentTool::ShapeTool(m_doc->Main());
+
-        if (!shapeTool.IsNull()) {
+void OCCTRender::setupView() {
-            TDF_LabelSequence labels;
+    view_ = viewer_->CreateView();
-            shapeTool->GetFreeShapes(labels);
+    
-            for (Standard_Integer i = 1; i <= labels.Length(); ++i) {
+    // 设置渲染参数
-                TopoDS_Shape shape;
+    view_->ChangeRenderingParams().Method = Graphic3d_RM_RASTERIZATION;
-                if (shapeTool->GetShape(labels.Value(i), shape)) {
+    view_->ChangeRenderingParams().IsShadowEnabled = Standard_False;
-                    Handle(AIS_Shape) aisShape = new AIS_Shape(shape);
+    view_->ChangeRenderingParams().IsReflectionEnabled = Standard_False;
-                    m_context->Display(aisShape, false);
+    view_->ChangeRenderingParams().IsAntialiasingEnabled = Standard_True;
-                }
+    view_->ChangeRenderingParams().Resolution = 2;
+    
+    // 设置背景渐变
+    view_->SetBgGradientColors(
+        Quantity_Color(Quantity_NOC_GRAY),
+        Quantity_Color(Quantity_NOC_BLACK),
+        Aspect_GFM_VER, // 垂直渐变
+        Standard_False
+    );
+    
+    // 设置默认相机位置
+    view_->SetProj(V3d_XposYnegZpos);
+    
+    // 设置相机参数
+    Handle(Graphic3d_Camera) camera = view_->Camera();
+    camera->SetFOVy(45.0); // 使用正确的FOV设置API
+    camera->SetZRange(1.0, 10000.0);
+}
+
+bool OCCTRender::loadModel(const std::string& filePath) {
+    // 清除现有模型
+    for (auto& shape : shapes_) {
+        context_->Remove(shape, Standard_False);
+    }
+    shapes_.clear();
+    
+    // 加载STEP文件
+    STEPControl_Reader reader;
+    IFSelect_ReturnStatus status = reader.ReadFile(filePath.c_str());
+    if (status != IFSelect_RetDone) {
+        printf("Error: Failed to read STEP file: %s\n", filePath.c_str());
+        loadDefaultModel();
+        return false;
+    }
+    
+    // 将文件内容转换为OCCT形状
+    reader.TransferRoots();
+    int numShapes = reader.NbShapes();
+    if (numShapes <= 0) {
+        printf("Error: No shapes found in STEP file\n");
+        loadDefaultModel();
+        return false;
+    }
+    
+    // 加载所有形状
+    for (Standard_Integer i = 1; i <= numShapes; i++) {
+        TopoDS_Shape shape = reader.Shape(i);
+        if (!shape.IsNull()) {
+            Handle(AIS_Shape) aisShape = new AIS_Shape(shape);
+            
+            // 设置材质
+            Handle(Prs3d_Drawer) drawer = aisShape->Attributes();
+            Handle(Prs3d_ShadingAspect) shadingAspect = new Prs3d_ShadingAspect();
+            
+            // 随机颜色
+            int colorIndex = i % 7;
+            Quantity_Color color;
+            switch (colorIndex) {
+                case 0: color = Quantity_NOC_RED; break;
+                case 1: color = Quantity_NOC_GREEN; break;
+                case 2: color = Quantity_NOC_BLUE1; break;
+                case 3: color = Quantity_NOC_YELLOW; break;
+                case 4: color = Quantity_NOC_MAGENTA1; break;
+                case 5: color = Quantity_NOC_CYAN1; break;
+                case 6: color = Quantity_NOC_ORANGE; break;
+                default: color = Quantity_NOC_WHITE;
             }
+            
+            shadingAspect->SetColor(color);
+            shadingAspect->SetMaterial(Graphic3d_NOM_PLASTIC);
+            drawer->SetShadingAspect(shadingAspect);
+            
+            context_->Display(aisShape, Standard_True);
+            shapes_.push_back(aisShape);
         }
     }
-    m_view->FitAll();
+    
+    // 调整相机到合适位置
+    view_->FitAll(0.05, Standard_True);
+    view_->ZFitAll();
+    printf("Successfully loaded STEP file with %d shapes\n", numShapes);
+    return true;
 }
 
-void OCCTRender::rotateCamera(float deltaX, float deltaY) {
+void OCCTRender::loadDefaultModel() {
-    m_view->Rotate(deltaX * 0.01f, deltaY * 0.01f, 0.0f, true); // 相对旋转
+    // 创建一个默认的3D立方体
-}
+    TopoDS_Shape box = BRepPrimAPI_MakeBox(10.0, 10.0, 10.0).Shape();
+    Handle(AIS_Shape) aisBox = new AIS_Shape(box);
+    
+    // 设置材质和颜色
+    Handle(Prs3d_Drawer) drawer = aisBox->Attributes();
+    Handle(Prs3d_ShadingAspect) shadingAspect = new Prs3d_ShadingAspect();
+    shadingAspect->SetColor(Quantity_NOC_RED);
+    shadingAspect->SetMaterial(Graphic3d_NOM_PLASTIC);
+    drawer->SetShadingAspect(shadingAspect);
+    
+    context_->Display(aisBox, Standard_True);
+    shapes_.push_back(aisBox);
+    
+    // 创建一个球体
+    TopoDS_Shape sphere = BRepPrimAPI_MakeSphere(gp_Pnt(20.0, 0.0, 0.0), 5.0).Shape();
+    Handle(AIS_Shape) aisSphere = new AIS_Shape(sphere);
+    shadingAspect = new Prs3d_ShadingAspect();
+    shadingAspect->SetColor(Quantity_NOC_BLUE1);
+    shadingAspect->SetMaterial(Graphic3d_NOM_PLASTIC);
+    aisSphere->Attributes()->SetShadingAspect(shadingAspect);
+    context_->Display(aisSphere, Standard_True);
+    shapes_.push_back(aisSphere);
+    
+    // 创建一个圆柱体
+    TopoDS_Shape cylinder = BRepPrimAPI_MakeCylinder(3.0, 15.0).Shape();
+    Handle(AIS_Shape) aisCylinder = new AIS_Shape(cylinder);
+    shadingAspect = new Prs3d_ShadingAspect();
+    shadingAspect->SetColor(Quantity_NOC_GREEN);
+    shadingAspect->SetMaterial(Graphic3d_NOM_PLASTIC);
+    aisCylinder->Attributes()->SetShadingAspect(shadingAspect);
+    
+    gp_Trsf transform;
+    transform.SetTranslation(gp_Vec(-15.0, -15.0, 0.0));
+    aisCylinder->SetLocalTransformation(transform);
+    
+    context_->Display(aisCylinder, Standard_True);
+    shapes_.push_back(aisCylinder);
+    
+    // 调整相机
+    view_->FitAll(0.05, Standard_True);
+    view_->ZFitAll();
+    printf("Loaded default model (cube, sphere, cylinder)\n");
+}
+
+//setTranslation
+void OCCTRender::setTranslation(float x, float y) {
+    translationX_ = x;
+    translationY_ = y;
+}
+
+void OCCTRender::render() {
+    if (view_.IsNull()) {
+        return;
+    }
+    
+    // 应用旋转
+    Handle(Graphic3d_Camera) camera = view_->Camera();
+    // 计算旋转
+    gp_Quaternion rotation;
+    rotation.SetEulerAngles(gp_EulerSequence::gp_Extrinsic_XYZ, 
+                           rotationX_ * M_PI / 180.0, 
+                           rotationY_ * M_PI / 180.0, 
+                           0.0);
+    
+    // 计算相机位置
+    gp_Dir camDir(0.0, 1.0, 0.0);
+    gp_Vec camVec = rotation * gp_Vec(camDir);
+    gp_Pnt camPos = gp_Pnt(0.0, 0.0, 0.0).Translated(camVec.Reversed() * 50.0 * zoomLevel_);
+    
+    // 设置相机参数
+    camera->SetEye(camPos);
+    camera->SetCenter(gp_Pnt(translationX_, translationY_, 0.0));
+    camera->SetUp(gp_Dir(0.0, 0.0, 1.0));
+    // 执行渲染
+    view_->Redraw();
+}
+
+void OCCTRender::resize(int width, int height) {
+    width_ = width;
+    height_ = height;
+    if (!view_.IsNull() && nativeWindow_ != nullptr) {
+        view_->SetWindow(nativeWindow_);
+        view_->MustBeResized();
+    }
+}
+
+void OCCTRender::setRotation(float xAngle, float yAngle) {
+    rotationX_ = xAngle;
+    rotationY_ = yAngle;
+}
+
+void OCCTRender::setZoomLevel(float zoom) {
+    zoomLevel_ = std::max(0.1f, std::min(zoom, 5.0f)); // 限制缩放范围
+}
+
+void OCCTRender::resetView() {
+    rotationX_ = 0.0f;
+    rotationY_ = 0.0f;
+    zoomLevel_ = 1.0f;
+    
+    if (!view_.IsNull()) {
+        view_->SetProj(V3d_XposYnegZpos);
+        view_->FitAll(0.05, Standard_False);
+    }
+}
+
+void OCCTRender::setClearColor(float r, float g, float b, float a) {
+    clearColor_ = Quantity_Color(r, g, b, Quantity_TOC_RGB);
+    if (!view_.IsNull()) {
+        view_->SetBackgroundColor(clearColor_);
+    }
+}
+
+} // namespace OCCTRenderer

entry/src/main/cpp/OCCTRender/OCCTRender.h

@@ -12,33 +12,64 @@
 #ifndef OCCT_RENDER_H
 #define OCCT_RENDER_H
 
-#include <Graphic3d_GraphicDriver.hxx>
+#include <string>
+#include <vector>
+#include <Standard_Handle.hxx>
+#include <AIS_InteractiveContext.hxx>
 #include <V3d_View.hxx>
 #include <V3d_Viewer.hxx>
-#include <AIS_InteractiveContext.hxx>
 #include <OpenGl_GraphicDriver.hxx>
-#include <XCAFApp_Application.hxx>
-#include <STEPCAFControl_Reader.hxx>
-#include <TDocStd_Document.hxx>
-#include <XCAFDoc_ShapeTool.hxx>
 #include <AIS_Shape.hxx>
+#include <STEPControl_Reader.hxx>
+#include <TopoDS_Shape.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
+#include <Aspect_DisplayConnection.hxx>
+#include <Message.hxx>
+#include <Quantity_Color.hxx>
+#include <gp_Quaternion.hxx>
+#include <gp_EulerSequence.hxx>
 
+class Aspect_Window;
+class gp_Quaternion;
+class Graphic3d_Camera;
+
+namespace OCCTRenderer {
 class OCCTRender {
 public:
-    OCCTRender(int width, int height); // 保持接口不变
+    OCCTRender();
     ~OCCTRender();
-    void loadModel(const char* stepPath);
+    
+    bool init(int width, int height);
+    bool loadModel(const std::string& filePath);
     void render();
-    void updateSize(int width, int height);
+    void resize(int width, int height);
-    void rotateCamera(float deltaX, float deltaY);
+    void setRotation(float xAngle, float yAngle);
+    void resetView();
+    void setClearColor(float r, float g, float b, float a);
+    void setZoomLevel(float zoom);
+    void setTranslation(float x, float y);
 
 private:
-    Handle(V3d_Viewer) m_viewer;
+    void setupViewer();
-    Handle(V3d_View) m_view;
+    void setupContext();
-    Handle(AIS_InteractiveContext) m_context;
+    void setupView();
-    Handle(TDocStd_Document) m_doc;
+    void loadDefaultModel();
-    int m_width;
+    
-    int m_height;
+    Handle(OpenGl_GraphicDriver) graphicDriver_;
+    Handle(V3d_Viewer) viewer_;
+    Handle(V3d_View) view_;
+    Handle(AIS_InteractiveContext) context_;
+    std::vector<Handle(AIS_Shape)> shapes_;
+    
+    float rotationX_;
+    float rotationY_;
+    float zoomLevel_;
+    int width_;
+    int height_;
+    float translationX_;
+    float translationY_;
+    Quantity_Color clearColor_;
+    Aspect_Window* nativeWindow_;
 };
-
+} // namespace OCCTRenderer
 #endif // OCCT_RENDER_H

entry/src/main/cpp/OCCTRenderThread/OCCTRenderThread.cpp

@@ -5,69 +5,192 @@
 // please include "napi/native_api.h".
 
 #include "OCCTRenderThread.h"
-#include <unistd.h> // for usleep
+#include <cstdio>
+#include <unistd.h>
 
-OCCTRenderThread::OCCTRenderThread(EGLNativeWindowType window, int width, int height)
+namespace OCCTRenderer {
-    : m_window(window), m_width(width), m_height(height) {}
+
+OCCTRenderThread::OCCTRenderThread() 
+    : isRunning_(false), 
+      nativeWindow_(nullptr),
+      windowWidth_(1280),
+      windowHeight_(720) {}
 
 OCCTRenderThread::~OCCTRenderThread() {
     stop();
-    delete m_occtRender;
 }
 
-void OCCTRenderThread::start() {
+bool OCCTRenderThread::start(OHNativeWindow* window) {
-    m_running = true;
+    if (isRunning_) {
-    m_thread = std::thread(&OCCTRenderThread::renderLoop, this);
+        return true;
+    }
+    
+    nativeWindow_ = window;
+    
+    // 初始化EGL
+    if (!eglCore_.init(nativeWindow_)) {
+        printf("Failed to initialize EGL\n");
+        return false;
+    }
+    
+    // 初始化OCCT渲染器
+    if (!renderer_.init(windowWidth_, windowHeight_)) {
+        printf("Failed to initialize OCCT renderer\n");
+        eglCore_.destroy();
+        return false;
+    }
+    
+    isRunning_ = true;
+    renderThread_ = std::thread(&OCCTRenderThread::renderLoop, this);
+    
+    return true;
 }
 
 void OCCTRenderThread::stop() {
-    m_running = false;
+    if (!isRunning_) {
-    if (m_thread.joinable()) {
+        return;
-        m_thread.join();
     }
-}
+    
-
+    isRunning_ = false;
-void OCCTRenderThread::loadModel(const char* path) {
+    
-    std::lock_guard<std::mutex> lock(m_mutex);
+    {
-    m_pendingModelPath = std::string(path);
+        std::lock_guard<std::mutex> lock(commandMutex_);
-    m_hasPendingModel = true;
+        commandQueue_.push(RenderCommand(CMD_EXIT));
-}
+    }
-
+    commandCondition_.notify_one();
-void OCCTRenderThread::onMouseEvent(float dx, float dy) {
+    
-    m_deltaX += dx;
+    if (renderThread_.joinable()) {
-    m_deltaY += dy;
+        renderThread_.join();
-    m_hasMouseInput = true;
+    }
+    
+    eglCore_.destroy();
 }
 
 void OCCTRenderThread::renderLoop() {
-    if (!m_eglCore.init(m_window)) {
+    while (isRunning_) {
-        return;
+        RenderCommand command;
-    }
+        bool hasCommand = false;
-    m_occtRender = new OCCTRender(m_width, m_height);
+        
-
+        {
-    while (m_running) {
+            std::unique_lock<std::mutex> lock(commandMutex_);
-        m_eglCore.makeCurrent();
+            commandCondition_.wait_for(lock, std::chrono::milliseconds(16), [this] {
-
+                return !commandQueue_.empty();
-        // Handle model loading
+            });
-        if (m_hasPendingModel) {
+            
-            std::lock_guard<std::mutex> lock(m_mutex);
+            if (!commandQueue_.empty()) {
-            m_occtRender->loadModel(m_pendingModelPath.c_str());
+                command = commandQueue_.front();
-            m_hasPendingModel = false;
+                commandQueue_.pop();
+                hasCommand = true;
+            }
         }
-
+        
-        // Handle mouse rotation
+        if (hasCommand) {
-        if (m_hasMouseInput.exchange(false)) {
+            switch (command.type) {
-            m_occtRender->rotateCamera(m_deltaX, m_deltaY);
+                case CMD_LOAD_MODEL:
-            m_deltaX = m_deltaY = 0.0f;
+                    renderer_.loadModel(command.param1);
+                    break;
+                case CMD_SET_ROTATION:
+                    renderer_.setRotation(command.param2, command.param3);
+                    break;
+                case CMD_SET_TRANSLATION:
+                    renderer_.setTranslation(command.param2, command.param3);
+                    break;
+                case CMD_RESET_VIEW:
+                    renderer_.resetView();
+                    break;
+                case CMD_SET_CLEAR_COLOR:
+                    renderer_.setClearColor(command.param2, command.param3, command.param4, command.param5);
+                    break;
+                case CMD_RESIZE:
+                    windowWidth_ = static_cast<int>(command.param2);
+                    windowHeight_ = static_cast<int>(command.param3);
+                    renderer_.resize(windowWidth_, windowHeight_);
+                    break;
+                case CMD_EXIT:
+                    isRunning_ = false;
+                    break;
+            }
         }
-
+        
-        m_occtRender->render();
+        if (!isRunning_) {
-        m_eglCore.swapBuffers();
+            break;
-
+        }
+        
+        // 渲染
+        eglCore_.makeCurrent();
+        renderer_.render();
+        eglCore_.swapBuffers();
+        
+        // 调用渲染完成回调
+        Callback callback;
+        {
+            std::lock_guard<std::mutex> lock(callbackMutex_);
+            callback = renderCompleteCallback_;
+        }
+        
+        if (callback) {
+            callback();
+        }
+        
+        // 控制帧率
         usleep(16000); // ~60 FPS
     }
+}
 
-    delete m_occtRender;
+void OCCTRenderThread::loadModel(const std::string& filePath) {
-    m_occtRender = nullptr;
+    std::lock_guard<std::mutex> lock(commandMutex_);
-    m_eglCore.release();
+    RenderCommand cmd(CMD_LOAD_MODEL);
-}
+    cmd.param1 = filePath;
+    commandQueue_.push(cmd);
+    commandCondition_.notify_one();
+}
+
+void OCCTRenderThread::setRotation(float xAngle, float yAngle) {
+    std::lock_guard<std::mutex> lock(commandMutex_);
+    RenderCommand cmd(CMD_SET_ROTATION);
+    cmd.param2 = xAngle;
+    cmd.param3 = yAngle;
+    commandQueue_.push(cmd);
+    commandCondition_.notify_one();
+}
+
+void OCCTRenderThread::setTranslation(float x, float y) {
+    std::lock_guard<std::mutex> lock(commandMutex_);
+    RenderCommand cmd(CMD_SET_TRANSLATION);
+    cmd.param2 = x;
+    cmd.param3 = y;
+    commandQueue_.push(cmd);
+    commandCondition_.notify_one();
+}
+
+void OCCTRenderThread::resetView() {
+    std::lock_guard<std::mutex> lock(commandMutex_);
+    commandQueue_.push(RenderCommand(CMD_RESET_VIEW));
+    commandCondition_.notify_one();
+}
+
+void OCCTRenderThread::setClearColor(float r, float g, float b, float a) {
+    std::lock_guard<std::mutex> lock(commandMutex_);
+    RenderCommand cmd(CMD_SET_CLEAR_COLOR);
+    cmd.param2 = r;
+    cmd.param3 = g;
+    cmd.param4 = b;
+    cmd.param5 = a;
+    commandQueue_.push(cmd);
+    commandCondition_.notify_one();
+}
+
+void OCCTRenderThread::resizeWindow(int width, int height) {
+    std::lock_guard<std::mutex> lock(commandMutex_);
+    RenderCommand cmd(CMD_RESIZE);
+    cmd.param2 = static_cast<float>(width);
+    cmd.param3 = static_cast<float>(height);
+    commandQueue_.push(cmd);
+    commandCondition_.notify_one();
+}
+
+void OCCTRenderThread::registerRenderCompleteCallback(Callback callback) {
+    std::lock_guard<std::mutex> lock(callbackMutex_);
+    renderCompleteCallback_ = callback;
+}
+} // namespace OCCTRenderer

entry/src/main/cpp/OCCTRenderThread/OCCTRenderThread.h

@@ -6,40 +6,74 @@
 
 #ifndef OCCT_RENDER_THREAD_H
 #define OCCT_RENDER_THREAD_H
-
 #include <thread>
 #include <atomic>
 #include <mutex>
+#include <condition_variable>
+#include <queue>
+#include <functional>
+
 #include "EGLCore/EGLCore.h"
 #include "OCCTRender/OCCTRender.h"
 
+namespace OCCTRenderer {
+
 class OCCTRenderThread {
 public:
-    OCCTRenderThread(EGLNativeWindowType window, int width, int height);
+    OCCTRenderThread();
     ~OCCTRenderThread();
-
+    
-    void start();
+    bool start(OHNativeWindow* window);
     void stop();
-    void loadModel(const char* path);
+    
-    void onMouseEvent(float dx, float dy);
+    void loadModel(const std::string& filePath);
-
+    void setRotation(float xAngle, float yAngle);
+    void setTranslation(float x, float y);
+    void resetView();
+    void setClearColor(float r, float g, float b, float a);
+    void resizeWindow(int width, int height);
+    
+    using Callback = std::function<void()>;
+    void registerRenderCompleteCallback(Callback callback);
+    
 private:
     void renderLoop();
-
+    
-    std::thread m_thread;
+    std::thread renderThread_;
-    std::atomic<bool> m_running{false};
+    std::atomic<bool> isRunning_;
-    EGLNativeWindowType m_window;
+    
-    int m_width, m_height;
+    OHNativeWindow* nativeWindow_;
-
+    EGLCore eglCore_;
-    EGLCore m_eglCore;
+    OCCTRender renderer_;
-    OCCTRender* m_occtRender = nullptr;
+    
-
+    std::mutex commandMutex_;
-    std::mutex m_mutex;
+    std::condition_variable commandCondition_;
-    std::string m_pendingModelPath;
+    
-    std::atomic<bool> m_hasPendingModel{false};
+    enum CommandType {
-
+        CMD_LOAD_MODEL,
-    float m_deltaX = 0.0f, m_deltaY = 0.0f;
+        CMD_SET_ROTATION,
-    std::atomic<bool> m_hasMouseInput{false};
+        CMD_SET_TRANSLATION,
+        CMD_RESET_VIEW,
+        CMD_SET_CLEAR_COLOR,
+        CMD_RESIZE,
+        CMD_EXIT
+    };
+    
+    struct RenderCommand {
+    CommandType type;
+    std::string param1; // For file path
+    float param2, param3, param4, param5;
+    RenderCommand() : type(CMD_EXIT), param1(""), param2(0.0f), param3(0.0f), param4(0.0f), param5(0.0f) {}
+    RenderCommand(CommandType t) : type(t), param1(""), param2(0), param3(0), param4(0), param5(0) {}
 };
-
+    
+    std::queue<RenderCommand> commandQueue_;
+    
+    std::mutex callbackMutex_;
+    Callback renderCompleteCallback_;
+    
+    int windowWidth_;
+    int windowHeight_;
+};
+} // namespace OCCTRenderer
 #endif //OCCT_RENDER_THREAD_H

entry/src/main/cpp/include/curl/curlver.h

@@ -0,0 +1,78 @@
+#ifndef CURLINC_CURLVER_H
+#define CURLINC_CURLVER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+   a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "Daniel Stenberg, <daniel@haxx.se>."
+
+/* This is the version number of the libcurl package from which this header
+   file origins: */
+#define LIBCURL_VERSION "8.18.0"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBCURL_VERSION_MAJOR 8
+#define LIBCURL_VERSION_MINOR 18
+#define LIBCURL_VERSION_PATCH 0
+/* This is the numeric version of the libcurl version number, meant for easier
+   parsing and comparisons by programs. The LIBCURL_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits. 1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+
+   Note: This define is the full hex number and _does not_ use the
+   CURL_VERSION_BITS() macro since curl's own configure script greps for it
+   and needs it to contain the full number.
+*/
+#define LIBCURL_VERSION_NUM 0x081200
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date follows this template:
+ *
+ * "2007-11-23"
+ */
+#define LIBCURL_TIMESTAMP "[vcpkg]"
+
+#define CURL_VERSION_BITS(x, y, z) ((x) << 16 | (y) << 8 | (z))
+#define CURL_AT_LEAST_VERSION(x, y, z) \
+  (LIBCURL_VERSION_NUM >= CURL_VERSION_BITS(x, y, z))
+
+#endif /* CURLINC_CURLVER_H */

entry/src/main/cpp/include/curl/easy.h

@@ -0,0 +1,123 @@
+#ifndef CURLINC_EASY_H
+#define CURLINC_EASY_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Flag bits in the curl_blob struct: */
+#define CURL_BLOB_COPY   1 /* tell libcurl to copy the data */
+#define CURL_BLOB_NOCOPY 0 /* tell libcurl to NOT copy the data */
+
+struct curl_blob {
+  void *data;
+  size_t len;
+  unsigned int flags; /* bit 0 is defined, the rest are reserved and should be
+                         left zeroes */
+};
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function.
+ * The third argument MUST be pointing to the specific type of the used option
+ * which is documented in each man page of the option. The data pointed to
+ * will be filled in accordingly and can be relied upon only if the function
+ * returns CURLE_OK. This function is intended to get used *AFTER* a performed
+ * transfer, all results from this function are undefined until the transfer
+ * is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistent connections cannot
+ * be transferred. It is useful in multi-threaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL *curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a curl handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+                                    size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+                                    size_t buflen, size_t *n);
+
+/*
+ * NAME curl_easy_upkeep()
+ *
+ * DESCRIPTION
+ *
+ * Performs connection upkeep for the given session handle.
+ */
+CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

entry/src/main/cpp/include/curl/header.h

@@ -0,0 +1,74 @@
+#ifndef CURLINC_HEADER_H
+#define CURLINC_HEADER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct curl_header {
+  char *name;    /* this might not use the same case */
+  char *value;
+  size_t amount; /* number of headers using this name  */
+  size_t index;  /* ... of this instance, 0 or higher */
+  unsigned int origin; /* see bits below */
+  void *anchor; /* handle privately used by libcurl */
+};
+
+/* 'origin' bits */
+#define CURLH_HEADER    (1 << 0) /* plain server header */
+#define CURLH_TRAILER   (1 << 1) /* trailers */
+#define CURLH_CONNECT   (1 << 2) /* CONNECT headers */
+#define CURLH_1XX       (1 << 3) /* 1xx headers */
+#define CURLH_PSEUDO    (1 << 4) /* pseudo headers */
+
+typedef enum {
+  CURLHE_OK,
+  CURLHE_BADINDEX,      /* header exists but not with this index */
+  CURLHE_MISSING,       /* no such header exists */
+  CURLHE_NOHEADERS,     /* no headers at all exist (yet) */
+  CURLHE_NOREQUEST,     /* no request with this number was used */
+  CURLHE_OUT_OF_MEMORY, /* out of memory while processing */
+  CURLHE_BAD_ARGUMENT,  /* a function argument was not okay */
+  CURLHE_NOT_BUILT_IN   /* if API was disabled in the build */
+} CURLHcode;
+
+CURL_EXTERN CURLHcode curl_easy_header(CURL *easy,
+                                       const char *name,
+                                       size_t index,
+                                       unsigned int origin,
+                                       int request,
+                                       struct curl_header **hout);
+
+CURL_EXTERN struct curl_header *curl_easy_nextheader(CURL *easy,
+                                                     unsigned int origin,
+                                                     int request,
+                                                     struct curl_header *prev);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_HEADER_H */

entry/src/main/cpp/include/curl/mprintf.h

@@ -0,0 +1,85 @@
+#ifndef CURLINC_MPRINTF_H
+#define CURLINC_MPRINTF_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
+#include "curl.h"  /* for CURL_EXTERN */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CURL_TEMP_PRINTF
+#if (defined(__GNUC__) || defined(__clang__) ||                         \
+  defined(__IAR_SYSTEMS_ICC__)) &&                                      \
+  defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) &&         \
+  !defined(CURL_NO_FMT_CHECKS)
+#if defined(__MINGW32__) && !defined(__clang__)
+#ifdef __MINGW_PRINTF_FORMAT  /* mingw-w64 3.0.0+. Needs stdio.h. */
+#define CURL_TEMP_PRINTF(fmt, arg) \
+  __attribute__((format(__MINGW_PRINTF_FORMAT, fmt, arg)))
+#else
+#define CURL_TEMP_PRINTF(fmt, arg)
+#endif
+#else
+#define CURL_TEMP_PRINTF(fmt, arg) \
+  __attribute__((format(printf, fmt, arg)))
+#endif
+#else
+#define CURL_TEMP_PRINTF(fmt, arg)
+#endif
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...)
+  CURL_TEMP_PRINTF(1, 2);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...)
+  CURL_TEMP_PRINTF(2, 3);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...)
+  CURL_TEMP_PRINTF(2, 3);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+                               const char *format, ...)
+  CURL_TEMP_PRINTF(3, 4);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args)
+  CURL_TEMP_PRINTF(1, 0);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args)
+  CURL_TEMP_PRINTF(2, 0);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args)
+  CURL_TEMP_PRINTF(2, 0);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+                                const char *format, va_list args)
+  CURL_TEMP_PRINTF(3, 0);
+CURL_EXTERN char *curl_maprintf(const char *format, ...)
+  CURL_TEMP_PRINTF(1, 2);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args)
+  CURL_TEMP_PRINTF(1, 0);
+
+#undef CURL_TEMP_PRINTF
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_MPRINTF_H */

entry/src/main/cpp/include/curl/multi.h

@@ -0,0 +1,551 @@
+#ifndef CURLINC_MULTI_H
+#define CURLINC_MULTI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+/*
+  This is an "external" header file. Do not give away any internals here!
+
+  GOALS
+
+  o Enable a "pull" interface. The application that uses libcurl decides where
+    and when to ask libcurl to get/send data.
+
+  o Enable multiple simultaneous transfers in the same thread without making it
+    complicated for the application.
+
+  o Enable the application to select() on its own file descriptors and curl's
+    file descriptors simultaneous easily.
+
+*/
+
+/*
+ * This header file should not really need to include "curl.h" since curl.h
+ * itself includes this file and we expect user applications to do #include
+ * <curl/curl.h> without the need for especially including multi.h.
+ *
+ * For some reason we added this include here at one point, and rather than to
+ * break existing (wrongly written) libcurl applications, we leave it as-is
+ * but with this warning attached.
+ */
+#include "curl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void CURLM;
+
+typedef enum {
+  CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
+                                    curl_multi_socket*() soon */
+  CURLM_OK,
+  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
+  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you are in deep sh*t */
+  CURLM_INTERNAL_ERROR,  /* this is a libcurl bug */
+  CURLM_BAD_SOCKET,      /* the passed in socket argument did not match */
+  CURLM_UNKNOWN_OPTION,  /* curl_multi_setopt() with unsupported option */
+  CURLM_ADDED_ALREADY,   /* an easy handle already added to a multi handle was
+                            attempted to get added - again */
+  CURLM_RECURSIVE_API_CALL, /* an api function was called from inside a
+                               callback */
+  CURLM_WAKEUP_FAILURE,  /* wakeup is unavailable or failed */
+  CURLM_BAD_FUNCTION_ARGUMENT, /* function called with a bad parameter */
+  CURLM_ABORTED_BY_CALLBACK,
+  CURLM_UNRECOVERABLE_POLL,
+  CURLM_LAST
+} CURLMcode;
+
+/* just to make code nicer when using curl_multi_socket() you can now check
+   for CURLM_CALL_MULTI_SOCKET too in the same style it works for
+   curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
+#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
+
+/* bitmask bits for CURLMOPT_PIPELINING */
+#define CURLPIPE_NOTHING   0L
+#define CURLPIPE_HTTP1     1L
+#define CURLPIPE_MULTIPLEX 2L
+
+typedef enum {
+  CURLMSG_NONE, /* first, not used */
+  CURLMSG_DONE, /* This easy handle has completed. 'result' contains
+                   the CURLcode of the transfer */
+  CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+  CURLMSG msg;       /* what this message means */
+  CURL *easy_handle; /* the handle it concerns */
+  union {
+    void *whatever;    /* message-specific data */
+    CURLcode result;   /* return code for transfer */
+  } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/* Based on poll(2) structure and values.
+ * We do not use pollfd and POLL* constants explicitly
+ * to cover platforms without poll(). */
+#define CURL_WAIT_POLLIN    0x0001
+#define CURL_WAIT_POLLPRI   0x0002
+#define CURL_WAIT_POLLOUT   0x0004
+
+struct curl_waitfd {
+  curl_socket_t fd;
+  short events;
+  short revents;
+};
+
+/*
+ * Name:    curl_multi_init()
+ *
+ * Desc:    initialize multi-style curl usage
+ *
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURL_EXTERN CURLM *curl_multi_init(void);
+
+/*
+ * Name:    curl_multi_add_handle()
+ *
+ * Desc:    add a standard curl handle to the multi stack
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                            CURL *curl_handle);
+
+/*
+ * Name:    curl_multi_remove_handle()
+ *
+ * Desc:    removes a curl handle from the multi stack again
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                               CURL *curl_handle);
+
+/*
+ * Name:    curl_multi_fdset()
+ *
+ * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
+ *          poll() on. We want curl_multi_perform() called as soon as one of
+ *          them are ready.
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                                       fd_set *read_fd_set,
+                                       fd_set *write_fd_set,
+                                       fd_set *exc_fd_set,
+                                       int *max_fd);
+
+/*
+ * Name:     curl_multi_wait()
+ *
+ * Desc:     Poll on all fds within a CURLM set as well as any
+ *           additional fds passed to the function.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_wait(CURLM *multi_handle,
+                                      struct curl_waitfd extra_fds[],
+                                      unsigned int extra_nfds,
+                                      int timeout_ms,
+                                      int *ret);
+
+/*
+ * Name:     curl_multi_poll()
+ *
+ * Desc:     Poll on all fds within a CURLM set as well as any
+ *           additional fds passed to the function.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_poll(CURLM *multi_handle,
+                                      struct curl_waitfd extra_fds[],
+                                      unsigned int extra_nfds,
+                                      int timeout_ms,
+                                      int *ret);
+
+/*
+ * Name:     curl_multi_wakeup()
+ *
+ * Desc:     wakes up a sleeping curl_multi_poll call.
+ *
+ * Returns:  CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_wakeup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_perform()
+ *
+ * Desc:    When the app thinks there is data available for curl it calls this
+ *          function to read/write whatever there is right now. This returns
+ *          as soon as the reads and writes are done. This function does not
+ *          require that there actually is data available for reading or that
+ *          data can be written, it can be called just in case. It returns
+ *          the number of handles that still transfer data in the second
+ *          argument's integer-pointer.
+ *
+ * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+ *          returns errors etc regarding the whole multi stack. There might
+ *          still have occurred problems on individual transfers even when
+ *          this returns OK.
+ */
+CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
+                                         int *running_handles);
+
+/*
+ * Name:    curl_multi_cleanup()
+ *
+ * Desc:    Cleans up and removes a whole multi stack. It does not free or
+ *          touch any individual easy handles in any way. We need to define
+ *          in what state those handles will be if this function is called
+ *          in the middle of a transfer.
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_info_read()
+ *
+ * Desc:    Ask the multi handle if there is any messages/informationals from
+ *          the individual transfers. Messages include informationals such as
+ *          error code from the transfer or just the fact that a transfer is
+ *          completed. More details on these should be written down as well.
+ *
+ *          Repeated calls to this function will return a new struct each
+ *          time, until a special "end of msgs" struct is returned as a signal
+ *          that there is no more to get at this point.
+ *
+ *          The data the returned pointer points to will not survive calling
+ *          curl_multi_cleanup().
+ *
+ *          The 'CURLMsg' struct is meant to be simple and only contain basic
+ *          information. If more involved information is wanted, we will
+ *          provide the particular "transfer handle" in that struct and that
+ *          should/could/would be used in subsequent curl_easy_getinfo() calls
+ *          (or similar). The point being that we must never expose complex
+ *          structs to applications, as then we will undoubtably get backwards
+ *          compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ *          of structs. It also writes the number of messages left in the
+ *          queue (after this read) in the integer the second argument points
+ *          to.
+ */
+CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+                                          int *msgs_in_queue);
+
+/*
+ * Name:    curl_multi_strerror()
+ *
+ * Desc:    The curl_multi_strerror function may be used to turn a CURLMcode
+ *          value into the equivalent human readable error string. This is
+ *          useful for printing meaningful error messages.
+ *
+ * Returns: A pointer to a null-terminated error message.
+ */
+CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
+
+/*
+ * Name:    curl_multi_socket() and
+ *          curl_multi_socket_all()
+ *
+ * Desc:    An alternative version of curl_multi_perform() that allows the
+ *          application to pass in one of the file descriptors that have been
+ *          detected to have "action" on them and let libcurl perform.
+ *          See man page for details.
+ */
+#define CURL_POLL_NONE   0
+#define CURL_POLL_IN     1
+#define CURL_POLL_OUT    2
+#define CURL_POLL_INOUT  3
+#define CURL_POLL_REMOVE 4
+
+#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
+
+#define CURL_CSELECT_IN   0x01
+#define CURL_CSELECT_OUT  0x02
+#define CURL_CSELECT_ERR  0x04
+
+typedef int (*curl_socket_callback)(CURL *easy,      /* easy handle */
+                                    curl_socket_t s, /* socket */
+                                    int what,        /* see above */
+                                    void *userp,     /* private callback
+                                                        pointer */
+                                    void *socketp);  /* private socket
+                                                        pointer */
+/*
+ * Name:    curl_multi_timer_callback
+ *
+ * Desc:    Called by libcurl whenever the library detects a change in the
+ *          maximum number of milliseconds the app is allowed to wait before
+ *          curl_multi_socket() or curl_multi_perform() must be called
+ *          (to allow libcurl's timed events to take place).
+ *
+ * Returns: The callback should return zero.
+ */
+typedef int (*curl_multi_timer_callback)(CURLM *multi,    /* multi handle */
+                                         long timeout_ms, /* see above */
+                                         void *userp);    /* private callback
+                                                             pointer */
+
+CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()")
+curl_multi_socket(CURLM *multi_handle, curl_socket_t s, int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
+                                               curl_socket_t s,
+                                               int ev_bitmask,
+                                               int *running_handles);
+
+CURL_EXTERN CURLMcode CURL_DEPRECATED(7.19.5, "Use curl_multi_socket_action()")
+curl_multi_socket_all(CURLM *multi_handle, int *running_handles);
+
+#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
+/* This macro below was added in 7.16.3 to push users who recompile to use
+ * the new curl_multi_socket_action() instead of the old curl_multi_socket()
+ */
+#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
+#endif
+
+/*
+ * Name:    curl_multi_timeout()
+ *
+ * Desc:    Returns the maximum number of milliseconds the app is allowed to
+ *          wait before curl_multi_socket() or curl_multi_perform() must be
+ *          called (to allow libcurl's timed events to take place).
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
+                                         long *milliseconds);
+
+typedef enum {
+  /* This is the socket callback function pointer */
+  CURLOPT(CURLMOPT_SOCKETFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 1),
+
+  /* This is the argument passed to the socket callback */
+  CURLOPT(CURLMOPT_SOCKETDATA, CURLOPTTYPE_OBJECTPOINT, 2),
+
+  /* set to 1 to enable pipelining for this multi handle */
+  CURLOPT(CURLMOPT_PIPELINING, CURLOPTTYPE_LONG, 3),
+
+  /* This is the timer callback function pointer */
+  CURLOPT(CURLMOPT_TIMERFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 4),
+
+  /* This is the argument passed to the timer callback */
+  CURLOPT(CURLMOPT_TIMERDATA, CURLOPTTYPE_OBJECTPOINT, 5),
+
+  /* maximum number of entries in the connection cache */
+  CURLOPT(CURLMOPT_MAXCONNECTS, CURLOPTTYPE_LONG, 6),
+
+  /* maximum number of (pipelining) connections to one host */
+  CURLOPT(CURLMOPT_MAX_HOST_CONNECTIONS, CURLOPTTYPE_LONG, 7),
+
+  /* maximum number of requests in a pipeline */
+  CURLOPT(CURLMOPT_MAX_PIPELINE_LENGTH, CURLOPTTYPE_LONG, 8),
+
+  /* a connection with a content-length longer than this
+     will not be considered for pipelining */
+  CURLOPT(CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 9),
+
+  /* a connection with a chunk length longer than this
+     will not be considered for pipelining */
+  CURLOPT(CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE, CURLOPTTYPE_OFF_T, 10),
+
+  /* a list of site names(+port) that are blocked from pipelining */
+  CURLOPT(CURLMOPT_PIPELINING_SITE_BL, CURLOPTTYPE_OBJECTPOINT, 11),
+
+  /* a list of server types that are blocked from pipelining */
+  CURLOPT(CURLMOPT_PIPELINING_SERVER_BL, CURLOPTTYPE_OBJECTPOINT, 12),
+
+  /* maximum number of open connections in total */
+  CURLOPT(CURLMOPT_MAX_TOTAL_CONNECTIONS, CURLOPTTYPE_LONG, 13),
+
+   /* This is the server push callback function pointer */
+  CURLOPT(CURLMOPT_PUSHFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 14),
+
+  /* This is the argument passed to the server push callback */
+  CURLOPT(CURLMOPT_PUSHDATA, CURLOPTTYPE_OBJECTPOINT, 15),
+
+  /* maximum number of concurrent streams to support on a connection */
+  CURLOPT(CURLMOPT_MAX_CONCURRENT_STREAMS, CURLOPTTYPE_LONG, 16),
+
+  /* network has changed, adjust caches/connection reuse */
+  CURLOPT(CURLMOPT_NETWORK_CHANGED, CURLOPTTYPE_LONG, 17),
+
+  /* This is the notify callback function pointer */
+  CURLOPT(CURLMOPT_NOTIFYFUNCTION, CURLOPTTYPE_FUNCTIONPOINT, 18),
+
+  /* This is the argument passed to the notify callback */
+  CURLOPT(CURLMOPT_NOTIFYDATA, CURLOPTTYPE_OBJECTPOINT, 19),
+
+  CURLMOPT_LASTENTRY /* the last unused */
+} CURLMoption;
+
+/* Definition of bits for the CURLMOPT_NETWORK_CHANGED argument: */
+
+/* - CURLMNWC_CLEAR_CONNS tells libcurl to prevent further reuse of existing
+   connections. Connections that are idle will be closed. Ongoing transfers
+   will continue with the connection they have. */
+#define CURLMNWC_CLEAR_CONNS (1L << 0)
+
+/* - CURLMNWC_CLEAR_DNS tells libcurl to prevent further reuse of existing
+   connections. Connections that are idle will be closed. Ongoing transfers
+   will continue with the connection they have. */
+#define CURLMNWC_CLEAR_DNS (1L << 0)
+
+/*
+ * Name:    curl_multi_setopt()
+ *
+ * Desc:    Sets options for the multi handle.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+                                        CURLMoption option, ...);
+
+/*
+ * Name:    curl_multi_assign()
+ *
+ * Desc:    This function sets an association in the multi handle between the
+ *          given socket and a private pointer of the application. This is
+ *          (only) useful for curl_multi_socket uses.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
+                                        curl_socket_t sockfd, void *sockp);
+
+/*
+ * Name:    curl_multi_get_handles()
+ *
+ * Desc:    Returns an allocated array holding all handles currently added to
+ *          the multi handle. Marks the final entry with a NULL pointer. If
+ *          there is no easy handle added to the multi handle, this function
+ *          returns an array with the first entry as a NULL pointer.
+ *
+ * Returns: NULL on failure, otherwise a CURL **array pointer
+ */
+CURL_EXTERN CURL **curl_multi_get_handles(CURLM *multi_handle);
+
+typedef enum {
+  CURLMINFO_NONE, /* first, never use this */
+  /* The number of easy handles currently managed by the multi handle,
+   * e.g. have been added but not yet removed. */
+  CURLMINFO_XFERS_CURRENT = 1,
+  /* The number of easy handles running, e.g. not done and not queueing. */
+  CURLMINFO_XFERS_RUNNING = 2,
+  /* The number of easy handles waiting to start, e.g. for a connection
+   * to become available due to limits on parallelism, max connections
+   * or other factors. */
+  CURLMINFO_XFERS_PENDING = 3,
+  /* The number of easy handles finished, waiting for their results to
+   * be read via `curl_multi_info_read()`. */
+  CURLMINFO_XFERS_DONE = 4,
+  /* The total number of easy handles added to the multi handle, ever. */
+  CURLMINFO_XFERS_ADDED = 5,
+
+  CURLMINFO_LASTENTRY /* the last unused */
+} CURLMinfo_offt;
+
+/*
+ * Name:    curl_multi_get_offt()
+ *
+ * Desc:    Retrieves a numeric value for the `CURLMINFO_*` enums.
+ *
+ * Returns: CULRM_OK or error when value could not be obtained.
+ */
+CURL_EXTERN CURLMcode curl_multi_get_offt(CURLM *multi_handle,
+                                          CURLMinfo_offt info,
+                                          curl_off_t *pvalue);
+
+/*
+ * Name: curl_push_callback
+ *
+ * Desc: This callback gets called when a new stream is being pushed by the
+ *       server. It approves or denies the new stream. It can also decide
+ *       to completely fail the connection.
+ *
+ * Returns: CURL_PUSH_OK, CURL_PUSH_DENY or CURL_PUSH_ERROROUT
+ */
+#define CURL_PUSH_OK       0
+#define CURL_PUSH_DENY     1
+#define CURL_PUSH_ERROROUT 2 /* added in 7.72.0 */
+
+struct curl_pushheaders;  /* forward declaration only */
+
+CURL_EXTERN char *curl_pushheader_bynum(struct curl_pushheaders *h,
+                                        size_t num);
+CURL_EXTERN char *curl_pushheader_byname(struct curl_pushheaders *h,
+                                         const char *name);
+
+typedef int (*curl_push_callback)(CURL *parent,
+                                  CURL *easy,
+                                  size_t num_headers,
+                                  struct curl_pushheaders *headers,
+                                  void *userp);
+
+/*
+ * Name:    curl_multi_waitfds()
+ *
+ * Desc:    Ask curl for fds for polling. The app can use these to poll on.
+ *          We want curl_multi_perform() called as soon as one of them are
+ *          ready. Passing zero size allows to get just a number of fds.
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_waitfds(CURLM *multi,
+                                         struct curl_waitfd *ufds,
+                                         unsigned int size,
+                                         unsigned int *fd_count);
+
+/*
+ * Notifications dispatched by a multi handle, when enabled.
+ */
+#define CURLMNOTIFY_INFO_READ    0
+#define CURLMNOTIFY_EASY_DONE    1
+
+/*
+ * Callback to install via CURLMOPT_NOTIFYFUNCTION.
+ */
+typedef void (*curl_notify_callback)(CURLM *multi,
+                                     unsigned int notification,
+                                     CURL *easy,
+                                     void *user_data);
+
+CURL_EXTERN CURLMcode curl_multi_notify_disable(CURLM *multi,
+                                                unsigned int notification);
+
+CURL_EXTERN CURLMcode curl_multi_notify_enable(CURLM *multi,
+                                               unsigned int notification);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

entry/src/main/cpp/include/curl/options.h

@@ -0,0 +1,70 @@
+#ifndef CURLINC_OPTIONS_H
+#define CURLINC_OPTIONS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  CURLOT_LONG,    /* long (a range of values) */
+  CURLOT_VALUES,  /*      (a defined set or bitmask) */
+  CURLOT_OFF_T,   /* curl_off_t (a range of values) */
+  CURLOT_OBJECT,  /* pointer (void *) */
+  CURLOT_STRING,  /*         (char * to null-terminated buffer) */
+  CURLOT_SLIST,   /*         (struct curl_slist *) */
+  CURLOT_CBPTR,   /*         (void * passed as-is to a callback) */
+  CURLOT_BLOB,    /* blob (struct curl_blob *) */
+  CURLOT_FUNCTION /* function pointer */
+} curl_easytype;
+
+/* Flag bits */
+
+/* "alias" means it is provided for old programs to remain functional,
+   we prefer another name */
+#define CURLOT_FLAG_ALIAS (1 << 0)
+
+/* The CURLOPTTYPE_* id ranges can still be used to figure out what type/size
+   to use for curl_easy_setopt() for the given id */
+struct curl_easyoption {
+  const char *name;
+  CURLoption id;
+  curl_easytype type;
+  unsigned int flags;
+};
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_by_name(const char *name);
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_by_id(CURLoption id);
+
+CURL_EXTERN const struct curl_easyoption *
+curl_easy_option_next(const struct curl_easyoption *prev);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+#endif /* CURLINC_OPTIONS_H */

entry/src/main/cpp/include/curl/stdcheaders.h

@@ -0,0 +1,35 @@
+#ifndef CURLINC_STDCHEADERS_H
+#define CURLINC_STDCHEADERS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include <sys/types.h>
+
+size_t fread(void *, size_t, size_t, FILE *);
+size_t fwrite(const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* CURLINC_STDCHEADERS_H */

entry/src/main/cpp/include/curl/system.h

@@ -0,0 +1,399 @@
+#ifndef CURLINC_SYSTEM_H
+#define CURLINC_SYSTEM_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/*
+ * Try to keep one section per platform, compiler and architecture, otherwise,
+ * if an existing section is reused for a different one and later on the
+ * original is adjusted, probably the piggybacking one can be adversely
+ * changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures use
+ * only compiler built-in predefined preprocessor symbols.
+ *
+ * curl_off_t
+ * ----------
+ *
+ * For any given platform/compiler curl_off_t MUST be typedef'ed to a 64-bit
+ * wide signed integral data type. The width of this data type must remain
+ * constant and independent of any possible large file support settings.
+ *
+ * As a general rule, curl_off_t shall not be mapped to off_t. This rule shall
+ * only be violated if off_t is the only 64-bit data type available and the
+ * size of off_t is independent of large file support settings. Keep your
+ * build on the safe side avoiding an off_t gating. If you have a 64-bit
+ * off_t then take for sure that another 64-bit data type exists, dig deeper
+ * and you will find it.
+ *
+ */
+
+#ifdef __DJGPP__
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__BORLANDC__)
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__POCC__)
+#  ifdef _MSC_VER
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__LCC__)
+#  ifdef __MCST__ /* MCST eLbrus Compiler Collection */
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  else                /* Local (or Little) C Compiler */
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  endif
+
+#elif defined(macintosh)
+#  include <ConditionalMacros.h>
+#  if TYPE_LONGLONG
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+
+#elif defined(__TANDEM)
+#  ifndef __LP64
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  endif
+
+#elif defined(UNDER_CE)
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__MINGW32__)
+#  include <inttypes.h>
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     PRId64
+#  define CURL_FORMAT_CURL_OFF_TU    PRIu64
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_PULL_SYS_TYPES_H      1
+
+#elif defined(__VMS)
+#  ifdef __VAX
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+
+#elif defined(__OS400__)
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__MVS__)
+#  ifdef _LONG_LONG
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else /* _LP64 and default */
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    ifdef _LONG_LONG
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    else /* _LP64 and default */
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+#elif defined(__TINYC__) /* also known as tcc */
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) /* Oracle Solaris Studio */
+#  if !defined(__LP64) && (defined(__ILP32) ||                          \
+                           defined(__i386) ||                           \
+                           defined(__sparcv8) ||                        \
+                           defined(__sparcv8plus))
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__LP64) || \
+        defined(__amd64) || defined(__sparcv9)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__xlc__) /* IBM xlc compiler */
+#  ifndef _LP64
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#elif defined(__hpux) /* HP aCC compiler */
+#  ifndef _LP64
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  if (_MSC_VER >= 1800)
+#    include <inttypes.h>
+#    define CURL_FORMAT_CURL_OFF_T     PRId64
+#    define CURL_FORMAT_CURL_OFF_TU    PRIu64
+#  else
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  endif
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__) && !defined(_SCO_DS)
+#  if !defined(__LP64__) &&                                             \
+  (defined(__ILP32__) || defined(__i386__) || defined(__hppa__) ||      \
+   defined(__ppc__) || defined(__powerpc__) || defined(__arm__) ||      \
+   defined(__sparc__) || defined(__mips__) || defined(__sh__) ||        \
+   defined(__XTENSA__) ||                                               \
+   (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 4) ||                \
+   (defined(__LONG_MAX__) && __LONG_MAX__ == 2147483647L))
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    if (__GNUC__ >= 4) || \
+       ((__GNUC__ == 3) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 4))
+#      define CURL_POPCOUNT64(x)       __builtin_popcountll(x)
+#      define CURL_CTZ64(x)            __builtin_ctzll(x)
+#    endif
+#  elif defined(__LP64__) || \
+        defined(__x86_64__) || defined(__ppc64__) || defined(__sparc64__) || \
+        defined(__e2k__) || \
+        (defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ == 8) || \
+        (defined(__LONG_MAX__) && __LONG_MAX__ == 9223372036854775807L)
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#    if (__GNUC__ >= 4) || \
+       ((__GNUC__ == 3) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ >= 4))
+#      define CURL_POPCOUNT64(x)       __builtin_popcountl(x)
+#      define CURL_CTZ64(x)            __builtin_ctzl(x)
+#    endif
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#else
+/* generic "safe guess" on old 32-bit style */
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#endif
+
+#ifdef _AIX
+/* AIX needs <sys/poll.h> */
+#define CURL_PULL_SYS_POLL_H
+#endif
+
+/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* CURL_PULL_SYS_POLL_H is defined above when inclusion of header file    */
+/* sys/poll.h is required here to properly make type definitions below.   */
+#ifdef CURL_PULL_SYS_POLL_H
+#  include <sys/poll.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+#endif
+
+/* Data type definition of curl_off_t. */
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+  typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+#endif
+
+#endif /* CURLINC_SYSTEM_H */

entry/src/main/cpp/include/curl/typecheck-gcc.h

@@ -0,0 +1,957 @@
+#ifndef CURLINC_TYPECHECK_GCC_H
+#define CURLINC_TYPECHECK_GCC_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+/* wraps curl_easy_setopt() with type checking */
+
+/* To add a new kind of warning, add an
+ *   if(curlcheck_sometype_option(_curl_opt))
+ *     if(!curlcheck_sometype(value))
+ *       Wcurl_easy_setopt_err_sometype();
+ * block and define curlcheck_sometype_option, curlcheck_sometype and
+ * Wcurl_easy_setopt_err_sometype below
+ *
+ * NOTE: We use two nested 'if' statements here instead of the && operator, in
+ *       order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x
+ *       when compiling with -Wlogical-op.
+ *
+ * To add an option that uses the same type as an existing option, you will
+ * just need to extend the appropriate _curl_*_option macro
+ */
+
+#define curl_easy_setopt(handle, option, value)                         \
+  __extension__({                                                       \
+      if(__builtin_constant_p(option)) {                                \
+        CURL_IGNORE_DEPRECATION(                                        \
+          if(curlcheck_long_option(option))                             \
+            if(!curlcheck_long(value))                                  \
+              Wcurl_easy_setopt_err_long();                             \
+          if(curlcheck_off_t_option(option))                            \
+            if(!curlcheck_off_t(value))                                 \
+              Wcurl_easy_setopt_err_curl_off_t();                       \
+          if(curlcheck_string_option(option))                           \
+            if(!curlcheck_string(value))                                \
+              Wcurl_easy_setopt_err_string();                           \
+          if((option) == CURLOPT_PRIVATE) { }                           \
+          if(curlcheck_write_cb_option(option))                         \
+            if(!curlcheck_write_cb(value))                              \
+              Wcurl_easy_setopt_err_write_callback();                   \
+          if(curlcheck_curl_option(option))                             \
+            if(!curlcheck_curl(value))                                  \
+              Wcurl_easy_setopt_err_curl();                             \
+          if((option) == CURLOPT_RESOLVER_START_FUNCTION)               \
+            if(!curlcheck_resolver_start_callback(value))               \
+              Wcurl_easy_setopt_err_resolver_start_callback();          \
+          if((option) == CURLOPT_READFUNCTION)                          \
+            if(!curlcheck_read_cb(value))                               \
+              Wcurl_easy_setopt_err_read_cb();                          \
+          if((option) == CURLOPT_IOCTLFUNCTION)                         \
+            if(!curlcheck_ioctl_cb(value))                              \
+              Wcurl_easy_setopt_err_ioctl_cb();                         \
+          if((option) == CURLOPT_SOCKOPTFUNCTION)                       \
+            if(!curlcheck_sockopt_cb(value))                            \
+              Wcurl_easy_setopt_err_sockopt_cb();                       \
+          if((option) == CURLOPT_OPENSOCKETFUNCTION)                    \
+            if(!curlcheck_opensocket_cb(value))                         \
+              Wcurl_easy_setopt_err_opensocket_cb();                    \
+          if((option) == CURLOPT_PROGRESSFUNCTION)                      \
+            if(!curlcheck_progress_cb(value))                           \
+              Wcurl_easy_setopt_err_progress_cb();                      \
+          if((option) == CURLOPT_XFERINFOFUNCTION)                      \
+            if(!curlcheck_xferinfo_cb(value))                           \
+              Wcurl_easy_setopt_err_xferinfo_cb();                      \
+          if((option) == CURLOPT_DEBUGFUNCTION)                         \
+            if(!curlcheck_debug_cb(value))                              \
+              Wcurl_easy_setopt_err_debug_cb();                         \
+          if((option) == CURLOPT_SSL_CTX_FUNCTION)                      \
+            if(!curlcheck_ssl_ctx_cb(value))                            \
+              Wcurl_easy_setopt_err_ssl_ctx_cb();                       \
+          if(curlcheck_conv_cb_option(option))                          \
+            if(!curlcheck_conv_cb(value))                               \
+              Wcurl_easy_setopt_err_conv_cb();                          \
+          if((option) == CURLOPT_SEEKFUNCTION)                          \
+            if(!curlcheck_seek_cb(value))                               \
+              Wcurl_easy_setopt_err_seek_cb();                          \
+          if((option) == CURLOPT_CHUNK_BGN_FUNCTION)                    \
+            if(!curlcheck_chunk_bgn_cb(value))                          \
+              Wcurl_easy_setopt_err_chunk_bgn_cb();                     \
+          if((option) == CURLOPT_CHUNK_END_FUNCTION)                    \
+            if(!curlcheck_chunk_end_cb(value))                          \
+              Wcurl_easy_setopt_err_chunk_end_cb();                     \
+          if((option) == CURLOPT_CLOSESOCKETFUNCTION)                   \
+            if(!curlcheck_close_socket_cb(value))                       \
+              Wcurl_easy_setopt_err_close_socket_cb();                  \
+          if((option) == CURLOPT_FNMATCH_FUNCTION)                      \
+            if(!curlcheck_fnmatch_cb(value))                            \
+              Wcurl_easy_setopt_err_fnmatch_cb();                       \
+          if((option) == CURLOPT_HSTSREADFUNCTION)                      \
+            if(!curlcheck_hstsread_cb(value))                           \
+              Wcurl_easy_setopt_err_hstsread_cb();                      \
+          if((option) == CURLOPT_HSTSWRITEFUNCTION)                     \
+            if(!curlcheck_hstswrite_cb(value))                          \
+              Wcurl_easy_setopt_err_hstswrite_cb();                     \
+          if((option) == CURLOPT_SSH_HOSTKEYFUNCTION)                   \
+            if(!curlcheck_ssh_hostkey_cb(value))                        \
+              Wcurl_easy_setopt_err_ssh_hostkey_cb();                   \
+          if((option) == CURLOPT_SSH_KEYFUNCTION)                       \
+            if(!curlcheck_ssh_key_cb(value))                            \
+              Wcurl_easy_setopt_err_ssh_key_cb();                       \
+          if((option) == CURLOPT_INTERLEAVEFUNCTION)                    \
+            if(!curlcheck_interleave_cb(value))                         \
+              Wcurl_easy_setopt_err_interleave_cb();                    \
+          if((option) == CURLOPT_PREREQFUNCTION)                        \
+            if(!curlcheck_prereq_cb(value))                             \
+              Wcurl_easy_setopt_err_prereq_cb();                        \
+          if((option) == CURLOPT_TRAILERFUNCTION)                       \
+            if(!curlcheck_trailer_cb(value))                            \
+              Wcurl_easy_setopt_err_trailer_cb();                       \
+          if(curlcheck_cb_data_option(option))                          \
+            if(!curlcheck_cb_data(value))                               \
+              Wcurl_easy_setopt_err_cb_data();                          \
+          if((option) == CURLOPT_ERRORBUFFER)                           \
+            if(!curlcheck_error_buffer(value))                          \
+              Wcurl_easy_setopt_err_error_buffer();                     \
+          if((option) == CURLOPT_CURLU)                                 \
+            if(!curlcheck_ptr((value), CURLU))                          \
+              Wcurl_easy_setopt_err_curlu();                            \
+          if((option) == CURLOPT_STDERR)                                \
+            if(!curlcheck_FILE(value))                                  \
+              Wcurl_easy_setopt_err_FILE();                             \
+          if(curlcheck_postfields_option(option))                       \
+            if(!curlcheck_postfields(value))                            \
+              Wcurl_easy_setopt_err_postfields();                       \
+          if((option) == CURLOPT_HTTPPOST)                              \
+            if(!curlcheck_arr((value), struct curl_httppost))           \
+              Wcurl_easy_setopt_err_curl_httpost();                     \
+          if((option) == CURLOPT_MIMEPOST)                              \
+            if(!curlcheck_ptr((value), curl_mime))                      \
+              Wcurl_easy_setopt_err_curl_mimepost();                    \
+          if(curlcheck_slist_option(option))                            \
+            if(!curlcheck_arr((value), struct curl_slist))              \
+              Wcurl_easy_setopt_err_curl_slist();                       \
+          if((option) == CURLOPT_SHARE)                                 \
+            if(!curlcheck_ptr((value), CURLSH))                         \
+              Wcurl_easy_setopt_err_CURLSH();                           \
+          )                                                             \
+          }                                                             \
+      curl_easy_setopt(handle, option, value);                          \
+    })
+
+/* wraps curl_easy_getinfo() with type checking */
+#define curl_easy_getinfo(handle, info, arg)                            \
+  __extension__({                                                       \
+      if(__builtin_constant_p(info)) {                                  \
+        CURL_IGNORE_DEPRECATION(                                        \
+          if(curlcheck_string_info(info))                               \
+            if(!curlcheck_arr((arg), char *))                           \
+              Wcurl_easy_getinfo_err_string();                          \
+          if(curlcheck_long_info(info))                                 \
+            if(!curlcheck_arr((arg), long))                             \
+              Wcurl_easy_getinfo_err_long();                            \
+          if(curlcheck_double_info(info))                               \
+            if(!curlcheck_arr((arg), double))                           \
+              Wcurl_easy_getinfo_err_double();                          \
+          if(curlcheck_slist_info(info))                                \
+            if(!curlcheck_arr((arg), struct curl_slist *))              \
+              Wcurl_easy_getinfo_err_curl_slist();                      \
+          if(curlcheck_tlssessioninfo_info(info))                       \
+            if(!curlcheck_arr((arg), struct curl_tlssessioninfo *))     \
+              Wcurl_easy_getinfo_err_curl_tlssessioninfo();             \
+          if(curlcheck_certinfo_info(info))                             \
+            if(!curlcheck_arr((arg), struct curl_certinfo *))           \
+              Wcurl_easy_getinfo_err_curl_certinfo();                   \
+          if(curlcheck_socket_info(info))                               \
+            if(!curlcheck_arr((arg), curl_socket_t))                    \
+              Wcurl_easy_getinfo_err_curl_socket();                     \
+          if(curlcheck_off_t_info(info))                                \
+            if(!curlcheck_arr((arg), curl_off_t))                       \
+              Wcurl_easy_getinfo_err_curl_off_t();                      \
+          )                                                             \
+          }                                                             \
+      curl_easy_getinfo(handle, info, arg);                             \
+    })
+
+#define curl_multi_setopt(handle, option, value)                        \
+  __extension__({                                                       \
+      if(__builtin_constant_p(option)) {                                \
+        if(curlcheck_long_option(option))                               \
+          if(!curlcheck_long(value))                                    \
+            Wcurl_multi_setopt_err_long();                              \
+        if(curlcheck_off_t_option(option))                              \
+          if(!curlcheck_off_t(value))                                   \
+            Wcurl_multi_setopt_err_curl_off_t();                        \
+        if(curlcheck_multicb_data_option(option))                       \
+          if(!curlcheck_cb_data(value))                                 \
+            Wcurl_multi_setopt_err_cb_data();                           \
+        if(curlcheck_charpp_option(option))                             \
+          if(!curlcheck_ptrptr(value, char))                            \
+            Wcurl_multi_setopt_err_charpp();                            \
+        if((option) == CURLMOPT_NOTIFYFUNCTION)                         \
+          if(!curlcheck_multinotify_cb(value))                          \
+            Wcurl_multi_setopt_err_notifycb();                          \
+        if((option) == CURLMOPT_PUSHFUNCTION)                           \
+          if(!curlcheck_multipush_cb(value))                            \
+            Wcurl_multi_setopt_err_pushcb();                            \
+        if((option) == CURLMOPT_SOCKETFUNCTION)                         \
+          if(!curlcheck_multisocket_cb(value))                          \
+            Wcurl_multi_setopt_err_socketcb();                          \
+        if((option) == CURLMOPT_TIMERFUNCTION)                          \
+          if(!curlcheck_multitimer_cb(value))                           \
+            Wcurl_multi_setopt_err_timercb();                           \
+      }                                                                 \
+      curl_multi_setopt(handle, option, value);                         \
+    })
+
+/* evaluates to true if the option takes a data argument to pass to a
+   callback */
+#define curlcheck_multicb_data_option(option)                           \
+  ((option) == CURLMOPT_NOTIFYDATA ||                                   \
+   (option) == CURLMOPT_PUSHDATA ||                                     \
+   (option) == CURLMOPT_SOCKETDATA ||                                   \
+   (option) == CURLMOPT_TIMERDATA ||                                    \
+   0)
+
+/* evaluates to true if the option takes a char ** argument */
+#define curlcheck_charpp_option(option)                                 \
+  ((option) == CURLMOPT_PIPELINING_SERVER_BL ||                         \
+   (option) == CURLMOPT_PIPELINING_SITE_BL ||                           \
+   0)
+
+/* evaluates to true if expr is of type curl_multi_timer_callback */
+#define curlcheck_multitimer_cb(expr)                                   \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_multi_timer_callback))
+
+/* evaluates to true if expr is of type curl_socket_callback */
+#define curlcheck_multisocket_cb(expr)                                  \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_socket_callback))
+
+/* evaluates to true if expr is of type curl_push_callback */
+#define curlcheck_multipush_cb(expr)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_push_callback))
+
+/* evaluates to true if expr is of type curl_push_callback */
+#define curlcheck_multinotify_cb(expr)                                  \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_notify_callback))
+
+/*
+ * For now, just make sure that the functions are called with three arguments
+ */
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+
+/* the actual warnings, triggered by calling the Wcurl_easy_setopt_err*
+ * functions */
+
+/* To define a new warning, use _CURL_WARNING(identifier, "message") */
+#define CURLWARNING(id, message)                                        \
+  static void __attribute__((__warning__(message)))                     \
+  __attribute__((__unused__)) __attribute__((__noinline__))             \
+  id(void) { __asm__(""); }
+
+CURLWARNING(Wcurl_multi_setopt_err_long,
+            "curl_multi_setopt expects a long argument")
+CURLWARNING(Wcurl_multi_setopt_err_curl_off_t,
+            "curl_multi_setopt expects a curl_off_t argument")
+CURLWARNING(Wcurl_multi_setopt_err_cb_data,
+            "curl_multi_setopt expects a 'void *' argument")
+CURLWARNING(Wcurl_multi_setopt_err_charpp,
+            "curl_multi_setopt expects a 'char **' argument")
+CURLWARNING(Wcurl_multi_setopt_err_pushcb,
+            "curl_multi_setopt expects a curl_push_callback argument")
+CURLWARNING(Wcurl_multi_setopt_err_notifycb,
+            "curl_multi_setopt expects a curl_notify_callback argument")
+CURLWARNING(Wcurl_multi_setopt_err_socketcb,
+            "curl_multi_setopt expects a curl_socket_callback argument")
+CURLWARNING(Wcurl_multi_setopt_err_timercb,
+            "curl_multi_setopt expects a curl_multi_timer_callback argument")
+
+CURLWARNING(Wcurl_easy_setopt_err_long,
+            "curl_easy_setopt expects a long argument")
+CURLWARNING(Wcurl_easy_setopt_err_curl_off_t,
+            "curl_easy_setopt expects a curl_off_t argument")
+CURLWARNING(Wcurl_easy_setopt_err_string,
+            "curl_easy_setopt expects a "
+            "string ('char *' or char[]) argument")
+CURLWARNING(Wcurl_easy_setopt_err_write_callback,
+            "curl_easy_setopt expects a curl_write_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_resolver_start_callback,
+            "curl_easy_setopt expects a "
+            "curl_resolver_start_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_read_cb,
+            "curl_easy_setopt expects a curl_read_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_ioctl_cb,
+            "curl_easy_setopt expects a curl_ioctl_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_sockopt_cb,
+            "curl_easy_setopt expects a curl_sockopt_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_opensocket_cb,
+            "curl_easy_setopt expects a "
+            "curl_opensocket_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_progress_cb,
+            "curl_easy_setopt expects a curl_progress_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_xferinfo_cb,
+            "curl_easy_setopt expects a curl_xferinfo_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_debug_cb,
+            "curl_easy_setopt expects a curl_debug_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_ssl_ctx_cb,
+            "curl_easy_setopt expects a curl_ssl_ctx_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_conv_cb,
+            "curl_easy_setopt expects a curl_conv_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_seek_cb,
+            "curl_easy_setopt expects a curl_seek_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_cb_data,
+            "curl_easy_setopt expects a "
+            "private data pointer as argument")
+CURLWARNING(Wcurl_easy_setopt_err_chunk_bgn_cb,
+            "curl_easy_setopt expects a curl_chunk_bgn_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_chunk_end_cb,
+            "curl_easy_setopt expects a curl_chunk_end_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_close_socket_cb,
+            "curl_easy_setopt expects a curl_closesocket_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_fnmatch_cb,
+            "curl_easy_setopt expects a curl_fnmatch_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_hstsread_cb,
+            "curl_easy_setopt expects a curl_hstsread_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_hstswrite_cb,
+            "curl_easy_setopt expects a curl_hstswrite_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_ssh_key_cb,
+            "curl_easy_setopt expects a curl_sshkeycallback argument")
+CURLWARNING(Wcurl_easy_setopt_err_ssh_hostkey_cb,
+            "curl_easy_setopt expects a curl_sshhostkeycallback argument")
+CURLWARNING(Wcurl_easy_setopt_err_interleave_cb,
+            "curl_easy_setopt expects a curl_interleave_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_prereq_cb,
+            "curl_easy_setopt expects a curl_prereq_callback argument")
+CURLWARNING(Wcurl_easy_setopt_err_trailer_cb,
+            "curl_easy_setopt expects a curl_trailerfunc_ok argument")
+CURLWARNING(Wcurl_easy_setopt_err_error_buffer,
+            "curl_easy_setopt expects a "
+            "char buffer of CURL_ERROR_SIZE as argument")
+CURLWARNING(Wcurl_easy_setopt_err_curlu,
+            "curl_easy_setopt expects a 'CURLU *' argument")
+CURLWARNING(Wcurl_easy_setopt_err_curl,
+            "curl_easy_setopt expects a 'CURL *' argument")
+CURLWARNING(Wcurl_easy_setopt_err_FILE,
+            "curl_easy_setopt expects a 'FILE *' argument")
+CURLWARNING(Wcurl_easy_setopt_err_postfields,
+            "curl_easy_setopt expects a 'void *' or 'char *' argument")
+CURLWARNING(Wcurl_easy_setopt_err_curl_httpost,
+            "curl_easy_setopt expects a 'struct curl_httppost *' "
+            "argument")
+CURLWARNING(Wcurl_easy_setopt_err_curl_mimepost,
+            "curl_easy_setopt expects a 'curl_mime *' "
+            "argument")
+CURLWARNING(Wcurl_easy_setopt_err_curl_slist,
+            "curl_easy_setopt expects a 'struct curl_slist *' argument")
+CURLWARNING(Wcurl_easy_setopt_err_CURLSH,
+            "curl_easy_setopt expects a CURLSH* argument")
+CURLWARNING(Wcurl_easy_getinfo_err_string,
+            "curl_easy_getinfo expects a pointer to 'char *'")
+CURLWARNING(Wcurl_easy_getinfo_err_long,
+            "curl_easy_getinfo expects a pointer to long")
+CURLWARNING(Wcurl_easy_getinfo_err_double,
+            "curl_easy_getinfo expects a pointer to double")
+CURLWARNING(Wcurl_easy_getinfo_err_curl_slist,
+            "curl_easy_getinfo expects a pointer to 'struct curl_slist *'")
+CURLWARNING(Wcurl_easy_getinfo_err_curl_tlssessioninfo,
+            "curl_easy_getinfo expects a pointer to "
+            "'struct curl_tlssessioninfo *'")
+CURLWARNING(Wcurl_easy_getinfo_err_curl_certinfo,
+            "curl_easy_getinfo expects a pointer to "
+            "'struct curl_certinfo *'")
+CURLWARNING(Wcurl_easy_getinfo_err_curl_socket,
+            "curl_easy_getinfo expects a pointer to curl_socket_t")
+CURLWARNING(Wcurl_easy_getinfo_err_curl_off_t,
+            "curl_easy_getinfo expects a pointer to curl_off_t")
+
+/* groups of curl_easy_setops options that take the same type of argument */
+
+/* evaluates to true if option takes a long argument */
+#define curlcheck_long_option(option)                                   \
+  (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
+
+#define curlcheck_off_t_option(option)                                  \
+  (((option) > CURLOPTTYPE_OFF_T) && ((option) < CURLOPTTYPE_BLOB))
+
+/* option takes a CURL * argument */
+#define curlcheck_curl_option(option)                                   \
+  ((option) == CURLOPT_STREAM_DEPENDS ||                                \
+   (option) == CURLOPT_STREAM_DEPENDS_E ||                              \
+   0)
+
+/* evaluates to true if option takes a char* argument */
+#define curlcheck_string_option(option)                                 \
+  ((option) == CURLOPT_ABSTRACT_UNIX_SOCKET ||                          \
+   (option) == CURLOPT_ACCEPT_ENCODING ||                               \
+   (option) == CURLOPT_ALTSVC ||                                        \
+   (option) == CURLOPT_CAINFO ||                                        \
+   (option) == CURLOPT_CAPATH ||                                        \
+   (option) == CURLOPT_COOKIE ||                                        \
+   (option) == CURLOPT_COOKIEFILE ||                                    \
+   (option) == CURLOPT_COOKIEJAR ||                                     \
+   (option) == CURLOPT_COOKIELIST ||                                    \
+   (option) == CURLOPT_CRLFILE ||                                       \
+   (option) == CURLOPT_CUSTOMREQUEST ||                                 \
+   (option) == CURLOPT_DEFAULT_PROTOCOL ||                              \
+   (option) == CURLOPT_DNS_INTERFACE ||                                 \
+   (option) == CURLOPT_DNS_LOCAL_IP4 ||                                 \
+   (option) == CURLOPT_DNS_LOCAL_IP6 ||                                 \
+   (option) == CURLOPT_DNS_SERVERS ||                                   \
+   (option) == CURLOPT_DOH_URL ||                                       \
+   (option) == CURLOPT_ECH ||                                           \
+   (option) == CURLOPT_EGDSOCKET ||                                     \
+   (option) == CURLOPT_FTP_ACCOUNT ||                                   \
+   (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER ||                       \
+   (option) == CURLOPT_FTPPORT ||                                       \
+   (option) == CURLOPT_HAPROXY_CLIENT_IP ||                             \
+   (option) == CURLOPT_HSTS ||                                          \
+   (option) == CURLOPT_INTERFACE ||                                     \
+   (option) == CURLOPT_ISSUERCERT ||                                    \
+   (option) == CURLOPT_KEYPASSWD ||                                     \
+   (option) == CURLOPT_KRBLEVEL ||                                      \
+   (option) == CURLOPT_LOGIN_OPTIONS ||                                 \
+   (option) == CURLOPT_MAIL_AUTH ||                                     \
+   (option) == CURLOPT_MAIL_FROM ||                                     \
+   (option) == CURLOPT_NETRC_FILE ||                                    \
+   (option) == CURLOPT_NOPROXY ||                                       \
+   (option) == CURLOPT_PASSWORD ||                                      \
+   (option) == CURLOPT_PINNEDPUBLICKEY ||                               \
+   (option) == CURLOPT_PRE_PROXY ||                                     \
+   (option) == CURLOPT_PROTOCOLS_STR ||                                 \
+   (option) == CURLOPT_PROXY ||                                         \
+   (option) == CURLOPT_PROXY_CAINFO ||                                  \
+   (option) == CURLOPT_PROXY_CAPATH ||                                  \
+   (option) == CURLOPT_PROXY_CRLFILE ||                                 \
+   (option) == CURLOPT_PROXY_ISSUERCERT ||                              \
+   (option) == CURLOPT_PROXY_KEYPASSWD ||                               \
+   (option) == CURLOPT_PROXY_PINNEDPUBLICKEY ||                         \
+   (option) == CURLOPT_PROXY_SERVICE_NAME ||                            \
+   (option) == CURLOPT_PROXY_SSL_CIPHER_LIST ||                         \
+   (option) == CURLOPT_PROXY_SSLCERT ||                                 \
+   (option) == CURLOPT_PROXY_SSLCERTTYPE ||                             \
+   (option) == CURLOPT_PROXY_SSLKEY ||                                  \
+   (option) == CURLOPT_PROXY_SSLKEYTYPE ||                              \
+   (option) == CURLOPT_PROXY_TLS13_CIPHERS ||                           \
+   (option) == CURLOPT_PROXY_TLSAUTH_PASSWORD ||                        \
+   (option) == CURLOPT_PROXY_TLSAUTH_TYPE ||                            \
+   (option) == CURLOPT_PROXY_TLSAUTH_USERNAME ||                        \
+   (option) == CURLOPT_PROXYPASSWORD ||                                 \
+   (option) == CURLOPT_PROXYUSERNAME ||                                 \
+   (option) == CURLOPT_PROXYUSERPWD ||                                  \
+   (option) == CURLOPT_RANDOM_FILE ||                                   \
+   (option) == CURLOPT_RANGE ||                                         \
+   (option) == CURLOPT_REDIR_PROTOCOLS_STR ||                           \
+   (option) == CURLOPT_REFERER ||                                       \
+   (option) == CURLOPT_REQUEST_TARGET ||                                \
+   (option) == CURLOPT_RTSP_SESSION_ID ||                               \
+   (option) == CURLOPT_RTSP_STREAM_URI ||                               \
+   (option) == CURLOPT_RTSP_TRANSPORT ||                                \
+   (option) == CURLOPT_SASL_AUTHZID ||                                  \
+   (option) == CURLOPT_SERVICE_NAME ||                                  \
+   (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                         \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                       \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 ||                    \
+   (option) == CURLOPT_SSH_KNOWNHOSTS ||                                \
+   (option) == CURLOPT_SSH_PRIVATE_KEYFILE ||                           \
+   (option) == CURLOPT_SSH_PUBLIC_KEYFILE ||                            \
+   (option) == CURLOPT_SSLCERT ||                                       \
+   (option) == CURLOPT_SSLCERTTYPE ||                                   \
+   (option) == CURLOPT_SSLENGINE ||                                     \
+   (option) == CURLOPT_SSLKEY ||                                        \
+   (option) == CURLOPT_SSLKEYTYPE ||                                    \
+   (option) == CURLOPT_SSL_CIPHER_LIST ||                               \
+   (option) == CURLOPT_SSL_EC_CURVES ||                                 \
+   (option) == CURLOPT_SSL_SIGNATURE_ALGORITHMS ||                      \
+   (option) == CURLOPT_TLS13_CIPHERS ||                                 \
+   (option) == CURLOPT_TLSAUTH_PASSWORD ||                              \
+   (option) == CURLOPT_TLSAUTH_TYPE ||                                  \
+   (option) == CURLOPT_TLSAUTH_USERNAME ||                              \
+   (option) == CURLOPT_UNIX_SOCKET_PATH ||                              \
+   (option) == CURLOPT_URL ||                                           \
+   (option) == CURLOPT_USERAGENT ||                                     \
+   (option) == CURLOPT_USERNAME ||                                      \
+   (option) == CURLOPT_AWS_SIGV4 ||                                     \
+   (option) == CURLOPT_USERPWD ||                                       \
+   (option) == CURLOPT_XOAUTH2_BEARER ||                                \
+   0)
+
+/* evaluates to true if option takes a curl_write_callback argument */
+#define curlcheck_write_cb_option(option)                               \
+  ((option) == CURLOPT_HEADERFUNCTION ||                                \
+   (option) == CURLOPT_WRITEFUNCTION)
+
+/* evaluates to true if option takes a curl_conv_callback argument */
+#define curlcheck_conv_cb_option(option)                                \
+  ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION ||                      \
+   (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION ||                    \
+   (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
+
+/* evaluates to true if option takes a data argument to pass to a callback */
+#define curlcheck_cb_data_option(option)                                      \
+  ((option) == CURLOPT_CHUNK_DATA ||                                          \
+   (option) == CURLOPT_CLOSESOCKETDATA ||                                     \
+   (option) == CURLOPT_DEBUGDATA ||                                           \
+   (option) == CURLOPT_FNMATCH_DATA ||                                        \
+   (option) == CURLOPT_HEADERDATA ||                                          \
+   (option) == CURLOPT_HSTSREADDATA ||                                        \
+   (option) == CURLOPT_HSTSWRITEDATA ||                                       \
+   (option) == CURLOPT_INTERLEAVEDATA ||                                      \
+   (option) == CURLOPT_IOCTLDATA ||                                           \
+   (option) == CURLOPT_OPENSOCKETDATA ||                                      \
+   (option) == CURLOPT_PREREQDATA ||                                          \
+   (option) == CURLOPT_XFERINFODATA ||                                        \
+   (option) == CURLOPT_READDATA ||                                            \
+   (option) == CURLOPT_SEEKDATA ||                                            \
+   (option) == CURLOPT_SOCKOPTDATA ||                                         \
+   (option) == CURLOPT_SSH_KEYDATA ||                                         \
+   (option) == CURLOPT_SSL_CTX_DATA ||                                        \
+   (option) == CURLOPT_WRITEDATA ||                                           \
+   (option) == CURLOPT_RESOLVER_START_DATA ||                                 \
+   (option) == CURLOPT_TRAILERDATA ||                                         \
+   (option) == CURLOPT_SSH_HOSTKEYDATA ||                                     \
+   0)
+
+/* evaluates to true if option takes a POST data argument (void* or char*) */
+#define curlcheck_postfields_option(option)                                   \
+  ((option) == CURLOPT_POSTFIELDS ||                                          \
+   (option) == CURLOPT_COPYPOSTFIELDS ||                                      \
+   0)
+
+/* evaluates to true if option takes a struct curl_slist * argument */
+#define curlcheck_slist_option(option)                                        \
+  ((option) == CURLOPT_HTTP200ALIASES ||                                      \
+   (option) == CURLOPT_HTTPHEADER ||                                          \
+   (option) == CURLOPT_MAIL_RCPT ||                                           \
+   (option) == CURLOPT_POSTQUOTE ||                                           \
+   (option) == CURLOPT_PREQUOTE ||                                            \
+   (option) == CURLOPT_PROXYHEADER ||                                         \
+   (option) == CURLOPT_QUOTE ||                                               \
+   (option) == CURLOPT_RESOLVE ||                                             \
+   (option) == CURLOPT_TELNETOPTIONS ||                                       \
+   (option) == CURLOPT_CONNECT_TO ||                                          \
+   0)
+
+/* groups of curl_easy_getinfo infos that take the same type of argument */
+
+/* evaluates to true if info expects a pointer to char * argument */
+#define curlcheck_string_info(info)                             \
+  (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG &&        \
+   (info) != CURLINFO_PRIVATE)
+
+/* evaluates to true if info expects a pointer to long argument */
+#define curlcheck_long_info(info)                       \
+  (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
+
+/* evaluates to true if info expects a pointer to double argument */
+#define curlcheck_double_info(info)                     \
+  (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
+
+/* true if info expects a pointer to struct curl_slist * argument */
+#define curlcheck_slist_info(info)                                      \
+  (((info) == CURLINFO_SSL_ENGINES) || ((info) == CURLINFO_COOKIELIST))
+
+/* true if info expects a pointer to struct curl_tlssessioninfo * argument */
+#define curlcheck_tlssessioninfo_info(info)                              \
+  (((info) == CURLINFO_TLS_SSL_PTR) || ((info) == CURLINFO_TLS_SESSION))
+
+/* true if info expects a pointer to struct curl_certinfo * argument */
+#define curlcheck_certinfo_info(info) ((info) == CURLINFO_CERTINFO)
+
+/* true if info expects a pointer to struct curl_socket_t argument */
+#define curlcheck_socket_info(info)                     \
+  (CURLINFO_SOCKET < (info) && (info) < CURLINFO_OFF_T)
+
+/* true if info expects a pointer to curl_off_t argument */
+#define curlcheck_off_t_info(info)              \
+  (CURLINFO_OFF_T < (info))
+
+/*
+ * typecheck helpers -- check whether given expression has requested type
+ */
+
+/* For pointers, you can use the curlcheck_ptr/curlcheck_arr macros,
+ * otherwise define a new macro. Search for __builtin_types_compatible_p
+ * in the GCC manual.
+ * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
+ * the actual expression passed to the curl_easy_setopt macro. This
+ * means that you can only apply the sizeof and __typeof__ operators, no
+ * == or whatsoever.
+ */
+
+/* XXX: should evaluate to true if expr is a pointer */
+#define curlcheck_any_ptr(expr)                 \
+  (sizeof(expr) == sizeof(void *))
+
+/* evaluates to true if expr is NULL */
+/* XXX: must not evaluate expr, so this check is not accurate */
+#define curlcheck_NULL(expr)                                            \
+  (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
+
+/* evaluates to true if expr is type*, const type* or NULL */
+#define curlcheck_ptr(expr, type)                                       \
+  (curlcheck_NULL(expr) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), type *) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), const type *))
+
+/* evaluates to true if expr is type**, const type** or NULL */
+#define curlcheck_ptrptr(expr, type)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), type **) ||           \
+   __builtin_types_compatible_p(__typeof__(expr), type *[]) ||          \
+   __builtin_types_compatible_p(__typeof__(expr), const type *[]) ||    \
+   __builtin_types_compatible_p(__typeof__(expr), const type **))
+
+/* evaluates to true if expr is one of type[], type*, NULL or const type* */
+#define curlcheck_arr(expr, type)                                       \
+  (curlcheck_ptr((expr), type) ||                                       \
+   __builtin_types_compatible_p(__typeof__(expr), type []))
+
+/* evaluates to true if expr is a string */
+#define curlcheck_string(expr)                                          \
+  (curlcheck_arr((expr), char) ||                                       \
+   curlcheck_arr((expr), signed char) ||                                \
+   curlcheck_arr((expr), unsigned char))
+
+/* evaluates to true if expr is a CURL * */
+#define curlcheck_curl(expr)                                            \
+  (curlcheck_NULL(expr) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), CURL *))
+
+/* evaluates to true if expr is a long (no matter the signedness)
+ * XXX: for now, int is also accepted (and therefore short and char, which
+ * are promoted to int when passed to a variadic function) */
+#define curlcheck_long(expr)                                            \
+  (                                                                     \
+  ((sizeof(long) != sizeof(int)) &&                                     \
+   (__builtin_types_compatible_p(__typeof__(expr), long) ||             \
+    __builtin_types_compatible_p(__typeof__(expr), signed long) ||      \
+    __builtin_types_compatible_p(__typeof__(expr), unsigned long)))     \
+  ||                                                                    \
+  ((sizeof(long) == sizeof(int)) &&                                     \
+  (__builtin_types_compatible_p(__typeof__(expr), long) ||              \
+   __builtin_types_compatible_p(__typeof__(expr), signed long) ||       \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned long) ||     \
+   __builtin_types_compatible_p(__typeof__(expr), int) ||               \
+   __builtin_types_compatible_p(__typeof__(expr), signed int) ||        \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned int) ||      \
+   __builtin_types_compatible_p(__typeof__(expr), short) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), signed short) ||      \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned short) ||    \
+   __builtin_types_compatible_p(__typeof__(expr), char) ||              \
+   __builtin_types_compatible_p(__typeof__(expr), signed char) ||       \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned char)))      \
+                                                                  )
+
+/* evaluates to true if expr is of type curl_off_t */
+#define curlcheck_off_t(expr)                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
+
+/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
+/* XXX: also check size of an char[] array? */
+#define curlcheck_error_buffer(expr)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), char *) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), char[]))
+
+/* evaluates to true if expr is of type (const) void* or (const) FILE* */
+#if 0
+#define curlcheck_cb_data(expr)                                         \
+  (curlcheck_ptr((expr), void) ||                                       \
+   curlcheck_ptr((expr), FILE))
+#else /* be less strict */
+#define curlcheck_cb_data(expr)                                         \
+  curlcheck_any_ptr(expr)
+#endif
+
+/* evaluates to true if expr is of type FILE* */
+#define curlcheck_FILE(expr)                                            \
+  (curlcheck_NULL(expr) ||                                              \
+   (__builtin_types_compatible_p(__typeof__(expr), FILE *)))
+
+/* evaluates to true if expr can be passed as POST data (void* or char*) */
+#define curlcheck_postfields(expr)                                      \
+  (curlcheck_ptr((expr), void) ||                                       \
+   curlcheck_arr((expr), char) ||                                       \
+   curlcheck_arr((expr), unsigned char))
+
+/* helper: __builtin_types_compatible_p distinguishes between functions and
+ * function pointers, hide it */
+#define curlcheck_cb_compatible(func, type)                             \
+  (__builtin_types_compatible_p(__typeof__(func), type) ||              \
+   __builtin_types_compatible_p(__typeof__(func) *, type))
+
+/* evaluates to true if expr is of type curl_resolver_start_callback */
+#define curlcheck_resolver_start_callback(expr)       \
+  (curlcheck_NULL(expr) || \
+   curlcheck_cb_compatible((expr), curl_resolver_start_callback))
+
+/* evaluates to true if expr is of type curl_read_callback or "similar" */
+#define curlcheck_read_cb(expr)                                         \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), __typeof__(fread) *) ||              \
+   curlcheck_cb_compatible((expr), curl_read_callback) ||               \
+   curlcheck_cb_compatible((expr), Wcurl_read_callback1) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_read_callback2) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_read_callback3) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_read_callback4) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_read_callback5) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_read_callback6))
+typedef size_t (*Wcurl_read_callback1)(char *, size_t, size_t, void *);
+typedef size_t (*Wcurl_read_callback2)(char *, size_t, size_t, const void *);
+typedef size_t (*Wcurl_read_callback3)(char *, size_t, size_t, FILE *);
+typedef size_t (*Wcurl_read_callback4)(void *, size_t, size_t, void *);
+typedef size_t (*Wcurl_read_callback5)(void *, size_t, size_t, const void *);
+typedef size_t (*Wcurl_read_callback6)(void *, size_t, size_t, FILE *);
+
+/* evaluates to true if expr is of type curl_write_callback or "similar" */
+#define curlcheck_write_cb(expr)                                        \
+  (curlcheck_read_cb(expr) ||                                           \
+   curlcheck_cb_compatible((expr), __typeof__(fwrite) *) ||             \
+   curlcheck_cb_compatible((expr), curl_write_callback) ||              \
+   curlcheck_cb_compatible((expr), Wcurl_write_callback1) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_write_callback2) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_write_callback3) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_write_callback4) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_write_callback5) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_write_callback6))
+typedef size_t (*Wcurl_write_callback1)(const char *, size_t, size_t, void *);
+typedef size_t (*Wcurl_write_callback2)(const char *, size_t, size_t,
+                                       const void *);
+typedef size_t (*Wcurl_write_callback3)(const char *, size_t, size_t, FILE *);
+typedef size_t (*Wcurl_write_callback4)(const void *, size_t, size_t, void *);
+typedef size_t (*Wcurl_write_callback5)(const void *, size_t, size_t,
+                                       const void *);
+typedef size_t (*Wcurl_write_callback6)(const void *, size_t, size_t, FILE *);
+
+/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
+#define curlcheck_ioctl_cb(expr)                                        \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_ioctl_callback) ||              \
+   curlcheck_cb_compatible((expr), Wcurl_ioctl_callback1) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_ioctl_callback2) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_ioctl_callback3) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_ioctl_callback4))
+typedef curlioerr (*Wcurl_ioctl_callback1)(CURL *, int, void *);
+typedef curlioerr (*Wcurl_ioctl_callback2)(CURL *, int, const void *);
+typedef curlioerr (*Wcurl_ioctl_callback3)(CURL *, curliocmd, void *);
+typedef curlioerr (*Wcurl_ioctl_callback4)(CURL *, curliocmd, const void *);
+
+/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
+#define curlcheck_sockopt_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_sockopt_callback) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_sockopt_callback1) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_sockopt_callback2))
+typedef int (*Wcurl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
+typedef int (*Wcurl_sockopt_callback2)(const void *, curl_socket_t,
+                                      curlsocktype);
+
+/* evaluates to true if expr is of type curl_opensocket_callback or
+   "similar" */
+#define curlcheck_opensocket_cb(expr)                                   \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_opensocket_callback) ||         \
+   curlcheck_cb_compatible((expr), Wcurl_opensocket_callback1) ||       \
+   curlcheck_cb_compatible((expr), Wcurl_opensocket_callback2) ||       \
+   curlcheck_cb_compatible((expr), Wcurl_opensocket_callback3) ||       \
+   curlcheck_cb_compatible((expr), Wcurl_opensocket_callback4))
+typedef curl_socket_t (*Wcurl_opensocket_callback1)
+  (void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (*Wcurl_opensocket_callback2)
+  (void *, curlsocktype, const struct curl_sockaddr *);
+typedef curl_socket_t (*Wcurl_opensocket_callback3)
+  (const void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (*Wcurl_opensocket_callback4)
+  (const void *, curlsocktype, const struct curl_sockaddr *);
+
+/* evaluates to true if expr is of type curl_progress_callback or "similar" */
+#define curlcheck_progress_cb(expr)                                     \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_progress_callback) ||           \
+   curlcheck_cb_compatible((expr), Wcurl_progress_callback1) ||         \
+   curlcheck_cb_compatible((expr), Wcurl_progress_callback2))
+typedef int (*Wcurl_progress_callback1)(void *,
+    double, double, double, double);
+typedef int (*Wcurl_progress_callback2)(const void *,
+    double, double, double, double);
+
+/* evaluates to true if expr is of type curl_xferinfo_callback */
+#define curlcheck_xferinfo_cb(expr)                                     \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_xferinfo_callback))
+
+/* evaluates to true if expr is of type curl_debug_callback or "similar" */
+#define curlcheck_debug_cb(expr)                                        \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_debug_callback) ||              \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback1) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback2) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback3) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback4) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback5) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback6) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback7) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_debug_callback8))
+typedef int (*Wcurl_debug_callback1) (CURL *,
+    curl_infotype, char *, size_t, void *);
+typedef int (*Wcurl_debug_callback2) (CURL *,
+    curl_infotype, char *, size_t, const void *);
+typedef int (*Wcurl_debug_callback3) (CURL *,
+    curl_infotype, const char *, size_t, void *);
+typedef int (*Wcurl_debug_callback4) (CURL *,
+    curl_infotype, const char *, size_t, const void *);
+typedef int (*Wcurl_debug_callback5) (CURL *,
+    curl_infotype, unsigned char *, size_t, void *);
+typedef int (*Wcurl_debug_callback6) (CURL *,
+    curl_infotype, unsigned char *, size_t, const void *);
+typedef int (*Wcurl_debug_callback7) (CURL *,
+    curl_infotype, const unsigned char *, size_t, void *);
+typedef int (*Wcurl_debug_callback8) (CURL *,
+    curl_infotype, const unsigned char *, size_t, const void *);
+
+/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
+/* this is getting even messier... */
+#define curlcheck_ssl_ctx_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_ssl_ctx_callback) ||            \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback1) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback2) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback3) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback4) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback5) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback6) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback7) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_ssl_ctx_callback8))
+typedef CURLcode (*Wcurl_ssl_ctx_callback1)(CURL *, void *, void *);
+typedef CURLcode (*Wcurl_ssl_ctx_callback2)(CURL *, void *, const void *);
+typedef CURLcode (*Wcurl_ssl_ctx_callback3)(CURL *, const void *, void *);
+typedef CURLcode (*Wcurl_ssl_ctx_callback4)(CURL *, const void *,
+                                            const void *);
+#ifdef HEADER_SSL_H
+/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
+ * this will of course break if we are included before OpenSSL headers...
+ */
+typedef CURLcode (*Wcurl_ssl_ctx_callback5)(CURL *, SSL_CTX *, void *);
+typedef CURLcode (*Wcurl_ssl_ctx_callback6)(CURL *, SSL_CTX *, const void *);
+typedef CURLcode (*Wcurl_ssl_ctx_callback7)(CURL *, const SSL_CTX *, void *);
+typedef CURLcode (*Wcurl_ssl_ctx_callback8)(CURL *, const SSL_CTX *,
+                                            const void *);
+#else
+typedef Wcurl_ssl_ctx_callback1 Wcurl_ssl_ctx_callback5;
+typedef Wcurl_ssl_ctx_callback1 Wcurl_ssl_ctx_callback6;
+typedef Wcurl_ssl_ctx_callback1 Wcurl_ssl_ctx_callback7;
+typedef Wcurl_ssl_ctx_callback1 Wcurl_ssl_ctx_callback8;
+#endif
+
+/* evaluates to true if expr is of type curl_conv_callback or "similar" */
+#define curlcheck_conv_cb(expr)                                         \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_conv_callback) ||               \
+   curlcheck_cb_compatible((expr), Wcurl_conv_callback1) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_conv_callback2) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_conv_callback3) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_conv_callback4))
+typedef CURLcode (*Wcurl_conv_callback1)(char *, size_t length);
+typedef CURLcode (*Wcurl_conv_callback2)(const char *, size_t length);
+typedef CURLcode (*Wcurl_conv_callback3)(void *, size_t length);
+typedef CURLcode (*Wcurl_conv_callback4)(const void *, size_t length);
+
+/* evaluates to true if expr is of type curl_seek_callback or "similar" */
+#define curlcheck_seek_cb(expr)                                         \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_seek_callback) ||               \
+   curlcheck_cb_compatible((expr), Wcurl_seek_callback1) ||             \
+   curlcheck_cb_compatible((expr), Wcurl_seek_callback2))
+typedef CURLcode (*Wcurl_seek_callback1)(void *, curl_off_t, int);
+typedef CURLcode (*Wcurl_seek_callback2)(const void *, curl_off_t, int);
+
+/* evaluates to true if expr is of type curl_chunk_bgn_callback */
+#define curlcheck_chunk_bgn_cb(expr)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_chunk_bgn_callback) ||          \
+   curlcheck_cb_compatible((expr), Wcurl_chunk_bgn_callback1) ||        \
+   curlcheck_cb_compatible((expr), Wcurl_chunk_bgn_callback2))
+typedef long (*Wcurl_chunk_bgn_callback1)(struct curl_fileinfo *,
+                                          void *, int);
+typedef long (*Wcurl_chunk_bgn_callback2)(void *, void *, int);
+
+/* evaluates to true if expr is of type curl_chunk_end_callback */
+#define curlcheck_chunk_end_cb(expr)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_chunk_end_callback))
+
+/* evaluates to true if expr is of type curl_closesocket_callback */
+#define curlcheck_close_socket_cb(expr)                                 \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_closesocket_callback))
+
+/* evaluates to true if expr is of type curl_fnmatch_callback */
+#define curlcheck_fnmatch_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_fnmatch_callback))
+
+/* evaluates to true if expr is of type curl_hstsread_callback */
+#define curlcheck_hstsread_cb(expr)                                     \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_hstsread_callback))
+
+/* evaluates to true if expr is of type curl_hstswrite_callback */
+#define curlcheck_hstswrite_cb(expr)                                    \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_hstswrite_callback))
+
+/* evaluates to true if expr is of type curl_sshhostkeycallback */
+#define curlcheck_ssh_hostkey_cb(expr)                                  \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_sshhostkeycallback))
+
+/* evaluates to true if expr is of type curl_sshkeycallback */
+#define curlcheck_ssh_key_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_sshkeycallback))
+
+/* evaluates to true if expr is of type curl_interleave_callback */
+#define curlcheck_interleave_cb(expr)                                   \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), Wcurl_interleave_callback1) ||       \
+   curlcheck_cb_compatible((expr), Wcurl_interleave_callback2))
+typedef size_t (*Wcurl_interleave_callback1)(void *p, size_t s,
+                                             size_t n, void *u);
+typedef size_t (*Wcurl_interleave_callback2)(char *p, size_t s,
+                                             size_t n, void *u);
+
+/* evaluates to true if expr is of type curl_prereq_callback */
+#define curlcheck_prereq_cb(expr)                                       \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_prereq_callback))
+
+/* evaluates to true if expr is of type curl_trailer_callback */
+#define curlcheck_trailer_cb(expr)                                      \
+  (curlcheck_NULL(expr) ||                                              \
+   curlcheck_cb_compatible((expr), curl_trailer_callback))
+
+#endif /* CURLINC_TYPECHECK_GCC_H */

entry/src/main/cpp/include/curl/urlapi.h

@@ -0,0 +1,155 @@
+#ifndef CURLINC_URLAPI_H
+#define CURLINC_URLAPI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#include "curl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* the error codes for the URL API */
+typedef enum {
+  CURLUE_OK,
+  CURLUE_BAD_HANDLE,          /* 1 */
+  CURLUE_BAD_PARTPOINTER,     /* 2 */
+  CURLUE_MALFORMED_INPUT,     /* 3 */
+  CURLUE_BAD_PORT_NUMBER,     /* 4 */
+  CURLUE_UNSUPPORTED_SCHEME,  /* 5 */
+  CURLUE_URLDECODE,           /* 6 */
+  CURLUE_OUT_OF_MEMORY,       /* 7 */
+  CURLUE_USER_NOT_ALLOWED,    /* 8 */
+  CURLUE_UNKNOWN_PART,        /* 9 */
+  CURLUE_NO_SCHEME,           /* 10 */
+  CURLUE_NO_USER,             /* 11 */
+  CURLUE_NO_PASSWORD,         /* 12 */
+  CURLUE_NO_OPTIONS,          /* 13 */
+  CURLUE_NO_HOST,             /* 14 */
+  CURLUE_NO_PORT,             /* 15 */
+  CURLUE_NO_QUERY,            /* 16 */
+  CURLUE_NO_FRAGMENT,         /* 17 */
+  CURLUE_NO_ZONEID,           /* 18 */
+  CURLUE_BAD_FILE_URL,        /* 19 */
+  CURLUE_BAD_FRAGMENT,        /* 20 */
+  CURLUE_BAD_HOSTNAME,        /* 21 */
+  CURLUE_BAD_IPV6,            /* 22 */
+  CURLUE_BAD_LOGIN,           /* 23 */
+  CURLUE_BAD_PASSWORD,        /* 24 */
+  CURLUE_BAD_PATH,            /* 25 */
+  CURLUE_BAD_QUERY,           /* 26 */
+  CURLUE_BAD_SCHEME,          /* 27 */
+  CURLUE_BAD_SLASHES,         /* 28 */
+  CURLUE_BAD_USER,            /* 29 */
+  CURLUE_LACKS_IDN,           /* 30 */
+  CURLUE_TOO_LARGE,           /* 31 */
+  CURLUE_LAST
+} CURLUcode;
+
+typedef enum {
+  CURLUPART_URL,
+  CURLUPART_SCHEME,
+  CURLUPART_USER,
+  CURLUPART_PASSWORD,
+  CURLUPART_OPTIONS,
+  CURLUPART_HOST,
+  CURLUPART_PORT,
+  CURLUPART_PATH,
+  CURLUPART_QUERY,
+  CURLUPART_FRAGMENT,
+  CURLUPART_ZONEID /* added in 7.65.0 */
+} CURLUPart;
+
+#define CURLU_DEFAULT_PORT (1 << 0)       /* return default port number */
+#define CURLU_NO_DEFAULT_PORT (1 << 1)    /* act as if no port number was set,
+                                             if the port number matches the
+                                             default for the scheme */
+#define CURLU_DEFAULT_SCHEME (1 << 2)     /* return default scheme if
+                                             missing */
+#define CURLU_NON_SUPPORT_SCHEME (1 << 3) /* allow non-supported scheme */
+#define CURLU_PATH_AS_IS (1 << 4)         /* leave dot sequences */
+#define CURLU_DISALLOW_USER (1 << 5)      /* no user+password allowed */
+#define CURLU_URLDECODE (1 << 6)          /* URL decode on get */
+#define CURLU_URLENCODE (1 << 7)          /* URL encode on set */
+#define CURLU_APPENDQUERY (1 << 8)        /* append a form style part */
+#define CURLU_GUESS_SCHEME (1 << 9)       /* legacy curl-style guessing */
+#define CURLU_NO_AUTHORITY (1 << 10)      /* Allow empty authority when the
+                                             scheme is unknown. */
+#define CURLU_ALLOW_SPACE (1 << 11)       /* Allow spaces in the URL */
+#define CURLU_PUNYCODE (1 << 12)          /* get the hostname in punycode */
+#define CURLU_PUNY2IDN (1 << 13)          /* punycode => IDN conversion */
+#define CURLU_GET_EMPTY (1 << 14)         /* allow empty queries and fragments
+                                             when extracting the URL or the
+                                             components */
+#define CURLU_NO_GUESS_SCHEME (1 << 15)   /* for get, do not accept a guess */
+
+typedef struct Curl_URL CURLU;
+
+/*
+ * curl_url() creates a new CURLU handle and returns a pointer to it.
+ * Must be freed with curl_url_cleanup().
+ */
+CURL_EXTERN CURLU *curl_url(void);
+
+/*
+ * curl_url_cleanup() frees the CURLU handle and related resources used for
+ * the URL parsing. It will not free strings previously returned with the URL
+ * API.
+ */
+CURL_EXTERN void curl_url_cleanup(CURLU *handle);
+
+/*
+ * curl_url_dup() duplicates a CURLU handle and returns a new copy. The new
+ * handle must also be freed with curl_url_cleanup().
+ */
+CURL_EXTERN CURLU *curl_url_dup(const CURLU *in);
+
+/*
+ * curl_url_get() extracts a specific part of the URL from a CURLU
+ * handle. Returns error code. The returned pointer MUST be freed with
+ * curl_free() afterwards.
+ */
+CURL_EXTERN CURLUcode curl_url_get(const CURLU *handle, CURLUPart what,
+                                   char **part, unsigned int flags);
+
+/*
+ * curl_url_set() sets a specific part of the URL in a CURLU handle. Returns
+ * error code. The passed in string will be copied. Passing a NULL instead of
+ * a part string, clears that part.
+ */
+CURL_EXTERN CURLUcode curl_url_set(CURLU *handle, CURLUPart what,
+                                   const char *part, unsigned int flags);
+
+/*
+ * curl_url_strerror() turns a CURLUcode value into the equivalent human
+ * readable error string. This is useful for printing meaningful error
+ * messages.
+ */
+CURL_EXTERN const char *curl_url_strerror(CURLUcode);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* CURLINC_URLAPI_H */

entry/src/main/cpp/include/curl/websockets.h

@@ -0,0 +1,98 @@
+#ifndef CURLINC_WEBSOCKETS_H
+#define CURLINC_WEBSOCKETS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct curl_ws_frame {
+  int age;              /* zero */
+  int flags;            /* See the CURLWS_* defines */
+  curl_off_t offset;    /* the offset of this data into the frame */
+  curl_off_t bytesleft; /* number of pending bytes left of the payload */
+  size_t len;           /* size of the current data chunk */
+};
+
+/* flag bits */
+#define CURLWS_TEXT       (1 << 0)
+#define CURLWS_BINARY     (1 << 1)
+#define CURLWS_CONT       (1 << 2)
+#define CURLWS_CLOSE      (1 << 3)
+#define CURLWS_PING       (1 << 4)
+#define CURLWS_OFFSET     (1 << 5)
+
+/*
+ * NAME curl_ws_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the websocket connection. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
+                                  size_t *recv,
+                                  const struct curl_ws_frame **metap);
+
+/* flags for curl_ws_send() */
+#define CURLWS_PONG       (1 << 6)
+
+/*
+ * NAME curl_ws_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the websocket connection. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_ws_send(CURL *curl, const void *buffer,
+                                  size_t buflen, size_t *sent,
+                                  curl_off_t fragsize,
+                                  unsigned int flags);
+
+/*
+ * NAME curl_ws_start_frame()
+ *
+ * DESCRIPTION
+ *
+ * Buffers a websocket frame header with the given flags and length.
+ * Errors when a previous frame is not complete, e.g. not all its
+ * payload has been added.
+ */
+CURL_EXTERN CURLcode curl_ws_start_frame(CURL *curl,
+                                         unsigned int flags,
+                                         curl_off_t frame_len);
+
+/* bits for the CURLOPT_WS_OPTIONS bitmask: */
+#define CURLWS_RAW_MODE   (1L << 0)
+#define CURLWS_NOAUTOPONG (1L << 1)
+
+CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *curl);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CURLINC_WEBSOCKETS_H */

entry/src/main/cpp/napi_init.cpp

@@ -1,119 +1,333 @@
 #include "napi/native_api.h"
 //#include "OCCTRenderThread/OCCTRenderThread.h"
-#include <map>
+#include <stdio.h>
+#include <unistd.h>
 #include <string>
+#include <map>
+#include <mutex>
+//#include <ace/xcomponent/native_interface_xcomponent.h>
 
-//#define LOG_TAG "NAPI_INIT"
+//using namespace OCCTRenderer;
-//#define LOGI(...) (LOG_TAG, __VA_ARGS__)
 //
-////存储 XComponent ID 到 OCCTRenderThread 实例的映射
+//// 存储XComponent ID到渲染线程的映射
-//static std::map<std::string, OCCTRenderThread*> g_renderThreads;
+//static std::map<int64_t, std::shared_ptr<OCCTRenderThread>> renderThreadMap;
+//static std::mutex mapMutex;
 //
-////NAPI: 初始化渲染器（绑定 XComponent）
+//// XComponent回调
-//static napi_value InitRenderer(napi_env env, napi_callback_info info) {
+//static void OnSurfaceCreated(XComponent* component, void* window)
+//{
+//    OH_NativeXComponent* nativeXComponent = reinterpret_cast<OH_NativeXComponent*>(component);
+//    int64_t id = 0;
+//    OH_NativeXComponent_GetXComponentId(nativeXComponent, &id);
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) == renderThreadMap.end()) {
+//            auto renderThread = std::make_shared<OCCTRenderThread>();
+//            renderThreadMap[id] = renderThread;
+//            
+//            // 启动渲染线程
+//            renderThread->start(reinterpret_cast<OHNativeWindow*>(window));
+//        }
+//    }
+//    
+//    printf("Surface created for component id: %lld\n", static_cast<long long>(id));
+//}
+//
+//static void OnSurfaceChanged(XComponent* component, void* window, int32_t width, int32_t height)
+//{
+//    OH_NativeXComponent* nativeXComponent = reinterpret_cast<OH_NativeXComponent*>(component);
+//    int64_t id = 0;
+//    OH_NativeXComponent_GetXComponentId(nativeXComponent, &id);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->resizeWindow(width, height);
+//        }
+//    }
+//    
+//    printf("Surface changed for component id: %lld, width: %d, height: %d\n", 
+//           static_cast<long long>(id), width, height);
+//}
+//
+//static void OnSurfaceDestroyed(XComponent* component, void* window)
+//{
+//    OH_NativeXComponent* nativeXComponent = reinterpret_cast<OH_NativeXComponent*>(component);
+//    int64_t id = 0;
+//    OH_NativeXComponent_GetXComponentId(nativeXComponent, &id);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->stop();
+//            renderThreadMap.erase(id);
+//        }
+//    }
+//    
+//    printf("Surface destroyed for component id: %lld\n", static_cast<long long>(id));
+//}
+//
+//// 渲染完成回调
+//static void OnRenderComplete()
+//{
+//    // 这里可以通知JS层渲染完成，例如发送事件
+//}
+//
+//// 旋转模型
+//static napi_value RotateModel(napi_env env, napi_value info)
+//{
 //    size_t argc = 3;
-//    napi_value args[3];
+//    napi_value args[3] = {nullptr};
 //    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
-//
+//    
-//    // 参数1: xcomponentId (string)
+//    if (argc < 3) {
-//    char xcompId[256];
+//        napi_throw_error(env, nullptr, "Wrong number of arguments");
-//    size_t xcompIdLen;
+//        return nullptr;
-//    napi_get_value_string_utf8(env, args[0], xcompId, sizeof(xcompId), &xcompIdLen);
-//
-//    // 参数2: nativeWindow (EGLNativeWindowType, 实际是 void*)
-//    EGLNativeWindowType window = nullptr;
-//    napi_get_value_external(env, args[1], reinterpret_cast<void**>(&window));
-//
-//    // 参数3: { width, height }
-//    int32_t width = 0, height = 0;
-//    napi_valuetype type;
-//    napi_typeof(env, args[2], &type);
-//    if (type == napi_object) {
-//        napi_value w, h;
-//        napi_get_named_property(env, args[2], "width", &w);
-//        napi_get_named_property(env, args[2], "height", &h);
-//        napi_get_value_int32(env, w, &width);
-//        napi_get_value_int32(env, h, &height);
 //    }
-//
+//    
-//    // 创建渲染线程
+//    int64_t id = 0;
-//    LOGI('Init RenderThread');
+//    double xAngle = 0.0;
-//    auto* renderThread = new OCCTRenderThread(window, width, height);
+//    double yAngle = 0.0;
-//    renderThread->start();
+//    
-//    LOGI('Deno Init RenderThread');
+//    napi_get_value_int64(env, args[0], &id);
-//    g_renderThreads[std::string(xcompId)] = renderThread;
+//    napi_get_value_double(env, args[1], &xAngle);
-//
+//    napi_get_value_double(env, args[2], &yAngle);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->setRotation(static_cast<float>(xAngle), static_cast<float>(yAngle));
+//        }
+//    }
+//    
 //    return nullptr;
 //}
 //
-//// NAPI: 加载 STEP 模型
+//// 平移模型
-//static napi_value LoadModel(napi_env env, napi_callback_info info) {
+//static napi_value TranslateModel(napi_env env, napi_value info)
-//    LOGI('Start LoadModel');
+//{
-//    size_t argc = 2;
-//    napi_value args[2];
-//    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
-//
-//    char xcompId[256];
-//    size_t len;
-//    napi_get_value_string_utf8(env, args[0], xcompId, sizeof(xcompId), &len);
-//
-//    char modelPath[1024];
-//    size_t pathLen;
-//    napi_get_value_string_utf8(env, args[1], modelPath, sizeof(modelPath), &pathLen);
-//    LOGI('Find RenderThread');
-//    auto it = g_renderThreads.find(std::string(xcompId));
-//    if (it != g_renderThreads.end()) {
-//        LOGI('LoadModel Began');
-//        it->second->loadModel(modelPath);
-//    }
-//
-//    return nullptr;
-//}
-//
-//// NAPI: 鼠标/触摸事件（可选，用于旋转）
-//static napi_value OnMouseEvent(napi_env env, napi_callback_info info) {
 //    size_t argc = 3;
-//    napi_value args[3];
+//    napi_value args[3] = {nullptr};
 //    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
-//
+//    
-//    char xcompId[256];
+//    if (argc < 3) {
-//    size_t len;
+//        napi_throw_error(env, nullptr, "Wrong number of arguments");
-//    napi_get_value_string_utf8(env, args[0], xcompId, sizeof(xcompId), &len);
+//        return nullptr;
-//
-//    double dx, dy;
-//    napi_get_value_double(env, args[1], &dx);
-//    napi_get_value_double(env, args[2], &dy);
-//
-//    auto it = g_renderThreads.find(std::string(xcompId));
-//    if (it != g_renderThreads.end()) {
-//        it->second->onMouseEvent(static_cast<float>(dx), static_cast<float>(dy));
 //    }
-//
+//    
+//    int64_t id = 0;
+//    double x = 0.0;
+//    double y = 0.0;
+//    
+//    napi_get_value_int64(env, args[0], &id);
+//    napi_get_value_double(env, args[1], &x);
+//    napi_get_value_double(env, args[2], &y);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->setTranslation(static_cast<float>(x), static_cast<float>(y));
+//        }
+//    }
+//    
 //    return nullptr;
 //}
 //
-//// NAPI: 销毁渲染器
+//// 重置视图
-//static napi_value DestroyRenderer(napi_env env, napi_callback_info info) {
+//static napi_value ResetView(napi_env env, napi_value info)
+//{
 //    size_t argc = 1;
-//    napi_value args[1];
+//    napi_value args[1] = {nullptr};
 //    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
-//
+//    
-//    char xcompId[256];
+//    if (argc < 1) {
-//    size_t len;
+//        napi_throw_error(env, nullptr, "Wrong number of arguments");
-//    napi_get_value_string_utf8(env, args[0], xcompId, sizeof(xcompId), &len);
+//        return nullptr;
-//
-//    auto it = g_renderThreads.find(std::string(xcompId));
-//    if (it != g_renderThreads.end()) {
-//        it->second->stop();
-//        delete it->second;
-//        g_renderThreads.erase(it);
 //    }
-//
+//    
+//    int64_t id = 0;
+//    napi_get_value_int64(env, args[0], &id);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->resetView();
+//        }
+//    }
+//    
 //    return nullptr;
 //}
+//
+//// 设置背景颜色
+//static napi_value SetClearColor(napi_env env, napi_value info)
+//{
+//    size_t argc = 5;
+//    napi_value args[5] = {nullptr};
+//    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+//    
+//    if (argc < 5) {
+//        napi_throw_error(env, nullptr, "Wrong number of arguments");
+//        return nullptr;
+//    }
+//    
+//    int64_t id = 0;
+//    double r = 0.0, g = 0.0, b = 0.0, a = 0.0;
+//    
+//    napi_get_value_int64(env, args[0], &id);
+//    napi_get_value_double(env, args[1], &r);
+//    napi_get_value_double(env, args[2], &g);
+//    napi_get_value_double(env, args[3], &b);
+//    napi_get_value_double(env, args[4], &a);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->setClearColor(static_cast<float>(r), static_cast<float>(g), 
+//                                              static_cast<float>(b), static_cast<float>(a));
+//        }
+//    }
+//    
+//    return nullptr;
+//}
+//
+//// 加载STEP模型
+//static napi_value LoadStepModel(napi_env env, napi_value info)
+//{
+//    size_t argc = 2;
+//    napi_value args[2] = {nullptr};
+//    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+//    
+//    if (argc < 2) {
+//        napi_throw_error(env, nullptr, "Wrong number of arguments");
+//        return nullptr;
+//    }
+//    
+//    int64_t id = 0;
+//    char path[1024] = {0};
+//    size_t pathLen = 0;
+//    
+//    napi_get_value_int64(env, args[0], &id);
+//    napi_get_value_string_utf8(env, args[1], path, sizeof(path), &pathLen);
+//    
+//    {
+//        std::lock_guard<std::mutex> lock(mapMutex);
+//        if (renderThreadMap.find(id) != renderThreadMap.end()) {
+//            renderThreadMap[id]->loadModel(std::string(path));
+//        }
+//    }
+//    
+//    return nullptr;
+//}
+//
+//// 注册模块
+//static napi_value Init(napi_env env, napi_value exports)
+//{
+//    // 注册XComponent回调
+//    OH_NativeXComponent_Callback callback = {
+//        .OnSurfaceCreated = OnSurfaceCreated,
+//        .OnSurfaceChanged = OnSurfaceChanged,
+//        .OnSurfaceDestroyed = OnSurfaceDestroyed
+//    };
+//    
+//    napi_property_descriptor desc[] = {
+//        DECLARE_NAPI_FUNCTION("rotateModel", RotateModel),
+//        DECLARE_NAPI_FUNCTION("translateModel", TranslateModel),
+//        DECLARE_NAPI_FUNCTION("resetView", ResetView),
+//        DECLARE_NAPI_FUNCTION("setClearColor", SetClearColor),
+//        DECLARE_NAPI_FUNCTION("loadStepModel", LoadStepModel)
+//    };
+//    
+//    NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
+//    
+//    return exports;
+//}
+//
+//EXTERN_C_START
+///*
+// * 定义函数，用于注册NAPI模块
+// */
+//static napi_module OCCTModel = {
+//    .nm_version = 1,
+//    .nm_flags = 0,
+//    .nm_filename = nullptr,
+//    .nm_register_func = Init,
+//    .nm_modname = "OCCTRender",
+//    .nm_priv = ((void*)0),
+//    .reserved = {0}
+//};
+//
+///*
+// * 模块注册函数
+// */
+//extern "C" void NAPI_occtrenderer_GetJSClass(void)
+//{
+//    napi_module_register(&OCCTModel);
+//}
+//EXTERN_C_END
+#include "curl/curl.h"
 
-static napi_value Add(napi_env env, napi_callback_info info)
+// [StartExclude curl_request_cpp]
-{
+#include "napi/native_api.h"
+#include "hilog/log.h"
+#include <string>
+using namespace std;
+// [EndExclude curl_request_cpp]
+
+// Get request and post request data response functions
+size_t ReqReply(void *ptr, size_t size, size_t nmemb, void *userdata) {
+    string *str = reinterpret_cast<string *>(userdata);
+    (*str).append((char *)ptr, size * nmemb);
+    return size * nmemb;
+}
+
+// http GET Request configuration
+CURLcode CurlGetReq(const std::string &url, std::string &response) {
+    // Curl initialization
+    CURL *curl = curl_easy_init();
+    // Curl return value
+    CURLcode res;
+    if (curl) {
+        // Set the request header for Curl
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(headers, "Content-Type:application/json");
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+        // Set the URL address for the request
+        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+
+        // Receive response header data, 0 represents not receiving, 1 represents receiving
+        curl_easy_setopt(curl, CURLOPT_HEADER, 1);
+
+        // Set data receiving function
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ReqReply);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&response);
+
+        // Set to not use any signal/alarm handlers
+        curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
+
+        // Set timeout period
+        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);
+
+        // Open request
+        res = curl_easy_perform(curl);
+    }
+    // Release curl
+    curl_easy_cleanup(curl);
+    return res;
+}
+
+
+static napi_value NatReq(napi_env env, napi_callback_info info) {
+    string getUrlStr = "http://www.baidu.com";
+    string getResponseStr;
+    auto res = CurlGetReq(getUrlStr, getResponseStr);
+    if (res == CURLE_OK) {
+        OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, "pure", "response: \n%{public}s", getResponseStr.c_str());
+    }
+
+    // [StartExclude curl_request_cpp]
+    size_t requireArgc = 2;
     size_t argc = 2;
     napi_value args[2] = {nullptr};
 
@@ -135,40 +349,26 @@ static napi_value Add(napi_env env, napi_callback_info info)
     napi_create_double(env, value0 + value1, &sum);
 
     return sum;
+    // [EndExclude curl_request_cpp]
 }
+// [End curl_request_cpp]
 
 EXTERN_C_START
 static napi_value Init(napi_env env, napi_value exports) {
-    if ((env == nullptr) || (exports == nullptr)) {
+    napi_property_descriptor desc[] = {{"add", nullptr, NatReq, nullptr, nullptr, nullptr, napi_default, nullptr}};
-        return nullptr;
+    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
-    }
-    napi_property_descriptor desc[] = {
-        //{"initRenderer", nullptr, InitRenderer,nullptr, nullptr, nullptr, napi_default, nullptr},
-        //{"loadModel", nullptr, LoadModel,nullptr, nullptr, nullptr, napi_default, nullptr},
-        //{"onMouseEvent", nullptr, OnMouseEvent,nullptr, nullptr, nullptr, napi_default, nullptr},
-        //{"destroyRenderer", nullptr, DestroyRenderer,nullptr, nullptr, nullptr, napi_default, nullptr},
-        { "add", nullptr, Add, nullptr, nullptr, nullptr, napi_default, nullptr }
-    };
-    
-    if (napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc) != napi_ok) {
-        return nullptr;
-    }
     return exports;
 }
 EXTERN_C_END
 
-// 编写接口的描述信息，根据实际需要可以修改对应参数
+static napi_module nativecurl = {
-static napi_module OCCTModel = {
     .nm_version = 1,
     .nm_flags = 0,
     .nm_filename = nullptr,
     .nm_register_func = Init,
-    .nm_modname = "OCCTRender",
+    .nm_modname = "nativecurl",
-    .nm_priv = ((void*)0),
+    .nm_priv = ((void *)0),
-    .reserved = { 0 } 
+    .reserved = {0},
 };
 
-extern "C" __attribute__((constructor)) void RegisterModule(void)
+extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&nativecurl); }
-{
-    napi_module_register(&OCCTModel);
-}

entry/src/main/cpp/types/libOCCTRender/Index.d.ts

@@ -1,6 +1,46 @@
-// Index.d.ts
+/**
-//export const initRenderer:(id: string, nativeWindow: any, size: { width: number; height: number }) => void;
+ * OCCT 3D渲染器接口
-//export const loadModel:(id: string, modelPath: string)=> void;
+ */
-//export const onMouseEvent:(id: string, dx: number, dy: number)=> void;
+declare namespace OCCTRender {
-//export const destroyRenderer:(id: string)=> void;
+  /**
-export const add: (a: number, b: number) => number;
+   * 加载STEP模型文件
+   * @param componentId - XComponent组件ID
+   * @param filePath - STEP文件路径
+   */
+  function loadStepModel(componentId: number, filePath: string): void;
+
+  /**
+   * 旋转模型
+   * @param componentId - XComponent组件ID
+   * @param xAngle - X轴旋转角度(度)
+   * @param yAngle - Y轴旋转角度(度)
+   */
+  function rotateModel(componentId: number, xAngle: number, yAngle: number): void;
+
+  /**
+   * 平移模型
+   * @param componentId - XComponent组件ID
+   * @param x - X轴平移量
+   * @param y - Y轴平移量
+   */
+  function translateModel(componentId: number, x: number, y: number): void;
+
+  /**
+   * 重置视图到初始状态
+   * @param componentId - XComponent组件ID
+   */
+  function resetView(componentId: number): void;
+
+  /**
+   * 设置背景颜色
+   * @param componentId - XComponent组件ID
+   * @param r - 红色分量(0-1)
+   * @param g - 绿色分量(0-1)
+   * @param b - 蓝色分量(0-1)
+   * @param a - 透明度(0-1)
+   */
+  function setClearColor(componentId: number, r: number, g: number, b: number, a: number): void;
+}
+
+// 导出接口
+export default OCCTRender;

entry/src/main/cpp/types/libcurl/Index.d.ts

@@ -0,0 +1 @@
+export const add: (a: number, b: number) => number;

entry/src/main/cpp/types/libcurl/oh-package.json5

@@ -0,0 +1,6 @@
+{
+  "name": "libcurl.so",
+  "types": "./Index.d.ts",
+  "version": "1.0.0",
+  "description": "Please describe the basic information."
+}

entry/src/main/ets/pages/modelView.ets

@@ -1,18 +1,26 @@
 import { hilog } from '@kit.PerformanceAnalysisKit';
 import fs from '@ohos.file.fs';
 import fileIO from '@ohos.fileio';
-import { Context } from '@kit.AbilityKit';
 //import OCCTRender from 'libOCCTRender.so';
+import navitecurl from 'libcurl.so'
 
 const DOMAIN = 0x0000;
 
+// interface GeneratedTypeLiteralInterface_1 {
+//   xcomponentid?: number;
+// }
+
 @Component
 export struct ModelView {
-  private displayController: XComponentController = new XComponentController();
+  // XComponent控制器
-  private displayContrId: string = 'OCCTRenderer';
+  displayController: XComponentController = new XComponentController()
+  displayContrId: number = -1;
+  lastTouchX: number = 0
+  lastTouchY: number = 0
+  // 是否正在拖动
+  isDragging: boolean = false
   @State modelPath: string = '';
   @State modelName:string='model.step';
-  @State nativeWindow:string='';
   aboutToAppear() {
     this.copyRawFileToSandbox();
   }
@@ -46,63 +54,105 @@ export struct ModelView {
 }
   build() {
     Flex({ direction: FlexDirection.Column }) {
-      Button('加载模型').onClick(()=>{
+      Row() {
-        try {
+        Button('重置视角')
-          // 调用 native 初始化渲染器
+          .onClick(() => {
-          console.log('displayContrId:', this.displayContrId);
+            //OCCTRender.resetView(this.displayContrId)
-          console.log('NativeWindow:', this.nativeWindow);
+          })
-          console.log('ModelPath:', this.modelPath);
+        Button('更换模型')
-          hilog.info(0x0000, 'ModelView', 'Load Model');
+          .onClick(() => {
-          // 复制模型文件并获取路径
+            // 这里可以实现文件选择器
-          console.info('Model copied to:', this.modelPath);
+            //OCCTRender.loadStepModel(this.displayContrId, this.modelPath)
-          // 调用 native 加载
+            hilog.info(0x0000, 'testTag', 'Test NAPI 2 + 3 = %{public}d', navitecurl.add(2, 3));
-          //OCCTRender.loadModel(this.displayContrId, this.modelPath);
+          })
-        } catch (e) {
+        Button('CURL模块加载检测')
-          hilog.error(0x0000, 'ModelView', `LoadModel Failed: ${JSON.stringify(e)}`);
+          .onClick(() => {
-        }
+            try {
-      })
+              console.info(`[NDK] 模块类型: ${typeof navitecurl}`);
-      Button('日志测试').onClick(async()=>{
+              console.info(`[NDK] 模块值: ${JSON.stringify(navitecurl)}`);
-        //NAPI日志接口测试
+              console.info(`[NDK] 所有属性: ${Object.keys(navitecurl).join(', ')}`);
-        let OCCTRender = await import("libOCCTRender.so")
+              if (!navitecurl) throw new Error("模块为 undefined");
-        hilog.info(DOMAIN, 'testTag', 'Test NAPI 2 + 3 = %{public}d', OCCTRender.add(2, 3));
+              if (typeof navitecurl.add !== 'function') throw new Error("add 方法不存在");
-      })
+            } catch (e) {
+              console.error(`[NDK] 加载失败: ${e.message}`, e);
+              // 此处会触发你看到的错误
+            }
+          })
+      }
+      // .width('100%')
+      // .justifyContent(FlexAlign.SpaceEvenly)
       // XComponent({
-      //   id: this.displayContrId,
+      //   id: 'OCCTRenderer',
       //   type: 'surface',
       //   controller: this.displayController
       // })
-      //   .onLoad(() => {
+      //   .onLoad((nativeXComponent: undefined) => {
-      //     // 获取 native window（必须在 onLoad 后才能获取）
+      //     if (!nativeXComponent || typeof nativeXComponent !== 'object') {
-      //     this.nativeWindow = this.displayController.getXComponentSurfaceId();
+      //       console.error('[OCCT] Invalid nativeXComponent object');
-      //     if (this.nativeWindow === undefined || this.nativeWindow === '') {
-      //       hilog.error(0x0000, 'ModelView', 'Failed to get native window');
       //       return;
       //     }
-      //     // 获取 XComponent 尺寸
+      //
-      //     let width = 0;
+      //     const id = (nativeXComponent as GeneratedTypeLiteralInterface_1).xcomponentid;
-      //     let height = 0;
+      //     if (typeof id !== 'number' || id <= 0) {
+      //       console.error('[OCCT] Invalid display controller ID:', id);
+      //       return;
+      //     }
+      //
+      //     this.displayContrId = id; // ✅ 赋值到新变量
+      //     console.info(`[OCCT] Display controller initialized | ID: ${this.displayContrId}`);
+      //
       //     try {
-      //       //OCCTRender.initRenderer(this.displayContrId, this.nativeWindow, { width: 800, height: 600 });
+      //       const modelPath = getContext(this).resourceDir + '/rawfile/Model.step';
-      //       console.info('Init Render Good');
+      //       OCCTRender.loadStepModel(this.displayContrId, modelPath); // ✅ 使用新变量
-      //     }catch(e){
+      //     } catch (err) {
-      //       console.info('Init Render Faile');
+      //       console.error('[OCCT] Model load failed:', JSON.stringify(err));
       //     }
       //   })
-      //   .onDestroy(() => {
+      //   .onClick(() => {
-      //     // 销毁时清理资源
+      //     if (this.displayContrId > 0) OCCTRender.resetView(this.displayContrId); // ✅
-      //     //OCCTRender.destroyRenderer(this.displayContrId);
       //   })
-      //   .onTouch((event) => {
+      //   .onTouch((event: TouchEvent) => {
-      //     // 简单鼠标/触摸拖拽旋转
+      //     if (this.displayContrId <= 0 || event.touches.length === 0) return;
-      //     if (event.type === TouchType.Move) {
+      //
-      //       const dx = event.tiltX;
+      //     switch (event.type) {
-      //       const dy = event.tiltY;
+      //       case TouchType.Down:
-      //       //occt.onMouseEvent(this.xcomponentId, dx, dy);
+      //         this.isDragging = true;
+      //         let GeneratedDestructArray_1 = [
+      //           event.touches[0].screenX,
+      //           event.touches[0].screenY
+      //         ];
+      //         this.lastTouchX = GeneratedDestructArray_1[0];
+      //         this.lastTouchY = GeneratedDestructArray_1[1];
+      //         break;
+      //
+      //       case TouchType.Move:
+      //         if (this.isDragging && event.touches[0]) {
+      //           const deltaX = event.touches[0].screenX - this.lastTouchX;
+      //           const deltaY = event.touches[0].screenY - this.lastTouchY;
+      //
+      //           const rotX = Math.max(-180, Math.min(180, deltaX * 0.3));
+      //           const rotY = Math.max(-180, Math.min(180, deltaY * 0.3));
+      //
+      //           OCCTRender.rotateModel(this.displayContrId, rotX, rotY);
+      //
+      //           let GeneratedDestructArray_1 = [
+      //             event.touches[0].screenX,
+      //             event.touches[0].screenY
+      //           ];
+      //           this.lastTouchX = GeneratedDestructArray_1[0];
+      //           this.lastTouchY = GeneratedDestructArray_1[1];
+      //         }
+      //         break;
+      //
+      //       case TouchType.Up:
+      //       case TouchType.Cancel:
+      //         this.isDragging = false;
+      //         break;
       //     }
       //   })
       //   .width('100%')
-      //   .height('100%')
+      //   .height('80%')
-      //   .backgroundColor('#333333');
+      //   .backgroundColor('#000000')
     }
     .width('100%')
     .height('100%');

entry/src/main/ets/pages/modelViewTab.ets

@@ -69,7 +69,8 @@ export struct ModelViewTab {
           bottom: 2,
           right: 0
         })
-      }.barHeight(0)
+      }.scrollable(false)
+      .barHeight(0)
       .margin({
         top: 0,
         left: 0,

entry/src/main/ets/pages/titleTab.ets

@@ -141,7 +141,8 @@ export struct TitleTab {
            .padding(1)
            .margin({ top: 0,left:0,bottom:2,right:0})
         })
-      }.barHeight(0)
+      }.scrollable(false)
+       .barHeight(0)
        .margin({ top: 0,left:0,bottom:0,right:0})
        .height('auto')
        .barMode(BarMode.Fixed)

entry/src/main/module.json5

@@ -29,7 +29,7 @@
               "ohos.want.action.home"
             ]
           }
-        ]
+        ],
       }
     ],
     "extensionAbilities": [

entry/src/main/resources/base/element/string.json

@@ -11,6 +11,10 @@
     {
       "name": "EntryAbility_label",
       "value": "OpenCAX"
+    },
+    {
+      "name": "reason",
+      "value": ""
     }
   ]
 }