Fix ios build

Reviewed-on: https://git.onlyoffice.com/ONLYOFFICE/build_tools/pulls/138

Dockerfile

@@ -5,13 +5,15 @@ RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
 RUN apt-get -y update && \
     apt-get -y install tar \
-                       sudo
+                       sudo \
+                       wget
 
 ADD . /build_tools
 WORKDIR /build_tools
 
 RUN mkdir -p /opt/python3 && \
-    tar -xzf /build_tools/tools/linux/python3.tar.gz -C /opt/python3 --strip-components=1
+    wget -P /opt/python3/ https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/python3.tar.gz && \
+    tar -xzf /opt/python3/python3.tar.gz -C /opt/python3 --strip-components=1
 
 ENV PATH="/opt/python3/bin:${PATH}"
 

configure.py

@@ -42,7 +42,7 @@ parser.add_option("--vs-version", action="store", type="string", dest="vs-versio
 parser.add_option("--vs-path", action="store", type="string", dest="vs-path", default="", help="path to vcvarsall")
 parser.add_option("--siteUrl", action="store", type="string", dest="siteUrl", default="127.0.0.1", help="site url")
 parser.add_option("--multiprocess", action="store", type="string", dest="multiprocess", default="1", help="provides ability to specify single process for make")
-parser.add_option("--custom-sysroot", action="store", type="string", dest="custom-sysroot", default="0", help="provides ability to use custom sysroot (ubuntu 16.04) to build c++ core. If value is \"1\", then the sysroot from tools/linux/sysroot will be used, and if it is not there, it will download it and unpack it. You can also set value as the path to the your own sysroot (rarely used). Only for linux")
+parser.add_option("--sysroot", action="store", type="string", dest="sysroot", default="0", help="provides ability to use sysroot (ubuntu 16.04) to build c++ code. If value is \"1\", then the sysroot from tools/linux/sysroot will be used, and if it is not there, it will download it and unpack it. You can also set value as the path to the your own sysroot (rarely used). Only for linux")
 
 (options, args) = parser.parse_args(arguments)
 configOptions = vars(options)

make.py

@@ -19,8 +19,6 @@ import make_common
 import develop
 import argparse
 
-base.check_python()
-
 parser = argparse.ArgumentParser(description="options")
 parser.add_argument("--build-only-branding", action="store_true")
 args = parser.parse_args()
@@ -30,6 +28,7 @@ if (args.build_only_branding):
 
 # parse configuration
 config.parse()
+base.check_python()
 
 base_dir = base.get_script_dir(__file__)
 
@@ -92,8 +91,6 @@ if config.check_option("module", "desktop"):
     config.extend_option("config", "updmodule")
     base.set_env("DESKTOP_URL_UPDATES_MAIN_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/appcast.json")
     base.set_env("DESKTOP_URL_UPDATES_DEV_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/appcastdev.json")
-    base.set_env("DESKTOP_URL_INSTALL_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/distrib/onlyoffice/<file>")
-    base.set_env("DESKTOP_URL_INSTALL_DEV_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/onlineinstallerdev/<file>")
 
 # build
 build_sln.make()

scripts/base.py

@@ -16,6 +16,7 @@ import json
 
 __file__script__path__ = os.path.dirname( os.path.realpath(__file__))
 icu_ver = "74"
+icu_ver_old = "58"  # for win_xp support
 
 # common functions --------------------------------------
 def get_script_dir(file=""):
@@ -697,9 +698,12 @@ def get_prefix_cross_compiler_arm64():
   return ""
 
 def get_gcc_version():
+  gcc_path = "gcc"
+  if config.option("sysroot") != "":
+    gcc_path = config.option("sysroot") + "/usr/bin/gcc"
   gcc_version_major = 4
   gcc_version_minor = 0
-  gcc_version_str = run_command("gcc -dumpfullversion -dumpversion")['stdout']
+  gcc_version_str = run_command(gcc_path + " -dumpfullversion -dumpversion")['stdout']
   if (gcc_version_str != ""):
     try:
       gcc_ver = gcc_version_str.split(".")
@@ -904,9 +908,24 @@ def _check_icu_common(dir, out):
   return isExist
 
 def qt_copy_icu(out):
-  tests = [get_env("QT_DEPLOY") + "/../lib", "/lib", "/lib/x86_64-linux-gnu", "/lib64", "/lib64/x86_64-linux-gnu"]
-  tests += ["/usr/lib", "/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/usr/lib64/x86_64-linux-gnu"]
-  tests += ["/lib/i386-linux-gnu", "/usr/lib/i386-linux-gnu"]
+  tests = [get_env("QT_DEPLOY") + "/../lib"]
+  prefix = ""
+  postfixes = [""]
+
+  # TODO add for linux arm desktop build
+  if config.option("sysroot") != "":
+    prefix = config.option("sysroot")
+  else:
+    prefix = ""
+    
+  postfixes += ["/x86_64-linux-gnu"]
+  postfixes += ["/i386-linux-gnu"]
+
+  for postfix in postfixes:
+    tests += [prefix + "/lib" + postfix]
+    tests += [prefix + "/lib64" + postfix]
+    tests += [prefix + "/usr/lib" + postfix]
+    tests += [prefix + "/usr/lib64" + postfix]
 
   for test in tests:
     if (_check_icu_common(test, out)):
@@ -995,7 +1014,7 @@ def generate_doctrenderer_config(path, root, product, vendor = "", dictionaries
   file.close()
   return
 
-def generate_plist_framework_folder(file, platform):
+def generate_plist(file, platform):
   bundle_id_url = "com.onlyoffice."
   if ("" != get_env("PUBLISHER_BUNDLE_ID")):
     bundle_id_url = get_env("PUBLISHER_BUNDLE_ID")
@@ -1046,7 +1065,29 @@ def generate_plist_framework_folder(file, platform):
   fileInfo.close()
   return
 
-def generate_plist(path, platform, max_depth=512):
+def generate_xcprivacy(file, platform):
+  content = \
+"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>NSPrivacyTracking</key>
+\t<false/>
+\t<key>NSPrivacyCollectedDataTypes</key>
+\t<array/>
+\t<key>NSPrivacyTrackingDomains</key>
+\t<array/>
+\t<key>NSPrivacyAccessedAPITypes</key>
+\t<array/>
+</dict>
+</plist>"""
+  fileDst = os.path.join(file, "PrivacyInfo.xcprivacy")
+  fileInfo = codecs.open(fileDst, "w", "utf-8")
+  fileInfo.write(content)
+  fileInfo.close()
+  return
+
+def for_each_framework(path, platform, callbacks, max_depth=512):
   if not config.check_option("config", "bundle_dylibs"):
     return
   if max_depth == 0:
@@ -1058,9 +1099,10 @@ def generate_plist(path, platform, max_depth=512):
   for file in glob.glob(src_folder):
     if (is_dir(file)):
       if file.endswith(".framework"):
-        generate_plist_framework_folder(file, platform)
+        for callback in callbacks:
+          callback(file, platform)
       else:
-        generate_plist(file, platform, max_depth - 1)
+        for_each_framework(file, platform, callbacks, max_depth - 1)
   return
 
 def correct_bundle_identifier(bundle_identifier):
@@ -1308,25 +1350,24 @@ def mac_correct_rpath_x2t(dir):
   mac_correct_rpath_library("DocxRenderer", ["UnicodeConverter", "kernel", "graphics"])
   mac_correct_rpath_library("IWorkFile", ["UnicodeConverter", "kernel"])
   mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics"])
-  cmd("chmod", ["-v", "+x", "./x2t"])
-  cmd("install_name_tool", ["-add_rpath", "@executable_path", "./x2t"], True)
-  mac_correct_rpath_binary("./x2t", mac_icu_libs + ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile"])
+
+  def correct_core_executable(name, libs):
+    cmd("chmod", ["-v", "+x", name])
+    cmd("install_name_tool", ["-add_rpath", "@executable_path", name], True)
+    mac_correct_rpath_binary(name, mac_icu_libs + libs)
+    return
+
+  correct_core_executable("x2t", ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile"])
   if is_file("./allfontsgen"):
-    cmd("chmod", ["-v", "+x", "./allfontsgen"])
-    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./allfontsgen"], True)
-    mac_correct_rpath_binary("./allfontsgen", mac_icu_libs + ["UnicodeConverter", "kernel", "graphics"])
+    correct_core_executable("allfontsgen", ["UnicodeConverter", "kernel", "graphics"])
   if is_file("./allthemesgen"):
-    cmd("chmod", ["-v", "+x", "./allthemesgen"])
-    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./allthemesgen"], True)
-    mac_correct_rpath_binary("./allthemesgen", mac_icu_libs + ["UnicodeConverter", "kernel", "graphics", "kernel_network", "doctrenderer", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "DocxRenderer"])
+    correct_core_executable("allthemesgen", ["UnicodeConverter", "kernel", "graphics", "kernel_network", "doctrenderer", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "DocxRenderer"])
   if is_file("./pluginsmanager"):
-    cmd("chmod", ["-v", "+x", "./pluginsmanager"])
-    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./pluginsmanager"], True)
-    mac_correct_rpath_binary("./pluginsmanager", mac_icu_libs + ["UnicodeConverter", "kernel", "kernel_network"])
+    correct_core_executable("pluginsmanager", ["UnicodeConverter", "kernel", "kernel_network"])
   if is_file("./vboxtester"):
-    cmd("chmod", ["-v", "+x", "./vboxtester"])
-    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./vboxtester"], True)
-    mac_correct_rpath_binary("./vboxtester", mac_icu_libs + ["UnicodeConverter", "kernel", "kernel_network"])
+    correct_core_executable("vboxtester", ["UnicodeConverter", "kernel", "kernel_network"])
+  if is_file("./x2ttester"):
+    correct_core_executable("x2ttester", ["UnicodeConverter", "kernel", "graphics"])
   os.chdir(cur_dir)
   return
 
@@ -1846,6 +1887,25 @@ def check_module_version(actual_version, clear_func):
   clear_func()
   return
 
+
+def set_sysroot_env():
+  global ENV_BEFORE_SYSROOT
+  ENV_BEFORE_SYSROOT = dict(os.environ)
+  if "linux" == host_platform() and config.option("sysroot") != "":
+    os.environ['PATH'] = config.option("sysroot") + "/usr/bin:" + get_env("PATH")
+    os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
+    os.environ['QMAKE_CUSTOM_SYSROOT'] = config.option("sysroot")
+    os.environ['PKG_CONFIG_PATH'] = config.get_custom_sysroot_lib() + "/pkgconfig"
+    os.environ['CC'] = config.get_custom_sysroot_bin() + "/gcc"
+    os.environ['CXX'] = config.get_custom_sysroot_bin() + "/g++"
+    os.environ['CFLAGS'] = "--sysroot=" + config.option("sysroot")
+    os.environ['CXXFLAGS'] = "--sysroot=" + config.option("sysroot")
+    check_python()
+    
+def restore_sysroot_env():
+  os.environ.clear()
+  os.environ.update(ENV_BEFORE_SYSROOT)
+    
 def check_python():
   if ("linux" != host_platform()):
     return
@@ -1923,9 +1983,6 @@ def create_x2t_js_cache(dir, product, platform):
     cmd_in_dir_qemu(platform, dir, "./x2t", ["-create-js-snapshots"], True)
     return
 
-  if platform == "win_arm64": # copying sdkjs later
-    return
-
   cmd_in_dir(dir, "./x2t", ["-create-js-snapshots"], True)
   return
 
@@ -1937,14 +1994,22 @@ def setup_local_qmake(dir_qmake):
 def deploy_icu(core_dir, dst_dir, platform):
   if (0 == platform.find("android")):
     src_dir = core_dir + "/Common/3dParty/icu/android/build/" + platform[8:]
-    copy_file(src_dir + "/icudt" + icu_ver + "l.dat", root_dir + "/icudt" + icu_ver + "l.dat")
+    copy_file(src_dir + "/icudt" + icu_ver + "l.dat", dst_dir + "/icudt" + icu_ver + "l.dat")
     return
 
+  isXp = False
+  if platform.endswith("xp"):
+    isXp = True
+    platform = platform[0:-3]
   src_dir = core_dir + "/Common/3dParty/icu/" + platform + "/build"
 
   if (0 == platform.find("win")):
-    copy_file(src_dir + "/icudt" + icu_ver + ".dll", dst_dir + "/icudt" + icu_ver + ".dll")
-    copy_file(src_dir + "/icuuc" + icu_ver + ".dll", dst_dir + "/icuuc" + icu_ver + ".dll")
+    icu_ver_win = icu_ver
+    if isXp:
+      icu_ver_win = icu_ver_old
+      src_dir += "/xp"
+    copy_file(src_dir + "/icudt" + icu_ver_win + ".dll", dst_dir + "/icudt" + icu_ver_win + ".dll")
+    copy_file(src_dir + "/icuuc" + icu_ver_win + ".dll", dst_dir + "/icuuc" + icu_ver_win + ".dll")
 
   if (0 == platform.find("linux")):
     copy_file(src_dir + "/libicudata.so." + icu_ver, dst_dir + "/libicudata.so." + icu_ver)

scripts/build_server.py

@@ -52,6 +52,7 @@ def make():
   base.cmd_in_dir(server_dir + "/DocService", "pkg", [".", "-t", pkg_target, "--options", "max_old_space_size=4096", "-o", "docservice"])
   base.cmd_in_dir(server_dir + "/FileConverter", "pkg", [".", "-t", pkg_target, "-o", "converter"])
   base.cmd_in_dir(server_dir + "/Metrics", "pkg", [".", "-t", pkg_target, "-o", "metrics"])
+  base.cmd_in_dir(server_dir + "/AdminPanel/server", "pkg", [".", "-t", pkg_target, "-o", "adminpanel"])
 
   example_dir = base.get_script_dir() + "/../../document-server-integration/web/documentserver-example/nodejs"
   base.delete_dir(example_dir  + "/node_modules")

scripts/config.py

@@ -56,10 +56,12 @@ def parse():
   if ("mac" == host_platform) and check_option("platform", "mac_arm64") and not base.is_os_arm():
     if not check_option("platform", "mac_64"):
       options["platform"] = "mac_64 " + options["platform"]
-      
-  if ("windows" == host_platform) and check_option("platform", "win_arm64") and not base.is_os_arm():
-    if not check_option("platform", "win_64"):
-      options["platform"] = "win_64 " + options["platform"]
+
+  if (False):
+    # use qemu on deploy for emulation 
+    if ("windows" == host_platform) and check_option("platform", "win_arm64") and not base.is_os_arm():
+      if not check_option("platform", "win_64"):
+        options["platform"] = "win_64 " + options["platform"]
 
   if ("linux" == host_platform) and check_option("platform", "linux_arm64") and not base.is_os_arm():
     if not check_option("platform", "linux_64"):
@@ -81,6 +83,27 @@ def parse():
 
   if ("windows" == host_platform) and ("2019" == option("vs-version")):
       extend_option("config", "vs2019")
+      
+  # sysroot setup
+  if "linux" != host_platform and "sysroot" in options:
+    options["sysroot"] = ""
+
+  if "linux" == host_platform and "sysroot" in options:
+    if options["sysroot"] == "0":
+      options["sysroot"] = ""
+    elif options["sysroot"] == "1":
+      dst_dir = os.path.abspath(base.get_script_dir(__file__) + '/../tools/linux/sysroot')
+      custom_sysroot = dst_dir + '/sysroot_ubuntu_1604'
+      options["sysroot"] = custom_sysroot
+      if not os.path.isdir(custom_sysroot):
+        print("Sysroot is not found, downloading...")
+        sysroot_url = 'https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/sysroot/sysroot_ubuntu_1604.tar.xz'
+        base.download(sysroot_url, dst_dir + '/sysroot_ubuntu_1604.tar.xz')
+        os.mkdir(custom_sysroot)
+        print("Unpacking...")
+        base.cmd2('tar', ['-xf', dst_dir + '/sysroot_ubuntu_1604.tar.xz', '-C', dst_dir])
+        if os.path.exists(dst_dir + '/sysroot_ubuntu_1604.tar.xz'):
+          os.remove(dst_dir + '/sysroot_ubuntu_1604.tar.xz')
 
   if is_cef_107():
     extend_option("config", "cef_version_107")
@@ -108,29 +131,8 @@ def parse():
   if not "sdkjs-plugin-server" in options:
     options["sdkjs-plugin-server"] = "default"
 
-  # custom-sysroot setup
-  if "linux" != host_platform and "custom-sysroot" in options:
-    options["custom-sysroot"] = ""
-
-  if "linux" == host_platform and "custom-sysroot" in options:
-    if options["custom-sysroot"] == "0":
-      options["custom-sysroot"] = ""
-    elif options["custom-sysroot"] == "1":
-      dst_dir = os.path.abspath(base.get_script_dir(__file__) + '/../tools/linux/sysroot')
-      custom_sysroot = dst_dir + '/sysroot_ubuntu_1604'
-      options["custom-sysroot"] = custom_sysroot
-      if not os.path.isdir(custom_sysroot):
-        print("Custom sysroot is not found, downloading...")
-        sysroot_url = 'https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/sysroot/sysroot_ubuntu_1604.tar.xz'
-        base.download(sysroot_url, dst_dir + '/sysroot_ubuntu_1604.tar.xz')
-        os.mkdir(custom_sysroot)
-        print("Unpacking...")
-        base.cmd2('tar', ['-xf', dst_dir + '/sysroot_ubuntu_1604.tar.xz', '-C', dst_dir])
-        if os.path.exists(dst_dir + '/sysroot_ubuntu_1604.tar.xz'):
-          os.remove(dst_dir + '/sysroot_ubuntu_1604.tar.xz')
-
   if not "arm64-toolchain-bin" in options:
-    if not "custom-sysroot" in options:
+    if not "sysroot" in options:
       options["arm64-toolchain-bin"] = "/usr/bin"
     else:
       options["arm64-toolchain-bin"] = get_custom_sysroot_bin()
@@ -235,12 +237,12 @@ def is_mobile_platform():
   return False
 
 def get_custom_sysroot_bin():
-  return option("custom-sysroot") + "/usr/bin"
+  return option("sysroot") + "/usr/bin"
 
 # todo 32bit support?
 def get_custom_sysroot_lib():
   if base.is_os_64bit():
-    return option("custom-sysroot") + "/usr/lib/x86_64-linux-gnu"
+    return option("sysroot") + "/usr/lib/x86_64-linux-gnu"
 
 def parse_defaults():
   defaults_path = base.get_script_dir() + "/../defaults"

scripts/core_common/make_common.py

@@ -26,6 +26,7 @@ import hyphen
 import googletest
 import libvlc
 import heif
+import webp
 
 def check_android_ndk_macos_arm(dir):
   if base.is_dir(dir + "/darwin-x86_64") and not base.is_dir(dir + "/darwin-arm64"):
@@ -55,6 +56,7 @@ def make():
   googletest.make()
   oo_brotli.make()
   heif.make()
+  webp.make()
 
   if config.check_option("build-libvlc", "1"):
     libvlc.make()

scripts/core_common/modules/android/android_ndk.py

@@ -71,13 +71,6 @@ else:
     "arch" : "darwin-x86_64"
   }
 
-def get_android_ndk_version():
-  #return "26.2.11394342"
-  return "21.1.6352462"
-
-def get_android_ndk_version_major():
-  return int(get_android_ndk_version().split(".")[0])
-
 def get_options_dict_as_array(opts):
   value = []
   for key in opts:

scripts/core_common/modules/android/icu_android.py

@@ -11,8 +11,8 @@ current_dir = os.path.abspath(current_dir)
 if not current_dir.endswith("/"):
   current_dir += "/"
 
-icu_major = "58"
-icu_minor = "3"
+icu_major = "74"
+icu_minor = "2"
 
 options = {
   "--enable-strict"       : "no",
@@ -41,12 +41,12 @@ cpp_flags_base = [
 cpp_flags = [
   "-fno-short-wchar",
   "-fno-short-enums",
-  
+
   "-DU_USING_ICU_NAMESPACE=0",
   "-DU_HAVE_NL_LANGINFO_CODESET=0",
   "-DU_TIMEZONE=0",
   "-DU_DISABLE_RENAMING=0",
-  
+
   "-DUCONFIG_NO_COLLATION=0",
   "-DUCONFIG_NO_FORMATTING=0",
   "-DUCONFIG_NO_REGULAR_EXPRESSIONS=0",
@@ -55,7 +55,7 @@ cpp_flags = [
   "-DU_STATIC_IMPLEMENTATION"
 ]
 
-def fetch_icu():
+def fetch_icu(major, minor):
   if not base.is_dir(current_dir + "icu"):
     base.cmd("git", ["clone", "--depth", "1", "--branch", "release-" + major + "-" + minor, "https://github.com/unicode-org/icu.git", current_dir + "icu2"])
     base.copy_dir(current_dir + "icu2/icu4c", current_dir + "icu")
@@ -106,9 +106,9 @@ def build_arch(arch):
   cross_build_dir = os.path.abspath(current_dir + "icu/cross_build")
   arch_build_dir = os.path.abspath(current_dir + "build/tmp")
   base.create_dir(arch_build_dir)
-  
+
   os.chdir(arch_build_dir)
-  base.cmd("./../../icu/source/configure", ["--with-cross-build=" + cross_build_dir] + 
+  base.cmd("./../../icu/source/configure", ["--with-cross-build=" + cross_build_dir] +
     android_ndk.get_options_dict_as_array(options) + ["--host=" + android_ndk.platforms[arch]["target"], "--prefix=" + arch_build_dir])
   base.cmd("make", ["-j4"])
   os.chdir(current_dir)
@@ -127,7 +127,7 @@ def make():
 
   old_env = dict(os.environ)
 
-  fetch_icu()
+  fetch_icu(icu_major, icu_minor)
 
   build_host()
 

scripts/core_common/modules/boost.py

@@ -99,7 +99,7 @@ def make():
     correct_install_includes_win(base_dir, "win_arm64")
 
   if config.check_option("platform", "linux_64") and not base.is_dir("../build/linux_64"):
-    if config.option("custom-sysroot") == "":
+    if config.option("sysroot") == "":
       addon_config = []
       addon_compile = []
       if "1" == config.option("use-clang"):

scripts/core_common/modules/boost_qt.py

@@ -9,11 +9,24 @@ import qmake
 
 def make(src_dir, modules, build_platform="android", qmake_addon=""):
   old_cur = os.getcwd()
+  old_env = dict(os.environ)
+  b2_addon = ""
 
   print("boost-headers...")
-  base.cmd("./bootstrap.sh", ["--with-libraries=system"])
-  base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install"])
-
+  
+  # for b2 checks
+  if config.option("sysroot") != "":
+    base.set_sysroot_env()
+    b2_addon = "cflags=\"--sysroot=" + config.option("sysroot") + "\""
+    b2_addon = "cxxflags=\"--sysroot=" + config.option("sysroot") + "\""
+    b2_addon = "linkflags=\"--sysroot=" + config.option("sysroot") + "\""
+    
+  base.cmd("./bootstrap.sh", ["--with-libraries=system"])   
+  base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install", b2_addon])
+  
+  if config.option("sysroot") != "":
+    base.restore_sysroot_env()
+  
   for module in modules:
     print("boost-module: " + module + " ...")
     module_dir = src_dir + "/libs/" + module
@@ -40,6 +53,8 @@ def make(src_dir, modules, build_platform="android", qmake_addon=""):
     base.save_as_script(module_dir + "/" + module + ".pro", pro_file_content)
     os.chdir(module_dir)
     qmake.make_all_platforms(module_dir + "/" + module + ".pro", qmake_addon)
-  
+
+  os.environ.clear()
+  os.environ.update(old_env)
   os.chdir(old_cur)
   return

scripts/core_common/modules/cef.py

@@ -5,6 +5,13 @@ sys.path.append('../..')
 import config
 import base
 import os
+import glob
+
+def clear_module():
+  for child in glob.glob("./*"):
+    if base.is_dir(child):
+      base.delete_dir(child)
+  return
 
 def make():
   print("[fetch & build]: cef")
@@ -13,6 +20,7 @@ def make():
   old_cur = os.getcwd()
   os.chdir(base_dir)
 
+  base.check_module_version("2", clear_module)
   platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64"]
 
   for platform in platforms:

scripts/core_common/modules/heif.py

@@ -23,6 +23,29 @@ ANDROID_CMAKE_TOOLCHAIN_FILE = base.get_env("ANDROID_NDK_ROOT") + "/build/cmake/
 # linux arm64 cmake toolchain
 LINUX_ARM64_CMAKE_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/arm/cross_arm64/linux-arm64.toolchain.cmake"
 
+LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/sysroot/custom-sysroot.toolchain.cmake"
+
+OLD_ENV = dict()
+
+# get custom sysroot vars as str
+def setup_custom_sysroot_env() -> str:
+  env_vars = []
+  env_vars += ['LD_LIBRARY_PATH=\"' + config.get_custom_sysroot_lib() + "\""]
+  env_vars += ['PATH=\"' + config.option("sysroot") + "/usr/bin:" + base.get_env("PATH") + "\""]
+  env_vars += ['CC=\"' + config.get_custom_sysroot_bin() + "/gcc\""]
+  env_vars += ['CXX=\"' + config.get_custom_sysroot_bin() + "/g++\""]
+  env_vars += ['AR=\"' + config.get_custom_sysroot_bin() + "/ar\""]
+  env_vars += ['RABLIB=\"' + config.get_custom_sysroot_bin() + "/ranlib\""]
+  env_vars += ['CFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+  env_vars += ['CXXFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+  env_vars += ['LDFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+
+  env_str = ""
+  for env_var in env_vars:
+    env_str += env_var + " "
+
+  return env_str
+
 def get_vs_version():
   vs_version = "14 2015"
   if config.option("vs-version") == "2019":
@@ -69,6 +92,8 @@ def build_with_cmake(platform, cmake_args, build_type):
       cmake_args_ext += ["-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0", "-DCMAKE_OSX_ARCHITECTURES=arm64"]
     elif platform == "linux_arm64":
       cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_ARM64_CMAKE_TOOLCHAIN_FILE]
+    elif config.option("sysroot") != "":
+      cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE] # force use custom CXXFLAGS with Release/Debug build
   # IOS
   elif "ios" in platform:
     cmake_args_ext = [
@@ -101,11 +126,15 @@ def build_with_cmake(platform, cmake_args, build_type):
     elif platform == "android_x86_64":
       cmake_args_ext += get_cmake_args_android("x86_64", "21")
 
+  # env setup for custom sysroot
+  env_str = setup_custom_sysroot_env() if config.option("sysroot") != "" else ""
+
   # run cmake
-  base.cmd("cmake", cmake_args + cmake_args_ext)
+  base.cmd(env_str + "cmake", cmake_args + cmake_args_ext)
+
   # build
   if "Unix Makefiles" in cmake_args_ext:
-    base.cmd("make", ["-j4"])
+    base.cmd(env_str + "make", ["-j4"])
   else:
     base.cmd("cmake", ["--build", ".", "--config", build_type])
   return
@@ -185,6 +214,7 @@ def make_x265(base_dir, build_type):
     "-DENABLE_CLI=OFF",                 # do not build standalone CLI app
     "-DENABLE_SHARED=OFF",              # do not build shared libs
     "-DENABLE_ASSEMBLY=OFF",            # disable assembly optimizations
+    "-DENABLE_LIBNUMA=OFF",             # disable libnuma usage (affects Linux only)
   ]
 
   # lib build function

scripts/core_common/modules/icu.py

@@ -9,11 +9,11 @@ import os
 import glob
 import icu_android
 
-def fetch_icu(major, minor):
+def fetch_icu(major, minor, target_dir="icu"):
   if (base.is_dir("./icu2")):
-    base.delete_dir_with_access_error("icu2")  
+    base.delete_dir_with_access_error("icu2")
   base.cmd("git", ["clone", "--depth", "1", "--branch", "release-" + major + "-" + minor, "https://github.com/unicode-org/icu.git", "./icu2"])
-  base.copy_dir("./icu2/icu4c", "./icu")
+  base.copy_dir("./icu2/icu4c", target_dir)
   base.delete_dir_with_access_error("icu2")
   return
 
@@ -44,9 +44,17 @@ def make():
 
   icu_major = "74"
   icu_minor = "2"
-  
+
   if not base.is_dir("icu"):
-    fetch_icu(icu_major, icu_minor)  
+    fetch_icu(icu_major, icu_minor)
+
+  # old version for win_xp
+  icu_major_old = "58"
+  icu_minor_old = "3"
+
+  if config.check_option("platform", "win_64_xp") or config.check_option("platform", "win_32_xp"):
+    if not base.is_dir("icu58"):
+      fetch_icu(icu_major_old, icu_minor_old, "icu58")
 
   if ("windows" == base.host_platform()):
     platformToolset = "v140"
@@ -57,52 +65,61 @@ def make():
       need_platforms.append("win_64")
     if (-1 != config.option("platform").find("win_32")):
       need_platforms.append("win_32")
-    if (-1 != config.option("platform").find("win_arm64")): 
+    if (-1 != config.option("platform").find("win_arm64")):
       need_platforms.append("win_64") # for exe files
       need_platforms.append("win_arm64")
-      
+
+    def build_icu_win(source_dir, out_dir, icu_major):
+      if base.is_dir(out_dir):
+        return
+
+      compile_bat = []
+      compile_bat.append("setlocal")
+
+      args = {
+        "win_32" : {
+          "msbuild_platfrom" : "Win32",
+          "vcvarsall_arch" : "x86",
+          "out_bin_dir" : source_dir + "/bin/",
+          "out_lib_dir" : source_dir + "/lib/"
+        },
+        "win_64" : {
+          "msbuild_platfrom" : "X64",
+          "vcvarsall_arch" : "x64",
+          "out_bin_dir" : source_dir + "/bin64/",
+          "out_lib_dir" : source_dir + "/lib64/"
+        },
+        "win_arm64" : {
+          "msbuild_platfrom" : "ARM64",
+          "vcvarsall_arch" : "x64_arm64",
+          "out_bin_dir" : source_dir + "/binARM64/",
+          "out_lib_dir" : source_dir + "/libARM64/"
+        }
+      }
+
+      platform_args = args[platform]
+
+      compile_bat.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + platform_args['vcvarsall_arch'])
+      compile_bat.append("call MSBuild.exe " + source_dir + "/source/allinone/allinone.sln /p:Configuration=Release /p:PlatformToolset=" + platformToolset + " /p:Platform=" + platform_args['msbuild_platfrom'])
+      compile_bat.append("endlocal")
+      base.run_as_bat(compile_bat)
+
+      base.create_dir(out_dir)
+      base.copy_file(platform_args['out_bin_dir'] + "icudt" + icu_major + ".dll", out_dir)
+      base.copy_file(platform_args['out_bin_dir'] + "icuuc" + icu_major + ".dll", out_dir)
+      base.copy_file(platform_args['out_lib_dir'] + "icudt.lib", out_dir)
+      base.copy_file(platform_args['out_lib_dir'] + "icuuc.lib", out_dir)
+
     for platform in need_platforms:
       if not config.check_option("platform", platform) and not config.check_option("platform", platform + "_xp"):
         continue
-      
-      if not base.is_dir(platform + "/build"):
-        base.create_dir(platform)
-        compile_bat = []
-        compile_bat.append("setlocal")
-        
-        args = {
-          "win_32" : {
-            "msbuild_platfrom" : "Win32",
-            "vcvarsall_arch" : "x86",
-            "out_bin_dir" : "icu/bin/",
-            "out_lib_dir" : "icu/lib/"
-          },
-          "win_64" : {
-            "msbuild_platfrom" : "X64",
-            "vcvarsall_arch" : "x64",
-            "out_bin_dir" : "icu/bin64/",
-            "out_lib_dir" : "icu/lib64/"
-          },
-          "win_arm64" : {
-            "msbuild_platfrom" : "ARM64",
-            "vcvarsall_arch" : "x64_arm64",
-            "out_bin_dir" : "icu/binARM64/",
-            "out_lib_dir" : "icu/libARM64/"
-          }
-        }
-        
-        platform_args = args[platform]
-                  
-        compile_bat.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + platform_args['vcvarsall_arch'])
-        compile_bat.append("call MSBuild.exe icu/source/allinone/allinone.sln /p:Configuration=Release /p:PlatformToolset=" + platformToolset + " /p:Platform=" + platform_args['msbuild_platfrom'])
-        compile_bat.append("endlocal")
-        base.run_as_bat(compile_bat)
-        
-        base.create_dir(platform + "/build")
-        base.copy_file(platform_args['out_bin_dir'] + "icudt" + icu_major + ".dll", platform + "/build/")
-        base.copy_file(platform_args['out_bin_dir'] + "icuuc" + icu_major + ".dll", platform + "/build/")
-        base.copy_file(platform_args['out_lib_dir'] + "icudt.lib", platform + "/build/")
-        base.copy_file(platform_args['out_lib_dir'] + "icuuc.lib", platform + "/build/")
+
+      if not (config.check_option("platform", "win_64_xp") or config.check_option("platform", "win_32_xp")):
+        build_icu_win("icu", platform + "/build", icu_major)
+      else:
+        # xp
+        build_icu_win("icu58", platform + "/build/xp", icu_major_old)
+
     os.chdir(old_cur)
     return
 
@@ -112,38 +129,35 @@ def make():
       os.chdir("icu/cross_build")
       command_configure = "./../source/runConfigureICU"
       command_compile_addon = "-static-libstdc++ -static-libgcc"
-      ld_library_path_copy = ''
       if "1" == config.option("use-clang"):
         command_configure = "CXXFLAGS=-stdlib=libc++ " + command_configure
         command_compile_addon = "-stdlib=libc++"
-      if "" == config.option("custom-sysroot"):
+      if "" == config.option("sysroot"):
         base.cmd(command_configure, ["Linux", "--prefix=" + base_dir + "/icu/cross_build_install"])
         base.replaceInFile("./../source/icudefs.mk.in", "LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS)", "LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS) " + command_compile_addon)
       else:
-        if 'LD_LIBRARY_PATH' in os.environ:
-          ld_library_path_copy = os.environ['LD_LIBRARY_PATH']
-        os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
+        base.set_sysroot_env()     
         base.cmd_exe("./../source/configure", ["--prefix=" + base_dir + "/icu/cross_build_install",
                                            "CC=" + config.get_custom_sysroot_bin() + "/gcc", "CXX=" + config.get_custom_sysroot_bin() + "/g++",
                                            "AR=" + config.get_custom_sysroot_bin() + "/ar", "RANLIB=" + config.get_custom_sysroot_bin() + "/ranlib",
-                                           "CFLAGS=--sysroot=" + config.option("custom-sysroot"),
-                                           "CXXFLAGS=--sysroot=" + config.option("custom-sysroot") + " " + command_compile_addon,
-                                           "LDFLAGS=--sysroot=" + config.option("custom-sysroot")])
+                                           "CFLAGS=--sysroot=" + config.option("sysroot"),
+                                           "CXXFLAGS=--sysroot=" + config.option("sysroot") + " " + command_compile_addon,
+                                           "LDFLAGS=--sysroot=" + config.option("sysroot")])
 
-      if "" == config.option("custom-sysroot"):
+      if "" == config.option("sysroot"):
         base.cmd("make", ["-j4"])
         base.cmd("make", ["install"], True)
       else:
         base.cmd_exe("make", ["-j4"])
         base.cmd_exe("make", ["install"], True)
-        os.environ['LD_LIBRARY_PATH'] = ld_library_path_copy
+        base.restore_sysroot_env()
 
       base.create_dir(base_dir + "/linux_64")
       base.create_dir(base_dir + "/linux_64/build")
       base.copy_file(base_dir + "/icu/cross_build_install/lib/libicudata.so." + icu_major + "." + icu_minor, base_dir + "/linux_64/build/libicudata.so." + icu_major)
       base.copy_file(base_dir + "/icu/cross_build_install/lib/libicuuc.so." + icu_major + "." + icu_minor, base_dir + "/linux_64/build/libicuuc.so." + icu_major)
       base.copy_dir(base_dir + "/icu/cross_build_install/include", base_dir + "/linux_64/build/include")
-      
+
     if config.check_option("platform", "linux_arm64") and not base.is_dir(base_dir + "/linux_arm64") and not base.is_os_arm():
       base.create_dir(base_dir + "/icu/linux_arm64")
       os.chdir(base_dir + "/icu/linux_arm64")
@@ -173,6 +187,6 @@ def make():
     if (-1 != config.option("platform").find("ios")):
       if not base.is_dir("build"):
         base.bash("./icu_ios")
-      
+
   os.chdir(old_cur)
   return

scripts/core_common/modules/openssl.py

@@ -87,9 +87,7 @@ def make():
     # -------------------------------------------------------------------------------------------------------
     return
 
-  if (-1 != config.option("platform").find("linux")) and not base.is_dir("../build/linux_64"):
-    ld_library_path_copy = ''
-
+  if (-1 != config.option("platform").find("linux")) and not base.is_dir("../build/linux_64"):     
     base.cmd("./config", ["enable-md2", "no-shared", "no-asm", "--prefix=" + old_cur_dir + "/build/linux_64", "--openssldir=" + old_cur_dir + "/build/linux_64"])
     if "1" == config.option("use-clang"):
       base.replaceInFile("./Makefile", "CC=$(CROSS_COMPILE)gcc", "CC=$(CROSS_COMPILE)clang")
@@ -97,27 +95,24 @@ def make():
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden -stdlib=libc++")
       base.replaceInFile("./Makefile", "LDFLAGS=", "LDFLAGS=-stdlib=libc++")
-    elif config.option("custom-sysroot") == "":
+    elif config.option("sysroot") == "":
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden")
     else:
-      if 'LD_LIBRARY_PATH' in os.environ:
-        ld_library_path_copy = os.environ['LD_LIBRARY_PATH']
-      os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
       base.replaceInFile("./Makefile", "CROSS_COMPILE=", "CROSS_COMPILE=" + config.get_custom_sysroot_bin() + "/")
-      base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("custom-sysroot"),)
-      base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("custom-sysroot"))
+      base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot"))
+      base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot"))
 
-    if config.option("custom-sysroot") == "":
+    if config.option("sysroot") == "":
       base.cmd("make", [])
       base.cmd("make", ["install"])
       base.cmd("make", ["clean"], True)
     else:
+      base.set_sysroot_env()
       base.cmd_exe("make", [])
       base.cmd_exe("make", ["install"])
       base.cmd_exe("make", ["clean"], True)
-      os.environ['LD_LIBRARY_PATH'] = ld_library_path_copy
-    # TODO: support x86
+      base.restore_sysroot_env()
 
   if (-1 != config.option("platform").find("linux_arm64")) and not base.is_dir("../build/linux_arm64"):
     if ("x86_64" != platform.machine()):

scripts/core_common/modules/v8.py

@@ -47,7 +47,7 @@ def is_use_clang():
   gcc_version = base.get_gcc_version()  
     
   is_clang = "false"
-  if config.option("custom-sysroot") == "" and (gcc_version >= 6000 or "1" == config.option("use-clang")):
+  if config.option("sysroot") == "" and (gcc_version >= 6000 or "1" == config.option("use-clang")):
     is_clang = "true"
 
   print("gcc version: " + str(gcc_version) + ", use clang:" + is_clang)

scripts/core_common/modules/v8_89.py

@@ -60,7 +60,7 @@ def make_args(args, platform, is_64=True, is_debug=False):
   
   linux_clang = False
   if platform == "linux":
-    if "" != config.option("custom-sysroot"):
+    if "" != config.option("sysroot"):
       args_copy.append("use_sysroot=false")
       args_copy.append("is_clang=false")
     else:
@@ -206,23 +206,24 @@ def make():
              "treat_warnings_as_errors=false"]
 
   if config.check_option("platform", "linux_64"):
-    ld_library_path_copy = ''
-    if config.option("custom-sysroot") != "":
-      if 'LD_LIBRARY_PATH' in os.environ:
-        ld_library_path_copy = os.environ['LD_LIBRARY_PATH']
-      os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
-
+    if config.option("sysroot") != "":
       src_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = []\n  cflags_c = []\n  cflags_cc = []\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = []"
-      dst_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = [\"--sysroot=" + config.option("custom-sysroot") + "\"]" + "\n  cflags_c = []\n  cflags_cc = [\"--sysroot=" + config.option("custom-sysroot") + "\"]" + "\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = [\"--sysroot=" + config.option("custom-sysroot") + "\"]"
+      dst_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = [\"--sysroot=" + config.option("sysroot") + "\"]" + "\n  cflags_c = []\n  cflags_cc = [\"--sysroot=" + config.option("sysroot") + "\"]" + "\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = [\"--sysroot=" + config.option("sysroot") + "\"]"
       base.replaceInFile("build/config/compiler/BUILD.gn", src_replace, dst_replace)
 
       src_replace = "gcc_toolchain(\"x64\") {\n  cc = \"gcc\"\n  cxx = \"g++\""
       dst_replace = "gcc_toolchain(\"x64\") {\n  cc = \""+ config.get_custom_sysroot_bin() + "/gcc\"\n  cxx = \"" + config.get_custom_sysroot_bin() + "/g++\""
       base.replaceInFile("build/toolchain/linux/BUILD.gn", src_replace, dst_replace)
+      
+      old_env = dict(os.environ)
+      base.set_sysroot_env()
+      base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
+      base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
+      base.restore_sysroot_env()
+    else:
+      base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
+      base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
 
-    base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
-    base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
-    os.environ['LD_LIBRARY_PATH'] = ld_library_path_copy
 
   if config.check_option("platform", "linux_32"):
     base.cmd2("gn", ["gen", "out.gn/linux_32", make_args(gn_args, "linux", False)])

scripts/core_common/modules/webp.py

@@ -0,0 +1,208 @@
+import sys
+sys.path.append('../..')
+import base
+import os
+import config
+
+ARCHES = {"win_64"              : "x64",
+          "win_32"              : "x86",
+          "linux_64"            : "x86_64-linux-gnu",
+          "linux_arm64"         : "aarch64-linux-gnu",
+          "mac_64"              : "x86_64-apple-darwin",
+          "mac_arm64"           : "arm-apple-darwin",
+          "android_arm64_v8a"   : "aarch64-linux-android",
+          "android_armv7"       : "armv7a-linux-androideabi",
+          "android_x86"         : "i686-linux-android",
+          "android_x86_64"      : "x86_64-linux-android",
+          "ios"                 : "arm-apple-darwin",
+          "ios_simulator"       : "x86_64-apple-darwin"}
+
+def get_xcode_sdk(platform):
+    xcode_sdk = "iphoneos"
+    if "simulator" in platform:
+        xcode_sdk = "iphonesimulator"
+    return xcode_sdk
+
+def get_ios_min_version(platform):
+    res = " -miphoneos-version-min=11.0"
+    if "simulator" in platform:
+        res = " -mios-simulator-version-min=11.0"
+    return res
+
+def fetch_repo():
+    base_dir = base.get_script_dir() + "/../../core/Common/3dParty/webp"
+    if not base.is_dir(base_dir):
+        base.create_dir(base_dir)
+    old_dir = os.getcwd()
+    os.chdir(base_dir)
+
+    if (base.is_dir("libwebp")):
+        base.delete_dir_with_access_error("libwebp")
+
+    if not base.is_dir("libwebp"):
+        base.cmd("git", ["clone", "--branch","v1.6.0", "https://chromium.googlesource.com/webm/libwebp"])
+    os.chdir(base_dir + "/libwebp")
+    return old_dir
+
+def create_build_dir(platform, build_type) -> str:
+    build_dir = ""
+    if "win" in platform:
+        target_file = "libwebp"
+        if build_type == "debug":
+            target_file += "-debug"
+        target_file += ".lib"
+        build_dir = "./../build/" + platform + "/"
+        if not base.is_dir(build_dir):
+            base.create_dir(build_dir)
+        elif base.is_file(build_dir + build_type + "/" + ARCHES[platform] + "/lib/" + target_file):
+            build_dir = ""
+    else:
+        build_dir = "./../build/" + platform + "/" + build_type
+        if not base.is_dir(build_dir):
+            base.create_dir(build_dir)
+        if base.is_file(build_dir + "/src/.libs/libwebp.a"):
+            build_dir = ""
+    return build_dir
+
+# get custom sysroot vars as str
+def setup_custom_sysroot_env() -> str:
+  env_vars = []
+  env_vars += ['LD_LIBRARY_PATH=\"' + config.get_custom_sysroot_lib() + "\""]
+  env_vars += ['PATH=\"' + config.option("sysroot") + "/usr/bin:" + base.get_env("PATH") + "\""]
+  env_vars += ['CC=\"' + config.get_custom_sysroot_bin() + "/gcc\""]
+  env_vars += ['CXX=\"' + config.get_custom_sysroot_bin() + "/g++\""]
+  env_vars += ['AR=\"' + config.get_custom_sysroot_bin() + "/ar\""]
+  env_vars += ['RABLIB=\"' + config.get_custom_sysroot_bin() + "/ranlib\""]
+  env_vars += ['CFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+  env_vars += ['CXXFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+  env_vars += ['LDFLAGS=\"' + "--sysroot=" + config.option("sysroot") + "\""]
+
+  env_str = ""
+  for env_var in env_vars:
+    env_str += env_var + " "
+
+  return env_str
+
+def get_args(platform, build_type, build_dir):
+    if "win" in platform:
+        args = []
+        args.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + ARCHES[platform])
+        args.append("call nmake /f Makefile.vc CFG=" + build_type + "-static" + " OBJDIR=" + build_dir)
+        return args
+    elif "linux" in platform:
+        cflags = "-O3 -DNDEBUG"
+        if build_type == "debug":
+            cflags = "-O0 -g"
+
+        if config.option("sysroot") != "":
+            cflags += " --sysroot=" + config.option("sysroot")
+
+        cross_arm64 = ""
+        if platform == "linux_arm64":
+            cross_cimpile_arm64 = config.option("arm64-toolchain-bin")
+            if "" == cross_cimpile_arm64:
+                cross_cimpile_arm64 = "/usr/bin"
+            cross_arm64 = "--cross-compile-prefix=" + cross_cimpile_arm64 + "/" + base.get_prefix_cross_compiler_arm64()
+
+        return ["--host=" + ARCHES[platform], "--enable-static", "--disable-shared",
+                "--disable-libwebpdecoder", "--disable-libwebpdemux",
+                "--disable-libwebpmux", "--disable-libwebpextras", 
+                cross_arm64, "CFLAGS=" + cflags, "LDFLAGS=-static"]
+    elif "mac" in platform:
+        arch = ARCHES[platform]
+        short_arch = arch[:arch.find("-")]
+        if short_arch == "arm":
+            short_arch += "64"
+        
+        cflags = "-O3 -DNDEBUG -arch " + short_arch + " -fPIC"
+        if build_type == "debug":
+            cflags = "-O0 -g -arch " + short_arch + " -fPIC"
+
+        return ["--host=" + arch, "--enable-static", "--disable-shared",
+                "--disable-libwebpdecoder", "--disable-libwebpdemux",
+                "--disable-libwebpmux", "--disable-libwebpextras", 
+                "CFLAGS=" + cflags, "LDFLAGS=-arch " + short_arch]
+    elif "ios" in platform:
+        arch = ARCHES[platform]
+        short_arch = arch[:arch.find("-")]
+        if short_arch == "arm":
+            short_arch += "64"
+        
+        xcode_sdk = get_xcode_sdk(platform)
+        version_min = get_ios_min_version(platform)
+        cflags = "-O3 -DNDEBUG -arch " + short_arch + version_min + " -fembed-bitcode"
+        if build_type == "debug":
+            cflags = "-O0 -g -arch " + short_arch + version_min + " -fembed-bitcode"
+
+        return ["--host=" + arch, "--enable-static", "--disable-shared",
+                "--disable-libwebpdecoder", "--disable-libwebpdemux",
+                "--disable-libwebpmux", "--disable-libwebpextras", 
+                "CC=clang -arch " + short_arch + " -isysroot $(xcrun --sdk " + xcode_sdk + " --show-sdk-path)",
+                "CFLAGS=" + cflags]
+    elif "android" in platform:
+        cflags = "-O3 -DNDEBUG"
+        if build_type == "debug":
+            cflags = "-O0 -g"
+
+        return ["--host=" + ARCHES[platform], "--enable-static", "--disable-shared",
+                "--disable-libwebpdecoder", "--disable-libwebpdemux",
+                "--disable-libwebpmux", "--disable-libwebpextras", 
+                "CFLAGS=" + cflags, "LDFLAGS=-static"]
+
+def make():
+    print("[fetch & build]: webp")
+
+    old_dir = fetch_repo()
+    build_type = "release"
+    if -1 != config.option("config").lower().find("debug"):
+        build_type = "debug"
+    platform = config.option("platform")
+    build_dir = create_build_dir(platform, build_type)
+    
+    if -1 != platform.find("ios"):
+        args_simulator = get_args("iossimulator", build_type, build_dir)
+    args = get_args(platform, build_type, build_dir)
+    
+    if build_dir == "":
+        return
+
+    # WINDOWS
+    if "windows" == base.host_platform():
+        base.run_as_bat(args, True)
+    
+    # LINUX
+    elif -1 != platform.find("linux"):
+        base.cmd("./autogen.sh")
+        os.chdir(build_dir)
+
+        if config.option("sysroot") != "":
+            args += ["CROSS_COMPILE=" + config.get_custom_sysroot_bin() + "/"]
+
+        env_str = setup_custom_sysroot_env() if config.option("sysroot") != "" else ""
+        base.cmd(env_str + "./../../../libwebp/configure",  args)
+        base.cmd(env_str + "make", ["-j$(nproc)"])
+
+    # MAC, ANDROID
+    elif -1 != platform.find("mac") or -1 != platform.find("ios") or -1 != platform.find("android"):
+        base.cmd("./autogen.sh")
+        os.chdir(build_dir)
+        base.cmd("./../../../libwebp/configure",  args)
+        base.cmd("make", ["-j$(sysctl -n hw.ncpu)"])
+
+    # IOS
+    elif -1 != platform.find("ios"):
+        base.cmd("./autogen.sh")
+        os.chdir(build_dir + "/ios")
+        base.cmd("./../../../libwebp/configure",  args)
+        base.cmd("make", ["-j$(sysctl -n hw.ncpu)"])
+        os.chdir(build_dir + "/iossimulator")
+        base.cmd("./../../../libwebp/configure",  args_simulator)
+        base.cmd("make", ["-j$(sysctl -n hw.ncpu)"])
+        os.chdir(build_dir)
+        base.cmd("lipo", ["-create", "/ios/src/.libs/libwebp.a", "/iossimulator/src/.libs/libwebp.a", "-output", "/libwebp.a"])
+        base.cmd("lipo", ["-create", "/ios/src/.libs/libwebpdecoder.a", "/iossimulator/src/.libs/libwebpdecoder.a", "-output", "/libwebpdecoder.a"])
+        base.cmd("lipo", ["-create", "/ios/src/.libs/libwebpdemux.a", "/iossimulator/src/.libs/libwebpdemux.a", "-output", "/libwebpdemux.a"])
+        base.cmd("lipo", ["-create", "/ios/src/.libs/libwebpmux.a", "/iossimulator/src/.libs/libwebpmux.a", "-output", "/libwebpmux.a"])
+        
+    os.chdir(old_dir)
+    return

scripts/deploy_builder.py

@@ -58,7 +58,7 @@ def make():
     #  base.generate_check_linux_system(git_dir + "/build_tools", root_dir)
 
     # icu
-    base.deploy_icu(core_dir, root_dir, platform)
+    base.deploy_icu(core_dir, root_dir, native_platform)
 
     # doctrenderer
     if isWindowsXP:
@@ -108,13 +108,13 @@ def make():
 
     # correct ios frameworks
     if ("ios" == platform):
-      base.generate_plist(root_dir, "ios")
+      base.for_each_framework(root_dir, "ios", callbacks=[base.generate_plist, base.generate_xcprivacy])
 
     if (0 == platform.find("linux")):
       base.linux_correct_rpath_docbuilder(root_dir)
 
     if (0 == platform.find("mac")):
-      base.generate_plist(root_dir, "mac", max_depth=1)
+      base.for_each_framework(root_dir, "mac", callbacks=[base.generate_plist], max_depth=1)
       base.mac_correct_rpath_x2t(root_dir)
       base.mac_correct_rpath_docbuilder(root_dir)
 
@@ -127,11 +127,6 @@ def make():
     base.copy_dir(git_dir  + "/core-fonts/openoffice", root_dir + "/fonts/openoffice")
     base.copy_file(git_dir + "/core-fonts/ASC.ttf",    root_dir + "/fonts/ASC.ttf")
 
-    if native_platform == "win_arm64":
-      base.delete_dir(root_dir + "/sdkjs")
-      base.copy_dir(root_dir_win64 + "/sdkjs", root_dir + "/sdkjs")
-      return
-
     # delete unnecessary builder files
     def delete_files(files):
       for file in files:

scripts/deploy_core.py

@@ -69,17 +69,13 @@ def make():
 
     # correct mac frameworks
     if (0 == platform.find("mac")):
-      base.generate_plist(archive_dir, "mac", max_depth=1)
+      base.for_each_framework(archive_dir, "mac", callbacks=[base.generate_plist], max_depth=1)
+      base.mac_correct_rpath_x2t(archive_dir)
 
     # js cache
     base.generate_doctrenderer_config(archive_dir + "/DoctRenderer.config", "./", "builder", "", "./dictionaries")
     base.create_x2t_js_cache(archive_dir, "core", platform)
     base.delete_file(archive_dir + "/DoctRenderer.config")
-    
-    # just copy sdkjs to avoid executing arm64 x2t on non-arm system
-    if native_platform == "win_arm64" :
-      base.delete_dir(archive_dir + "/sdkjs")
-      base.copy_dir(archive_dir + "/../../../win_64/" + branding + "/core/sdkjs", archive_dir + "/sdkjs")
 
     # dictionaries
     base.copy_dictionaries(git_dir + "/dictionaries", archive_dir + "/dictionaries", True, False)

scripts/deploy_desktop.py

@@ -82,7 +82,7 @@ def make():
     #  base.generate_check_linux_system(git_dir + "/build_tools", root_dir + "/converter")
 
     # icu
-    base.deploy_icu(core_dir, root_dir + "/converter", platform)
+    base.deploy_icu(core_dir, root_dir + "/converter", native_platform)
 
     # doctrenderer
     if isWindowsXP:
@@ -117,6 +117,20 @@ def make():
     else:
       base.copy_files(core_dir + "/Common/3dParty/cef/" + native_platform + "/" + build_dir_name + "/*", root_dir)
 
+    if (0 == platform.find("mac")):
+      dir_base_old = os.getcwd()
+      os.chdir(root_dir + "/Chromium Embedded Framework.framework")
+      base.create_dir("Versions")
+      base.create_dir("Versions/A")
+      base.move_file("Chromium Embedded Framework", "Versions/A/Chromium Embedded Framework")
+      base.move_dir("Resources", "Versions/A/Resources")
+      base.move_dir("Libraries", "Versions/A/Libraries")
+      base.cmd("ln", ["-s", "Versions/A/Chromium Embedded Framework", "Chromium Embedded Framework"])
+      base.cmd("ln", ["-s", "Versions/A/Resources", "Resources"])
+      base.cmd("ln", ["-s", "Versions/A/Libraries", "Libraries"])
+      base.cmd("ln", ["-s", "A", "Versions/Current"])
+      os.chdir(dir_base_old);
+
     isUseQt = True
     if (0 == platform.find("mac")) or (0 == platform.find("ios")):
       isUseQt = False
@@ -172,8 +186,6 @@ def make():
         base.copy_file(git_dir + "/desktop-apps/win-linux/extras/projicons/" + apps_postfix + "/projicons.exe", root_dir + "/DesktopEditors.exe")
         if not isWindowsXP:
           base.copy_file(git_dir + "/desktop-apps/win-linux/extras/update-daemon/" + apps_postfix + "/updatesvc.exe", root_dir + "/updatesvc.exe")
-        else:
-          base.copy_file(git_dir + "/desktop-apps/win-linux/extras/online-installer/" + apps_postfix + "/online-installer.exe", root_dir + "/online-installer.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/" + apps_postfix + "/DesktopEditors.exe", root_dir + "/editors.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/res/icons/desktopeditors.ico", root_dir + "/app.ico")
       elif (0 == platform.find("linux")):
@@ -230,6 +242,19 @@ def make():
     #base.copy_dir(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins/encrypt/ui/engine/database/{9AB4BBA8-A7E5-48D5-B683-ECE76A020BB1}", root_dir + "/editors/sdkjs-plugins/{9AB4BBA8-A7E5-48D5-B683-ECE76A020BB1}")
     base.copy_sdkjs_plugin(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins", root_dir + "/editors/sdkjs-plugins", "sendto", True)
 
+    isUseAgent = True
+    if isWindowsXP:
+      isUseAgent = False
+
+    if (isUseAgent):
+      agent_plugin_dir = git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins/ai-agent"
+      if (False):
+        base.cmd_in_dir(agent_plugin_dir, "npm", ["install"], True)
+        base.cmd_in_dir(agent_plugin_dir, "npm", ["run", "build"], True)
+        base.copy_dir(agent_plugin_dir + "/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}", root_dir + "/editors/sdkjs-plugins/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}")
+      else:
+        base.copy_dir(agent_plugin_dir + "/deploy/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}", root_dir + "/editors/sdkjs-plugins/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}")
+
     base.copy_file(base_dir + "/js/" + branding + "/desktop/index.html", root_dir + "/index.html")
     base.create_dir(root_dir + "/editors/webext")
     base.copy_file(base_dir + "/js/" + branding + "/desktop/noconnect.html", root_dir + "/editors/webext/noconnect.html")
@@ -240,11 +265,6 @@ def make():
     else:
       base.copy_dir(git_dir + "/desktop-apps/common/loginpage/providers", root_dir + "/providers")
 
-    # license
-    if (0 == platform.find("mac")):
-      base.create_dir(root_dir + "/license")
-      base.copy_file(git_dir + "/desktop-apps/common/package/license/opensource/EULA.html", root_dir + "/license/EULA.html")
-
     isUseJSC = False
     if (0 == platform.find("mac")):
       doctrenderer_lib = "libdoctrenderer.dylib"
@@ -279,7 +299,7 @@ def make():
 
     if (0 == platform.find("mac")):
       # gen plists with max_depth 2 because frameworks are only located in root_dir and converter subdirectory
-      base.generate_plist(root_dir, "mac", max_depth=2)
+      base.for_each_framework(root_dir, "mac", callbacks=[base.generate_plist], max_depth=2)
       base.mac_correct_rpath_desktop(root_dir)
 
     if is_host_not_arm:
@@ -292,8 +312,8 @@ def make():
       themes_params = []
       if ("" != config.option("themesparams")):
         themes_params = ["--params=\"" + config.option("themesparams") + "\""]
-      base.cmd_exe(root_dir + "/converter/allfontsgen", ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""])
-      base.cmd_exe(root_dir + "/converter/allthemesgen", ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params)
+      base.cmd_exe(root_dir + "/converter/allfontsgen", ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""], True)
+      base.cmd_exe(root_dir + "/converter/allthemesgen", ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params, True)
       base.delete_file(root_dir + "/converter/AllFonts.js")
       base.delete_file(root_dir + "/converter/font_selection.bin")
       base.delete_file(root_dir + "/converter/fonts.log")

scripts/deploy_mobile.py

@@ -80,7 +80,7 @@ def make():
 
     # correct ios frameworks
     if ("ios" == platform):
-      base.generate_plist(root_dir, "ios")
+      base.for_each_framework(root_dir, "ios", callbacks=[base.generate_plist, base.generate_xcprivacy])
       deploy_fonts(git_dir, root_dir)
       base.copy_dictionaries(git_dir + "/dictionaries", root_dir + "/dictionaries", True, False)
 

scripts/deploy_osign.py

@@ -37,7 +37,7 @@ def make():
 
     # correct ios frameworks
     if ("ios" == platform):
-      base.generate_plist(root_dir, "ios")
+      base.for_each_framework(root_dir, "ios", callbacks=[base.generate_plist, base.generate_xcprivacy])
 
   for native_platform in platforms:
     if native_platform == "android":

scripts/deploy_server.py

@@ -58,6 +58,14 @@ def make():
     base.create_dir(build_server_dir + '/Metrics/node_modules/modern-syslog/build/Release')
     base.copy_file(server_dir + "/Metrics/node_modules/modern-syslog/build/Release/core.node", build_server_dir + "/Metrics/node_modules/modern-syslog/build/Release/core.node")
 
+    # AdminPanel server part
+    base.create_dir(build_server_dir + '/AdminPanel/server')
+    base.copy_exe(server_dir + "/AdminPanel/server", build_server_dir + '/AdminPanel/server', "adminpanel")
+
+    # AdminPanel client part
+    base.create_dir(build_server_dir + '/AdminPanel/client/build')
+    base.copy_dir(server_dir + '/AdminPanel/client/build', build_server_dir + '/AdminPanel/client/build')
+
     qt_dir = base.qt_setup(native_platform)
     platform = native_platform
 
@@ -104,7 +112,7 @@ def make():
 
     # correct mac frameworks
     if (0 == platform.find("mac")):
-      base.generate_plist(converter_dir, "mac", max_depth=1)
+      base.for_each_framework(converter_dir, "mac", callbacks=[base.generate_plist], max_depth=1)
 
     # js
     js_dir = root_dir

scripts/package_desktop.py

@@ -75,9 +75,6 @@ def make_windows():
     make_prepare("xp")
     make_zip("xp")
     make_inno("xp")
-  # Disable build online installer
-  # if common.platform == "windows_x86_xp":
-  #  make_online()
 
   utils.set_cwd(common.workspace_dir)
   return
@@ -169,18 +166,6 @@ def make_advinst(edition = "opensource"):
     utils.set_summary("desktop advinst " + edition + " deploy", ret)
   return
 
-def make_online():
-  online_file = utils.glob_file("OnlineInstaller-" + package_version + "*.exe")
-  utils.log_h2("desktop online installer build")
-  ret = utils.is_file(online_file)
-  utils.set_summary("desktop online installer build", ret)
-
-  if common.deploy and ret:
-    utils.log_h2("desktop online installer deploy")
-    ret = s3_upload([online_file], "desktop/win/online/")
-    utils.set_summary("desktop online installer deploy", ret)
-  return
-
 #
 # macOS
 #

scripts/qmake.py

@@ -100,9 +100,8 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
     if "1" == config.option("use-clang"):
       build_params.append("-spec")
       build_params.append("linux-clang-libc++")
-    if "" != config.option("custom-sysroot"):
-      os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
-      os.environ['QMAKE_CUSTOM_SYSROOT'] = config.option("custom-sysroot")
+    if "" != config.option("sysroot"):
+      base.set_sysroot_env()
       base.cmd_exe(qmake_app, build_params) # calls cmd_exe to pass os.env
     else:
       base.cmd(qmake_app, build_params)

tools/linux/automate.py

@@ -71,7 +71,10 @@ if not base.is_file("./node_js_setup_14.x"):
 
 if not base.is_dir("./qt_build"):
   print("install qt...")
-  install_qt_prebuild()
+  if base.get_env("DO_NOT_USE_PREBUILD_QT") == "1":
+    install_qt()
+  else:
+    install_qt_prebuild()
 
 branch = get_branch_name("../..")
 

tools/linux/sysroot/build_sysroot.py

@@ -29,7 +29,37 @@ def download_sysroot():
 
     bash_chroot('apt update -y', tmp_sysroot_ubuntu_dir)
     bash_chroot('apt upgrade -y', tmp_sysroot_ubuntu_dir)
-    bash_chroot('apt install -y build-essential curl libpthread-stubs0-dev zlib1g-dev', tmp_sysroot_ubuntu_dir)
+    
+    apt_libs = ["build-essential"]
+    apt_libs += ["libpthread-stubs0-dev"]
+    apt_libs += ["zlib1g-dev"]
+    apt_libs += ["curl"]
+    apt_libs += ["libc6-dev"]
+    apt_libs += ["glib-2.0-dev"]
+    apt_libs += ["libglu1-mesa-dev"]
+    apt_libs += ["libgtk-3-dev"]
+    apt_libs += ["libpulse-dev"]
+    apt_libs += ["libasound2-dev"]
+    apt_libs += ["libatspi2.0-dev"]
+    apt_libs += ["libcups2-dev"]
+    apt_libs += ["libdbus-1-dev"]
+    apt_libs += ["libicu-dev"]
+    apt_libs += ["libgstreamer1.0-dev"]
+    apt_libs += ["libgstreamer-plugins-base1.0-dev"]
+    apt_libs += ["libx11-xcb-dev"]
+    apt_libs += ["libxcb*"]
+    apt_libs += ["libxi-dev"]
+    apt_libs += ["libxrender-dev"]
+    apt_libs += ["libxss-dev"]
+    apt_libs += ["libxkbcommon-dev"]
+    apt_libs += ["libxkbcommon-x11-dev"]
+    apt_libs += ["libnotify-dev"]
+    apt_libs += ["gtk+-3.0-dev"]
+    
+    apt_libs_str = ""
+    for apt_lib in apt_libs:
+        apt_libs_str += apt_lib + " "
+    bash_chroot('apt install -y ' + apt_libs_str, tmp_sysroot_ubuntu_dir)
 
     # # downloading arm toolchain
     arm_toolchain_url = 'https://releases.linaro.org/components/toolchain/binaries/5.4-2017.05/aarch64-linux-gnu/'

tools/linux/sysroot/custom-sysroot.toolchain.cmake

@@ -0,0 +1,4 @@
+set(CMAKE_C_FLAGS $ENV{CFLAGS})
+set(CMAKE_CXX_FLAGS $ENV{CXXFLAGS})
+set(CMAKE_C_LINKER_FLAGS $ENV{LDFLAGS})
+set(CMAKE_CXX_LINKER_FLAGS $ENV{LDFLAGS})

tools/linux/sysroot/fix_symlinks.py

@@ -4,46 +4,42 @@ import uuid
 
 # change symbolic link to relative paths
 def fix_symlinks(top_dir='./sysroot_ubuntu_1604'):
-    top_dir += '/usr/lib/x86_64-linux-gnu'
     for root, dirs, files in os.walk(top_dir):
         for name in files:
             path = os.path.join(root, name)
             if not os.path.islink(path):
                 continue
-
             try:
                 target = os.readlink(path)
             except OSError as e:
                 print(f"Error reading link '{path}': {e}", file=sys.stderr)
                 continue
-
-            if not target.startswith('/lib/'):
+            
+            if not target.startswith('/'):
                 continue
-
-            new_target = "../../../lib" + target[4:]
+            
+            new_target = top_dir + target
+            new_target_rel = os.path.relpath(new_target, os.path.dirname(path))
             temp_name = f".tmp.{uuid.uuid4().hex}"
             temp_path = os.path.join(root, temp_name)
-
             try:
-                os.symlink(new_target, temp_path)
+                os.symlink(new_target_rel, temp_path)
             except OSError as e:
                 print(f"Failed to create temporary symlink for '{path}': {e}", file=sys.stderr)
                 continue
-
             try:
                 os.replace(temp_path, path)
-                print(f"Updated: {path} -> {new_target}")
+                print(f"Updated: {path} -> {new_target_rel}")
             except OSError as e:
                 print(f"Failed to replace symlink '{path}': {e}", file=sys.stderr)
                 try:
                     os.unlink(temp_path)
                 except OSError:
                     pass
-        break # no subfolders
 
 if __name__ == "__main__":
     if len(sys.argv) > 1:
         directory = sys.argv[1]
     else:
         directory = './sysroot_ubuntu_1604'
-    fix_symlinks(directory)
+    fix_symlinks(directory)