enchancements to install from url

add support for myrient.erista.me website
use spaces for separator, seems less overcrowded
2024-10-08 20:50:42 -07:00 · 2024-07-20 02:45:52 -07:00 · 2024-07-16 21:27:12 -07:00 · 2024-07-16 20:59:32 -07:00 · 2024-07-16 20:59:23 -07:00 · 2024-07-16 10:42:18 -07:00
47 changed files with 1870 additions and 256 deletions
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)

 project(ezremote_client)

@@ -25,8 +25,10 @@ add_executable(ezremote_client
  source/http/httplib.cpp
  source/clients/baseclient.cpp
  source/clients/apache.cpp
+  source/clients/archiveorg.cpp
  source/clients/ftpclient.cpp
  source/clients/gdrive.cpp
+  source/clients/myrient.cpp
  source/clients/iis.cpp
  source/clients/nginx.cpp
  source/clients/npxserve.cpp
@@ -67,7 +69,7 @@ add_executable(ezremote_client

 add_self(ezremote_client)

-add_pkg(ezremote_client ${CMAKE_SOURCE_DIR}/data "RMTC00001" "ezRemote Client" "01.25" 32 0)
+add_pkg(ezremote_client ${CMAKE_SOURCE_DIR}/data "RMTC00001" "ezRemote Client" "01.29" 32 0)

 target_link_libraries(ezremote_client
  c
@@ -81,7 +81,13 @@ To distinguish between FTP, SMB, NFS, WebDAV or HTTP, the URL must be prefix wit
   ```
 - For Google Drive use the following URL for the server  **https://drive.google.com**
   <br />[Go to the following wiki for instructions on how to setup the app to connect to Google Drive]( https://github.com/cy33hc/ps4-ezremote-client/wiki/Setup-App-for-use-with-Google-Drive)
-   
+
+- For Internet Archive repos download URLs
+  - Only supports parsing of the download URL (ie the URL where you see a list of files). Example
+    |      |           |  |
+    |----------|-----------|---|
+    | ![archive_org_screen1](https://github.com/user-attachments/assets/b129b6cf-b938-4d7c-a3fa-61e1c633c1f6) | ![archive_org_screen2](https://github.com/user-attachments/assets/646106d1-e60b-4b35-b153-3475182df968)| ![image](https://github.com/user-attachments/assets/cad94de8-a694-4ef5-92a8-b87468e30adb) |
+       
 Tested with following WebDAV server:
 - **(Recommeded)** [Dufs](https://github.com/sigoden/dufs) - For hosting your own WebDAV server. (Recommended since this allow anonymous access which is required for Remote Package Install)
 - [SFTPgo](https://github.com/drakkan/sftpgo) - For local hosted WebDAV server. Can also be used as a webdav frontend for Cloud Storage like AWS S3, Azure Blob or Google Storage.
@@ -136,6 +142,7 @@ Circle - Un-Select the file list to navigate to other widgets or Close Dialog wi
 Square - Mark file(s)/folder(s) for Delete/Rename/Upload/Download
 R1 - Navigate to the Remote list of files
 L1 - Navigate to the Local list of files
+L2 - To go up a directory from current directory
 TouchPad Button - Exit Application (versions prior to 1.06)
 Options Button - Exit Application (versions 1.06 and above)
 ```
@@ -113,7 +113,7 @@ STR_DOWNLOAD_INSTALL_MSG=تثبيت الحزمة عن بعد غير ممكن. ه
 STR_CHECKING_REMOTE_SERVER_MSG=التحقق من الخادم البعيد لتثبيت الحزمة عن بعد.
 STR_ENABLE_RPI=RPI
 STR_ENABLE_RPI_FTP_SMB_MSG=يتيح هذا الخيار تثبيت الحزمة عن بُعد عبر خادم الويب المضمن.
-STR_ENABLE_RPI_WEBDAV_MSG==يتيح هذا الخيار تثبيت الحزمة عن بُعد عبر خادم الويب المضمن.
+STR_ENABLE_RPI_WEBDAV_MSG=يتيح هذا الخيار تثبيت الحزمة عن بُعد عبر خادم الويب المضمن.
 STR_FILES=الملفات
 STR_EDITOR=المحرر
 STR_SAVE=حفظ
@@ -112,8 +112,8 @@ STR_CANNOT_CONNECT_REMOTE_MSG=Remote HTTP Server not reachable.
 STR_DOWNLOAD_INSTALL_MSG=Remote Package Install not possible. Would you like to download package and install instead?
 STR_CHECKING_REMOTE_SERVER_MSG=Checking remote server for Remote Package Install.
 STR_ENABLE_RPI=RPI
-STR_ENABLE_RPI_FTP_SMB_MSG=This option enables Remote Package Installation via embedded Web Server.
-STR_ENABLE_RPI_WEBDAV_MSG==This option enables Remote Package Installation via embedded Web Server.
+STR_ENABLE_RPI_FTP_SMB_MSG=This option enables Remote Package Installation via embedded Web Server proxy.
+STR_ENABLE_RPI_WEBDAV_MSG=This option enables Remote Package Installation via embedded Web Server proxy.
 STR_FILES=Files
 STR_EDITOR=Editor
 STR_SAVE=Save
@@ -160,3 +160,7 @@ STR_LANGUAGE=Language
 STR_TEMP_DIRECTORY=Temp Directory
 STR_REALDEBRID=Real-Debrid
 STR_BACKGROUND_INSTALL_INPROGRESS=Package install is running in the background. Don't close the app while install is in progress
+STR_ENABLE_DISC_CACHE_MSG=Enable disk caching. Can improve Remote Package Install speed in cases where connection to remote is slow, but breaks resuming of install
+STR_ENABLE_ALLDEBRID_MSG=Install Via AllDebrid
+STR_ENABLE_REALDEBRID_MSG=Install Via RealDebrid
+STR_ENABLE_DISKCACHE_DESC=Enable Disk Cache
@@ -25,7 +25,7 @@ STR_FILE=파일
 STR_TYPE=종류
 STR_NAME=이름
 STR_SIZE=크기
-STR_DATE=일시
+STR_DATE=날짜
 STR_NEW_FOLDER=새 폴더
 STR_RENAME=이름 변경
 STR_DELETE=삭제
@@ -39,7 +39,7 @@ STR_OVERWRITE=덮어쓰기
 STR_DONT_OVERWRITE=덮어쓰기 금지
 STR_ASK_FOR_CONFIRM=수락여부를 질문
 STR_DONT_ASK_CONFIRM=수락여부를 묻지 않음
-STR_ALLWAYS_USE_OPTION=두번다시 묻지 않고 항상 이 설정을 사용
+STR_ALLWAYS_USE_OPTION=두 번 다시 묻지 않고 항상 이 설정을 사용
 STR_ACTIONS=실행
 STR_CONFIRM=확인
 STR_OVERWRITE_OPTIONS=덮어쓰기 옵션
@@ -59,3 +59,75 @@ STR_FAIL_DEL_DIR_MSG=디렉토리 삭제에 실패하였습니다.
 STR_DELETING=삭제 중
 STR_FAIL_DEL_FILE_MSG=파일 삭제에 실패하였습니다.
 STR_DELETED=삭제됨
+STR_LINK=링크
+STR_SHARE=공유
+STR_FAILED=310 실패함
+STR_FAIL_CREATE_LOCAL_FILE_MSG=310 로컬에서 파일을 만들기 실패함
+STR_INSTALL=설치
+STR_INSTALLING=설치 중
+STR_INSTALL_SUCCESS=성공
+STR_INSTALL_FAILED=실패함
+STR_INSTALL_SKIPPED=건너뜀
+STR_CHECK_HTTP_MSG=원격 HTTP 서버에 대한 연결 확인
+STR_FAILED_HTTP_CHECK=HTTP 서버에 연결에 실패함
+STR_REMOTE_NOT_HTTP=원격이 HTTP 서버가 아님
+STR_INSTALL_FROM_DATA_MSG=패키지가 /data 또는 /mnt/usbX 폴더에 없음
+STR_ALREADY_INSTALLED_MSG=패키지가 이미 설치되었음
+STR_INSTALL_FROM_URL=URL에서 설치
+STR_CANNOT_READ_PKG_HDR_MSG=패키지 헤더 정보를 읽을 수 없음
+STR_FAVORITE_URLS=즐겨찾기 URL
+STR_SLOT=슬롯
+STR_EDIT=편집
+STR_ONETIME_URL=한 번만 Url
+STR_NOT_A_VALID_PACKAGE=유효하지 않은 패키지
+STR_WAIT_FOR_INSTALL_MSG=패키지 설치가 완료되기를 기다리는 중
+STR_FAIL_INSTALL_TMP_PKG_MSG=pkg 파일을 설치하지 못했습니다. tmp pkg를 수동으로 삭제하세요.
+STR_AUTO_DELETE_TMP_PKG=설치 후 임시로 다운로드한 pkg 파일을 자동으로 삭제
+STR_PROTOCOL_NOT_SUPPORTED=지원되지 않는 프로토콜
+STR_COULD_NOT_RESOLVE_HOST=호스트 이름을 확인할 수 없음
+STR_EXTRACT=압축 해제
+STR_EXTRACTING=압축 해제 중
+STR_FAILED_TO_EXTRACT=압축 해제 실패함
+STR_EXTRACT_LOCATION=압축 해제 위치
+STR_COMPRESS=압축
+STR_ZIP_FILE_PATH=Zip 파일 이름
+STR_COMPRESSING=압축 중
+STR_ERROR_CREATE_ZIP=zip 파일을 만드는 동안 오류 발생
+STR_UNSUPPORTED_FILE_FORMAT=지원되지 않는 압축 파일 형식
+STR_CUT=잘라내기
+STR_COPY=복사
+STR_PASTE=붙여넣기
+STR_MOVING=이동 중
+STR_COPYING=복사 중
+STR_FAIL_MOVE_MSG=파일 이동 실패함
+STR_FAIL_COPY_MSG=파일 복사 실패함
+STR_CANT_MOVE_TO_SUBDIR_MSG=상위 디렉토리를 하위 디렉토리로 이동할 수 없음
+STR_CANT_COPY_TO_SUBDIR_MSG=상위 디렉토리를 하위 디렉토리로 복사할 수 없음
+STR_UNSUPPORTED_OPERATION_MSG=지원되지 않는 작업
+STR_HTTP_PORT=Http 포트
+STR_REINSTALL_CONFIRM_MSG=콘텐츠가 이미 설치되었습니다. 설치를 계속할까요?
+STR_REMOTE_NOT_SUPPORT_MSG=보호된 서버에서는 원격 패키지 설치가 지원되지 않습니다.
+STR_CANNOT_CONNECT_REMOTE_MSG=원격 HTTP 서버에 연결할 수 없습니다.
+STR_DOWNLOAD_INSTALL_MSG=원격 패키지 설치가 불가능합니다. 패키지를 다운로드하여 설치할까요?
+STR_CHECKING_REMOTE_SERVER_MSG=원격 패키지 설치를 위해 원격 서버를 확인하고 있습니다.
+STR_FILES=파일
+STR_EDITOR=편집기
+STR_SAVE=저장
+STR_MAX_EDIT_FILE_SIZE_MSG=다음보다 큰 파일을 편집할 수 없음
+STR_DELETE_LINE=선택한 줄 삭제
+STR_INSERT_LINE=선택한 줄 아래에 삽입
+STR_MODIFIED=수정됨
+STR_FAIL_GET_TOKEN_MSG=다음에서 접속 토큰을 얻는데 실패함
+STR_GET_TOKEN_SUCCESS_MSG=로그인에 성공했습니다. 브라우저를 닫고 애플리케이션으로 돌아갈 수 있음
+STR_NEW_FILE=새 파일
+STR_SETTINGS=설정
+STR_GLOBAL=글로벌
+STR_COPY_LINE=선택한 줄 복사
+STR_PASTE_LINE=선택한 줄에 붙여넣기
+STR_SHOW_HIDDEN_FILES=숨겨진 파일 표시
+STR_SET_DEFAULT_DIRECTORY=기본 폴더 설정
+STR_SET_DEFAULT_DIRECTORY_MSG=기본 디렉터리로 설정됨
+STR_NFS_EXP_PATH_MISSING_MSG=URL에 NFS 내보내기 경로 없음
+STR_FAIL_INIT_NFS_CONTEXT=NFS 컨텍스트를 초기화 실패함
+STR_FAIL_MOUNT_NFS_MSG=NFS 공유를 마운트 실패함
+STR_VIEW_IMAGE=이미지 보기
@@ -1,75 +1,133 @@
 STR_CONNECTION_SETTINGS=Bağlantı Ayarları
 STR_SITE=Site
 STR_LOCAL=Yerel
-STR_REMOTE=Uzaktan
+STR_REMOTE=Uzak
 STR_MESSAGES=Mesajlar
 STR_UPDATE_SOFTWARE=Yazılımı Güncelle
 STR_CONNECT=Bağlan
-STR_DISCONNECT=Bağlantıyı kes
-STR_SEARCH=Ara
+STR_DISCONNECT=Bağlantıyı Kes
+STR_SEARCH=Arama
 STR_REFRESH=Yenile
 STR_SERVER=Sunucu
 STR_USERNAME=Kullanıcı Adı
-STR_PASSWORD=Şifre
+STR_PASSWORD=Parola
 STR_PORT=Port
-STR_PASV=Pasv
+STR_PASV=Pasif
 STR_DIRECTORY=Dizin
 STR_FILTER=Filtre
 STR_YES=Evet
 STR_NO=Hayır
 STR_CANCEL=İptal
-STR_CONTINUE=Devam
+STR_CONTINUE=Devam Et
 STR_CLOSE=Kapat
 STR_FOLDER=Klasör
 STR_FILE=Dosya
-STR_TYPE=Tip
+STR_TYPE=Tür
 STR_NAME=Ad
 STR_SIZE=Boyut
 STR_DATE=Tarih
 STR_NEW_FOLDER=Yeni Klasör
 STR_RENAME=Yeniden Adlandır
 STR_DELETE=Sil
-STR_UPLOAD=Karşıya Yükle
+STR_UPLOAD=Yükle
 STR_DOWNLOAD=İndir
-STR_SELECT_ALL=Tümünü Seç
-STR_CLEAR_ALL=Tümünü Temizle
-STR_UPLOADING=Karşıya Yükleniyor
+STR_SELECT_ALL=Hepsini Seç
+STR_CLEAR_ALL=Hepsini Temizle
+STR_UPLOADING=Yükleniyor
 STR_DOWNLOADING=İndiriliyor
-STR_OVERWRITE=Üzerine yaz
-STR_DONT_OVERWRITE=Üzerine yazma
-STR_ASK_FOR_CONFIRM=Onaylamak için sor
-STR_DONT_ASK_CONFIRM=Onaylamak için sorma
-STR_ALLWAYS_USE_OPTION=Daima bu seçeneği kullan ve bir daha sorma
-STR_ACTIONS=Eylemler
+STR_OVERWRITE=Üzerine Yaz
+STR_DONT_OVERWRITE=Üzerine Yazma
+STR_ASK_FOR_CONFIRM=Onay İste
+STR_DONT_ASK_CONFIRM=Onay İsteme
+STR_ALLWAYS_USE_OPTION=Bu seçeneği her zaman kullan ve bir daha sorma
+STR_ACTIONS=İşlemler
 STR_CONFIRM=Onayla
-STR_OVERWRITE_OPTIONS=Ayarların üzerine yaz
+STR_OVERWRITE_OPTIONS=Üzerine Yazma Seçenekleri
 STR_PROPERTIES=Özellikler
-STR_PROGRESS=Durum
+STR_PROGRESS=İlerleme
 STR_UPDATES=Güncellemeler
 STR_DEL_CONFIRM_MSG=Bu dosya(ları)/klasör(leri) silmek istediğinizden emin misiniz?
-STR_CANCEL_ACTION_MSG=İptal ediliyor. Son işlemin tamamlanması bekleniyor
-STR_FAIL_UPLOAD_MSG=Dosya karşıya yükleme başarısız
-STR_FAIL_DOWNLOAD_MSG=Dosya indirme başarısız
-STR_FAIL_READ_LOCAL_DIR_MSG=Dizindeki içerikler okunamadı ya da öyle bir klasör yok
-STR_CONNECTION_CLOSE_ERR_MSG=426 Bağlantı kesildi.
-STR_REMOTE_TERM_CONN_MSG=426 Uzaktan Sunucu bağlantıyı kesti.
-STR_FAIL_LOGIN_MSG=300 Giriş başarısız. Lütfen kullanıcı adınızı ve şifrenizi kontrol edin.
+STR_CANCEL_ACTION_MSG=İptal ediliyor. Son eylemin tamamlanması bekleniyor
+STR_FAIL_UPLOAD_MSG=Dosya yüklenemedi
+STR_FAIL_DOWNLOAD_MSG=Dosya indirilemedi
+STR_FAIL_READ_LOCAL_DIR_MSG=Yerel dizinin içeriği okunamadı veya klasör mevcut değil.
+STR_CONNECTION_CLOSE_ERR_MSG=426 Bağlantı kapatıldı.
+STR_REMOTE_TERM_CONN_MSG=426 Uzak Sunucu bağlantıyı sonlandırdı.
+STR_FAIL_LOGIN_MSG=300 Giriş Başarısız. Lütfen kullanıcı adınızı veya şifrenizi kontrol edin.
 STR_FAIL_TIMEOUT_MSG=426 Başarısız. Bağlantı zaman aşımına uğradı.
-STR_FAIL_DEL_DIR_MSG=Dizin silme başarısız
+STR_FAIL_DEL_DIR_MSG=Dizin silinemedi
 STR_DELETING=Siliniyor
-STR_FAIL_DEL_FILE_MSG=Dosya silme başarısız
+STR_FAIL_DEL_FILE_MSG=Dosya silinemedi
 STR_DELETED=Silindi
-STR_LINK=Link
+STR_LINK=Bağlantı
 STR_SHARE=Paylaş
 STR_FAILED=310 Başarısız
-STR_FAIL_CREATE_LOCAL_FILE_MSG=310 Yerelde dosya oluşturulumu başarısız
-STR_INSTALL=Yükle
-STR_INSTALLING=Yükleniyor
+STR_FAIL_CREATE_LOCAL_FILE_MSG=310 Yerelde dosya oluşturulamadı
+STR_INSTALL=Kur
+STR_INSTALLING=Kuruluyor
 STR_INSTALL_SUCCESS=Başarılı
 STR_INSTALL_FAILED=Başarısız
 STR_INSTALL_SKIPPED=Atlandı
-STR_CHECK_HTTP_MSG=Uzaktan HTTP Sunucusu bağlantısı kontrol ediliyor
-STR_FAILED_HTTP_CHECK=HTTP Sunucusuna bağlantı başarısız
-STR_REMOTE_NOT_HTTP=Uzaktaki HTTP Sunucusu değil
-STR_INSTALL_FROM_DATA_MSG=Paket /data ya da /mnt/usbX dizininde değil
+STR_CHECK_HTTP_MSG=Uzak HTTP Sunucusuna bağlantı kontrol ediliyor
+STR_FAILED_HTTP_CHECK=HTTP Sunucusuna bağlanılamadı
+STR_REMOTE_NOT_HTTP=Uzak bir HTTP Sunucusu değil
+STR_INSTALL_FROM_DATA_MSG=Paket /data veya /mnt/usbX klasöründe değil
 STR_ALREADY_INSTALLED_MSG=Paket zaten kurulu
+STR_INSTALL_FROM_URL=URL'den Kur
+STR_CANNOT_READ_PKG_HDR_MSG=Paket başlık bilgisi okunamadı
+STR_FAVORITE_URLS=Favori URL'ler
+STR_SLOT=Yuva
+STR_EDIT=Düzenle
+STR_ONETIME_URL=Tek Seferlik URL
+STR_NOT_A_VALID_PACKAGE=Geçerli bir Paket değil
+STR_WAIT_FOR_INSTALL_MSG=Paketin kurulmasının tamamlanması bekleniyor
+STR_FAIL_INSTALL_TMP_PKG_MSG=Geçici paketin kurulumu başarısız. Lütfen geçici paketi manuel olarak silin
+STR_AUTO_DELETE_TMP_PKG=Kurulumdan sonra geçici indirilen paketi otomatik olarak sil
+STR_PROTOCOL_NOT_SUPPORTED=Protokol desteklenmiyor
+STR_COULD_NOT_RESOLVE_HOST=Ana bilgisayar adı çözülemedi
+STR_EXTRACT=Çıkart
+STR_EXTRACTING=Çıkartılıyor
+STR_FAILED_TO_EXTRACT=Çıkartma başarısız oldu
+STR_EXTRACT_LOCATION=Çıkartılacak Konum
+STR_COMPRESS=Sıkıştır
+STR_ZIP_FILE_PATH=Zip Dosya Adı
+STR_COMPRESSING=Sıkıştırılıyor
+STR_ERROR_CREATE_ZIP=Zip oluşturulurken hata oluştu
+STR_UNSUPPORTED_FILE_FORMAT=Desteklenmeyen sıkıştırılmış dosya formatı
+STR_CUT=Kes
+STR_COPY=Kopyala
+STR_PASTE=Yapıştır
+STR_MOVING=Taşınıyor
+STR_COPYING=Kopyalanıyor
+STR_FAIL_MOVE_MSG=Dosya taşınamadı
+STR_FAIL_COPY_MSG=Dosya kopyalanamadı
+STR_CANT_MOVE_TO_SUBDIR_MSG=Ana dizin alt dizinine taşınamaz
+STR_CANT_COPY_TO_SUBDIR_MSG=Ana dizin alt dizinine kopyalanamaz
+STR_UNSUPPORTED_OPERATION_MSG=Desteklenmeyen işlem
+STR_HTTP_PORT=Http Portu
+STR_REINSTALL_CONFIRM_MSG=İçerik zaten kurulu. Kuruluma devam etmek istiyor musunuz?
+STR_REMOTE_NOT_SUPPORT_MSG=Korunan sunucular için uzak paket kurulumu desteklenmiyor.
+STR_CANNOT_CONNECT_REMOTE_MSG=Uzak HTTP Sunucusuna bağlanılamıyor.
+STR_DOWNLOAD_INSTALL_MSG=Uzak Paket Kurulumu mümkün değil. Paketi indirip kurmak ister misiniz?
+STR_CHECKING_REMOTE_SERVER_MSG=Uzak Paket Kurulumu için uzak sunucu kontrol ediliyor.
+STR_FILES=Dosyalar
+STR_EDITOR=Düzenleyici
+STR_SAVE=Kaydet
+STR_MAX_EDIT_FILE_SIZE_MSG=Boyutu şu büyüklükten büyük dosyalar düzenlenemez
+STR_DELETE_LINE=Seçili Satırı Sil
+STR_INSERT_LINE=Seçili Satırın Altına Ekle
+STR_MODIFIED=Değiştirildi
+STR_FAIL_GET_TOKEN_MSG=Erişim token'ı alınamadı
+STR_GET_TOKEN_SUCCESS_MSG=Giriş Başarılı. Tarayıcıyı kapatıp uygulamaya dönebilirsiniz
+STR_NEW_FILE=Yeni Dosya
+STR_SETTINGS=Ayarlar
+STR_GLOBAL=Genel
+STR_COPY_LINE=Seçili satırı kopyala
+STR_PASTE_LINE=Seçili satıra yapıştır
+STR_SHOW_HIDDEN_FILES=Gizli dosyaları göster
+STR_SET_DEFAULT_DIRECTORY=Varsayılan Klasörü Ayarla
+STR_SET_DEFAULT_DIRECTORY_MSG=varsayılan dizin olarak ayarlandı
+STR_NFS_EXP_PATH_MISSING_MSG=URL'de NFS dışa aktarma yolu eksik
+STR_FAIL_INIT_NFS_CONTEXT=NFS bağlamı başlatılamadı
+STR_FAIL_MOUNT_NFS_MSG=NFS paylaşımı bağlanamadı
+STR_VIEW_IMAGE=Görüntüyü Görüntüle
@@ -0,0 +1,133 @@
+STR_CONNECTION_SETTINGS=Cài đặt kết nối
+STR_SITE=Vị trí
+STR_LOCAL=Thiết bị
+STR_REMOTE=Máy đích
+STR_MESSAGES=Tin nhắn
+STR_UPDATE_SOFTWARE=Cập nhật phần mềm
+STR_CONNECT=Kết nối
+STR_DISCONNECT=Ngắt kết nối
+STR_SEARCH=Tìm kiếm
+STR_REFRESH=Làm mới
+STR_SERVER=Máy chủ
+STR_USERNAME=Tên đăng nhập
+STR_PASSWORD=Mật khẩu
+STR_PORT=Cổng
+STR_PASV=Pasv
+STR_DIRECTORY=Thư mục
+STR_FILTER=Bộ lọc
+STR_YES=Đồng ý
+STR_NO=Không
+STR_CANCEL=Hủy bỏ
+STR_CONTINUE=Tiếp tục
+STR_CLOSE=Đóng
+STR_FOLDER=Thư mục
+STR_FILE=Tập tin
+STR_TYPE=Loại
+STR_NAME=Tên
+STR_SIZE=Kích thước
+STR_DATE=Ngày tháng
+STR_NEW_FOLDER=Thư mục mới
+STR_RENAME=Đổi tên
+STR_DELETE=Xóa
+STR_UPLOAD=Tải lên
+STR_DOWNLOAD=Tải xuống
+STR_SELECT_ALL=Chọn tất cả
+STR_CLEAR_ALL=Bỏ chọn tất cả
+STR_UPLOADING=Đang tải lên
+STR_DOWNLOADING=Đang tải xuống
+STR_OVERWRITE=Ghi đè
+STR_DONT_OVERWRITE=Không ghi đè
+STR_ASK_FOR_CONFIRM=Hỏi xác nhận
+STR_DONT_ASK_CONFIRM=Không hỏi xác nhận
+STR_ALLWAYS_USE_OPTION=Luôn dùng tùy chọn này và không hỏi lại
+STR_ACTIONS=Hành động
+STR_CONFIRM=Xác nhận
+STR_OVERWRITE_OPTIONS=Tùy chọn ghi đè
+STR_PROPERTIES=Thuộc tính
+STR_PROGRESS=Tiến trình
+STR_UPDATES=Cập nhật
+STR_DEL_CONFIRM_MSG=Bạn có chắc chắn muốn xóa (những) tập tin / thư mục này không?
+STR_CANCEL_ACTION_MSG=Hủy bỏ. Chờ hành động cuối cùng hoàn tất.Canceling.
+STR_FAIL_UPLOAD_MSG=Không thể tải file lên
+STR_FAIL_DOWNLOAD_MSG=Không thể tải file
+STR_FAIL_READ_LOCAL_DIR_MSG=Không đọc được nội dung của thư mục hoặc thư mục không tồn tại.
+STR_CONNECTION_CLOSE_ERR_MSG=426 Kết nối đã đóng.
+STR_REMOTE_TERM_CONN_MSG=426 Máy chủ đã ngắt kết nối.
+STR_FAIL_LOGIN_MSG=300 Đăng nhập thất bại. Vui lòng kiểm tra lại tên đăng nhập hoặc mật khẩu.
+STR_FAIL_TIMEOUT_MSG=426 Thất bại. Quá thời gian kết nối.
+STR_FAIL_DEL_DIR_MSG=Không thể xóa thư mục
+STR_DELETING=Đang xóa
+STR_FAIL_DEL_FILE_MSG=Không thể xóa tập tin
+STR_DELETED=Đã xóa
+STR_LINK=Liên kết
+STR_SHARE=Chia sẻ
+STR_FAILED=310 Lỗi
+STR_FAIL_CREATE_LOCAL_FILE_MSG=310 Không thể tạo file trên máy này
+STR_INSTALL=Cài đặt
+STR_INSTALLING=Đang cài đặt
+STR_INSTALL_SUCCESS=Thành công
+STR_INSTALL_FAILED=Thất bại
+STR_INSTALL_SKIPPED=Bỏ qua
+STR_CHECK_HTTP_MSG=Đang kiểm tra kết nối tới máy chủ HTTP
+STR_FAILED_HTTP_CHECK=Không thể kết nối tới máy chủ HTTP
+STR_REMOTE_NOT_HTTP=Máy đích không phải máy chủ HTTP
+STR_INSTALL_FROM_DATA_MSG=Package không có trong thư mục /data hoặc /mnt/usbX
+STR_ALREADY_INSTALLED_MSG=Package đã được cài đặt
+STR_INSTALL_FROM_URL=Cài từ địa chỉ URL
+STR_CANNOT_READ_PKG_HDR_MSG=Không thể đọc được thông tin header của package
+STR_FAVORITE_URLS=URLs yêu thích
+STR_SLOT=Vị trí
+STR_EDIT=Sửa
+STR_ONETIME_URL=Url một lần
+STR_NOT_A_VALID_PACKAGE=Package không đúng
+STR_WAIT_FOR_INSTALL_MSG=Đợi Package kết thúc cài đặt
+STR_FAIL_INSTALL_TMP_PKG_MSG=Không thể cài file pkg. Vui lòng xóa tmp pkg thủ công
+STR_AUTO_DELETE_TMP_PKG=Tự động xóa file pkg được tải về tạm thời sau khi cài xong
+STR_PROTOCOL_NOT_SUPPORTED=Protocol không được hỗ trợ
+STR_COULD_NOT_RESOLVE_HOST=Không thể phân giải tên máy chủ
+STR_EXTRACT=Giải nén
+STR_EXTRACTING=Đang giải nén
+STR_FAILED_TO_EXTRACT=Giải nén thất bại
+STR_EXTRACT_LOCATION=Vị trí giải nén
+STR_COMPRESS=Nén
+STR_ZIP_FILE_PATH=Tên file Zip
+STR_COMPRESSING=Đang nén
+STR_ERROR_CREATE_ZIP=Lỗi khi tạo file zip
+STR_UNSUPPORTED_FILE_FORMAT=Phần mở rộng file không được hỗ trợ
+STR_CUT=Cắt
+STR_COPY=Sao chép
+STR_PASTE=Dán
+STR_MOVING=Đang di chuyển
+STR_COPYING=Đang copy
+STR_FAIL_MOVE_MSG=Không thể di chuyển file
+STR_FAIL_COPY_MSG=Không thể sao chép file
+STR_CANT_MOVE_TO_SUBDIR_MSG=Không thể di chuyển thư mục cha vào bên trong thư mục con
+STR_CANT_COPY_TO_SUBDIR_MSG=Không thể sao chép thư mục cha vào bên trong thư mục con
+STR_UNSUPPORTED_OPERATION_MSG=Hành động không được hỗ trợ
+STR_HTTP_PORT=Cổng Http
+STR_REINSTALL_CONFIRM_MSG=Nội dung đã được cài đặt. Bạn có muốn tiếp tục cài đặt không?
+STR_REMOTE_NOT_SUPPORT_MSG=Cài đặt gói từ xa không được hỗ trợ cho các máy chủ được bảo vệ.
+STR_CANNOT_CONNECT_REMOTE_MSG=Máy chủ HTTP đích không thể truy cập được.
+STR_DOWNLOAD_INSTALL_MSG=Không thể cài đặt package từ xa. Bạn có muốn tải package xuống và cài đặt không?
+STR_CHECKING_REMOTE_SERVER_MSG=Đang kiểm tra máy chủ đích để cài đặt package từ xa.
+STR_FILES=Tập tin
+STR_EDITOR=Trình soạn thảo
+STR_SAVE=Lưu
+STR_MAX_EDIT_FILE_SIZE_MSG=Không thể chỉnh sửa các tập tin lớn hơn
+STR_DELETE_LINE=Xóa dòng đã chọn
+STR_INSERT_LINE=Chèn bên dưới dòng đã chọn
+STR_MODIFIED=Đã sửa đổi
+STR_FAIL_GET_TOKEN_MSG=Không thể lấy được access token từ
+STR_GET_TOKEN_SUCCESS_MSG=Đăng nhập thành công. Bạn có thể đóng trình duyệt và quay lại ứng dụng
+STR_NEW_FILE=Tập tin mới
+STR_SETTINGS=Cài đặt
+STR_GLOBAL=Toàn cục
+STR_COPY_LINE=Sao chép dòng đã chọn
+STR_PASTE_LINE=Dán vào dòng đã chọn
+STR_SHOW_HIDDEN_FILES=Hiển thị các tập tin ẩn
+STR_SET_DEFAULT_DIRECTORY=Đặt thư mục mặc định
+STR_SET_DEFAULT_DIRECTORY_MSG=đã được thiết lập làm thư mục mặc định
+STR_NFS_EXP_PATH_MISSING_MSG=Đường dẫn NFS bị thiếu trong URL
+STR_FAIL_INIT_NFS_CONTEXT=Không khởi tạo được ngữ cảnh NFS
+STR_FAIL_MOUNT_NFS_MSG=Không thể mount NFS share
+STR_PROMOTING=Promoting
@@ -1,6 +1,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <pthread.h>
+#include <json-c/json.h>
 #include <lexbor/html/parser.h>
 #include <lexbor/dom/interfaces/element.h>
 #include <minizip/unzip.h>
@@ -10,6 +11,8 @@
 #include "clients/smbclient.h"
 #include "clients/webdav.h"
 #include "clients/apache.h"
+#include "clients/archiveorg.h"
+#include "clients/myrient.h"
 #include "clients/nginx.h"
 #include "clients/npxserve.h"
 #include "clients/nfsclient.h"
@@ -17,6 +20,7 @@
 #include "clients/rclone.h"
 #include "clients/sftpclient.h"
 #include "filehost/filehost.h"
+#include "server/http_server.h"
 #include "common.h"
 #include "fs.h"
 #include "config.h"
@@ -364,6 +368,7 @@ namespace Actions

        if (confirm_state == CONFIRM_YES)
        {
+            sceRtcGetCurrentTick(&prev_tick);
            return remoteclient->Put(src, dest);
        }

@@ -487,6 +492,7 @@ namespace Actions
    int DownloadFile(const char *src, const char *dest)
    {
        bytes_transfered = 0;
+        sceRtcGetCurrentTick(&prev_tick);
        if (!remoteclient->Size(src, &bytes_to_download))
        {
            remoteclient->Quit();
@@ -518,6 +524,7 @@ namespace Actions

        if (confirm_state == CONFIRM_YES)
        {
+            sceRtcGetCurrentTick(&prev_tick);
            return remoteclient->Get(dest, src);
        }

@@ -709,13 +716,39 @@ namespace Actions
                            }
                            else
                            {
-                                std::string url = INSTALLER::getRemoteUrl(it->path, true);
-                                std::string title = INSTALLER::GetRemotePkgTitle(remoteclient, it->path, &header);
+                                if (remote_settings->enable_disk_cache)
+                                {
+                                    SplitPkgInstallData *install_data = (SplitPkgInstallData*) malloc(sizeof(SplitPkgInstallData));
+                                    memset(install_data, 0, sizeof(SplitPkgInstallData));

-                                if (INSTALLER::InstallRemotePkg(url, &header, title, true) == 0)
-                                    failed++;
+                                    OrbisTick tick;
+                                    sceRtcGetCurrentTick(&tick);
+                                    std::string install_pkg_path = std::string(temp_folder) + "/" + std::to_string(tick.mytick) + ".pkg";
+                                    SplitFile *sp = new SplitFile(install_pkg_path, INSTALL_ARCHIVE_PKG_SPLIT_SIZE/2);
+
+                                    install_data->split_file = sp;
+                                    install_data->remote_client = remoteclient;
+                                    install_data->path = it->path;
+                                    remoteclient->Size(it->path, &install_data->size);
+                                    install_data->stop_write_thread = false;
+                                    install_data->delete_client = false;
+
+                                    int ret = pthread_create(&install_data->thread, NULL, DownloadSplitPkg, install_data);
+
+                                    if (INSTALLER::InstallSplitPkg(it->path, install_data, false) == 0)
+                                        failed++;
+                                    else
+                                        success++;
+                                }
                                else
-                                    success++;
+                                {
+                                    std::string url = INSTALLER::getRemoteUrl(it->path, true);
+                                    std::string title = INSTALLER::GetRemotePkgTitle(remoteclient, it->path, &header);
+                                    if (INSTALLER::InstallRemotePkg(url, &header, title, true) == 0)
+                                        failed++;
+                                    else
+                                        success++;
+                                }
                            }
                        }
                        else
@@ -818,6 +851,18 @@ namespace Actions
        return NULL;
    }

+    void *DownloadSplitPkg(void *argp)
+    {
+        SplitPkgInstallData *install_data = (SplitPkgInstallData*) argp;
+        SplitFile *sp = install_data->split_file;
+
+        /* loop over file contents and write to fd */
+        sp->Open();
+        install_data->remote_client->Get(sp, install_data->path);
+        sp->Close();
+        return NULL;
+    }
+
    void *InstallLocalPkgsThread(void *argp)
    {
        int failed = 0;
@@ -1065,7 +1110,7 @@ namespace Actions
        }
    }

-    void *InstallUrlPkgThread(void *argp)
+    void *InstallLocalUrlPkgThread(void *argp)
    {
        bytes_transfered = 0;
        sceRtcGetCurrentTick(&prev_tick);
@@ -1076,10 +1121,10 @@ namespace Actions
        OrbisTick tick;
        sceRtcGetCurrentClockLocalTime(&now);
        sceRtcGetTick(&now, &tick);
-        sprintf(filename, "%s/%lu.pkg", DATA_PATH, tick.mytick);
+        sprintf(filename, "%s/%lu.pkg", TMP_FOLDER_PATH, tick.mytick);

        std::string full_url = std::string(install_pkg_url.url);
-        FileHost *filehost = FileHost::getFileHost(full_url);
+        FileHost *filehost = FileHost::getFileHost(full_url, install_pkg_url.enable_alldebrid, install_pkg_url.enable_realdebrid);
        if (!filehost->IsValidUrl())
        {
            sprintf(status_message, "%s", lang_strings[STR_FAIL_TO_OBTAIN_GG_DL_MSG]);
@@ -1102,7 +1147,7 @@ namespace Actions
        std::string host = full_url.substr(0, path_pos);
        std::string path = full_url.substr(path_pos);

-        WebDAVClient tmp_client;
+        BaseClient tmp_client;
        tmp_client.Connect(host.c_str(), install_pkg_url.username, install_pkg_url.password);

        sprintf(activity_message, "%s URL to %s", lang_strings[STR_DOWNLOADING], filename);
@@ -1110,7 +1155,7 @@ namespace Actions
        memset(&header, 0, s);

        int ret = tmp_client.Size(path, &bytes_to_download);
-        if (!ret)
+        if (ret == 0)
        {
            sprintf(status_message, "%s - %s", lang_strings[STR_FAILED], lang_strings[STR_CANNOT_READ_PKG_HDR_MSG]);
            tmp_client.Quit();
@@ -1120,7 +1165,7 @@ namespace Actions
        }

        file_transfering = 1;
-        int is_performed = tmp_client.Get(path, filename);
+        int is_performed = tmp_client.Get(filename, path);

        if (is_performed == 0)
        {
@@ -1173,10 +1218,70 @@ namespace Actions
        return NULL;
    }

+    void *InstallRpiUrlPkgThread(void *argp)
+    {
+        json_object *params = json_object_new_object();
+        json_object_object_add(params, "url", json_object_new_string(install_pkg_url.url));
+        json_object_object_add(params, "use_alldebrid", json_object_new_boolean(install_pkg_url.enable_alldebrid));
+        json_object_object_add(params, "use_realdebrid", json_object_new_boolean(install_pkg_url.enable_realdebrid));
+        json_object_object_add(params, "use_disk_cache", json_object_new_boolean(install_pkg_url.enable_disk_cache));
+
+        const char *params_str = json_object_to_json_string(params);
+
+        char host[128];
+        sprintf(host, "http://127.0.0.1:%d", http_server_port);
+
+        httplib::Client tmp_client(host);
+        tmp_client.set_keep_alive(true);
+        tmp_client.set_follow_location(true);
+        tmp_client.set_connection_timeout(30);
+        tmp_client.set_read_timeout(30);
+        tmp_client.enable_server_certificate_verification(false);
+
+        auto res = tmp_client.Post("/__local__/install_url", params_str, strlen(params_str), "application/json");
+        if (res != nullptr && HTTP_SUCCESS(res->status))
+        {
+            json_object *jobj = json_tokener_parse(res->body.c_str());
+            if (jobj != nullptr)
+            {
+                json_object *result = json_object_object_get(jobj, "result");
+                if (result != nullptr)
+                {
+                    bool success = json_object_get_boolean(json_object_object_get(result, "success"));
+                    if (!success)
+                    {
+                        const char* error_message = json_object_get_string(json_object_object_get(result, "error"));
+                        sprintf(status_message, "%s", error_message);
+                        activity_inprogess = false;
+                        Windows::SetModalMode(false);
+                    }
+                }
+            }
+            else
+            {
+                activity_inprogess = false;
+                Windows::SetModalMode(false);
+            }
+        }
+        else
+        {
+            activity_inprogess = false;
+            Windows::SetModalMode(false);
+        }
+
+        return NULL;
+    }
+
    void InstallUrlPkg()
    {
+        int res;
        sprintf(status_message, "%s", "");
-        int res = pthread_create(&bk_activity_thid, NULL, InstallUrlPkgThread, NULL);
+
+        if (!install_pkg_url.enable_rpi)
+            res = pthread_create(&bk_activity_thid, NULL, InstallLocalUrlPkgThread, NULL);
+        else
+            res = pthread_create(&bk_activity_thid, NULL, InstallRpiUrlPkgThread, NULL);
+
        if (res != 0)
        {
            activity_inprogess = false;
@@ -1205,6 +1310,10 @@ namespace Actions
                remoteclient = new NpxServeClient();
            else if (strcmp(remote_settings->http_server_type, HTTP_SERVER_RCLONE) == 0)
                remoteclient = new RCloneClient();
+            else if (strcmp(remote_settings->http_server_type, HTTP_SERVER_ARCHIVEORG) == 0)
+                remoteclient = new ArchiveOrgClient();
+            else if (strcmp(remote_settings->http_server_type, HTTP_SERVER_MYRIENT) == 0)
+                remoteclient = new MyrientClient();
        }
        else if (strncmp(remote_settings->server, "webdavs://", 10) == 0 || strncmp(remote_settings->server, "webdav://", 9) == 0)
        {
@@ -1339,6 +1448,7 @@ namespace Actions

        if (confirm_state == CONFIRM_YES)
        {
+            sceRtcGetCurrentTick(&prev_tick);
            if (isCopy)
                return FS::Copy(src, dest);
            else
@@ -1541,6 +1651,7 @@ namespace Actions

        if (confirm_state == CONFIRM_YES)
        {
+            sceRtcGetCurrentTick(&prev_tick);
            if (isCopy)
                return remoteclient->Copy(src, dest);
            else
@@ -99,7 +99,8 @@ namespace Actions
    void InstallRemotePkgs();
    void *InstallLocalPkgsThread(void *argp);
    void InstallLocalPkgs();
-    void *InstallUrlPkgThread(void *argp);
+    void *InstallLocalUrlPkgThread(void *argp);
+    void *InstallRpiUrlPkgThread(void *argp);
    void InstallUrlPkg();
    void *KeepAliveThread(void *argp);
    void *ExtractZipThread(void *argp);
@@ -120,6 +121,7 @@ namespace Actions
    void CreateLocalFile(char *filename);
    void CreateRemoteFile(char *filename);
    void *ExtractArchivePkg(void *argp);
+    void *DownloadSplitPkg(void *argp);
 }

 #endif
@@ -0,0 +1,239 @@
+#include <lexbor/html/parser.h>
+#include <lexbor/dom/interfaces/element.h>
+#include <lexbor/dom/interfaces/node.h>
+#include <fstream>
+#include <map>
+#include "common.h"
+#include "clients/remote_client.h"
+#include "clients/archiveorg.h"
+#include "lang.h"
+#include "util.h"
+#include "system.h"
+#include "windows.h"
+
+using httplib::Client;
+using httplib::Headers;
+using httplib::Result;
+
+static std::map<std::string, int> month_map = {{"Jan", 1}, {"Feb", 2}, {"Mar", 3}, {"Apr", 4}, {"May", 5}, {"Jun", 6}, {"Jul", 7}, {"Aug", 8}, {"Sep", 9}, {"Oct", 10}, {"Nov", 11}, {"Dec", 12}};
+
+std::vector<DirEntry> ArchiveOrgClient::ListDir(const std::string &path)
+{
+    std::vector<DirEntry> out;
+    DirEntry entry;
+    Util::SetupPreviousFolder(path, &entry);
+    out.push_back(entry);
+
+    std::string encoded_path = httplib::detail::encode_url(GetFullPath(path) + "/");
+    if (auto res = client->Get(encoded_path))
+    {
+        lxb_status_t status;
+        lxb_dom_attr_t *attr;
+        lxb_dom_element_t *table_element, *tr_element, *td_element;
+        lxb_html_document_t *document;
+        lxb_dom_collection_t *table_collection;
+        lxb_dom_collection_t *tr_collection;
+        lxb_dom_collection_t *td_collection;
+        std::string tmp_string;
+        const lxb_char_t *value;
+        size_t value_len;
+
+        document = lxb_html_document_create();
+        status = lxb_html_document_parse(document, (lxb_char_t *)res->body.c_str(), res->body.length());
+        if (status != LXB_STATUS_OK)
+        {
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        table_collection = lxb_dom_collection_make(&document->dom_document, 1);
+        if (table_collection == NULL)
+        {
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        tr_collection = lxb_dom_collection_make(&document->dom_document, 128);
+        if (tr_collection == NULL)
+        {
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        status = lxb_dom_elements_by_tag_name(lxb_dom_interface_element(document->body),
+                                              table_collection, (const lxb_char_t *)"table", 5);
+        if (status != LXB_STATUS_OK)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        if (lxb_dom_collection_length(table_collection) < 1)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        for (size_t i = 0; i < lxb_dom_collection_length(table_collection); i++)
+        {
+            table_element = lxb_dom_collection_element(table_collection, i);
+            value = lxb_dom_element_class(table_element, &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            if (tmp_string.compare("directory-listing-table") == 0)
+                break;
+            table_element = nullptr;
+        }
+
+        if (table_element == nullptr)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        status = lxb_dom_elements_by_tag_name(table_element,
+                                              tr_collection, (const lxb_char_t *)"tr", 2);
+        if (status != LXB_STATUS_OK && lxb_dom_collection_length(tr_collection) < 2)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        // skip row 0 , since it has the previous folder header
+        for (size_t i = 2; i < lxb_dom_collection_length(tr_collection); i++)
+        {
+            DirEntry entry;
+            std::string title, aclass;
+            memset(&entry.modified, 0, sizeof(DateTime));
+
+            tr_element = lxb_dom_collection_element(tr_collection, i);
+
+            td_collection = lxb_dom_collection_make(&document->dom_document, 5);
+            status = lxb_dom_elements_by_tag_name(tr_element,
+                                                  td_collection, (const lxb_char_t *)"td", 2);
+            if (status != LXB_STATUS_OK || lxb_dom_collection_length(td_collection) < 3)
+            {
+                lxb_dom_collection_destroy(td_collection, true);
+                lxb_dom_collection_destroy(tr_collection, true);
+                lxb_dom_collection_destroy(table_collection, true);
+                lxb_html_document_destroy(document);
+                goto finish;
+            }
+
+            // td0 contains the <a> tag
+            td_element = lxb_dom_collection_element(td_collection, 0);
+            lxb_dom_node_t *a_node = NextChildElement(td_element);
+            value = lxb_dom_element_local_name(lxb_dom_interface_element(a_node), &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            if (tmp_string.compare("a") != 0)
+            {
+                lxb_dom_collection_destroy(td_collection, true);
+                lxb_dom_collection_destroy(tr_collection, true);
+                lxb_dom_collection_destroy(table_collection, true);
+                lxb_html_document_destroy(document);
+                goto finish;
+            }
+            value = lxb_dom_element_get_attribute(lxb_dom_interface_element(a_node), (const lxb_char_t *)"href", 4, &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            if (tmp_string[tmp_string.length()-1] == '/')
+                tmp_string = tmp_string.substr(0, tmp_string.length()-1);
+            tmp_string = BaseClient::UnEscape(tmp_string);
+            sprintf(entry.name, "%s", tmp_string.c_str());
+            sprintf(entry.directory, "%s", path.c_str());
+            if (path.length() > 0 && path[path.length() - 1] == '/')
+            {
+                sprintf(entry.path, "%s%s", path.c_str(), entry.name);
+            }
+            else
+            {
+                sprintf(entry.path, "%s/%s", path.c_str(), entry.name);
+            }
+
+            // next td contains the date
+            td_element = lxb_dom_collection_element(td_collection, 1);
+            value = lxb_dom_node_text_content(NextChildTextNode(td_element), &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            std::vector<std::string> date_time = Util::Split(tmp_string, " ");
+
+            if (date_time.size() > 1)
+            {
+                std::vector<std::string> adate = Util::Split(date_time[0], "-");
+                if (adate.size() == 3)
+                {
+                    entry.modified.day = atoi(adate[0].c_str());
+                    entry.modified.month = month_map[adate[1]];
+                    entry.modified.year = atoi(adate[2].c_str());
+                }
+
+                std::vector<std::string> atime = Util::Split(date_time[1], ":");
+                if (atime.size() == 2)
+                {
+                    entry.modified.hours = atoi(atime[0].c_str());
+                    entry.modified.minutes = atoi(atime[1].c_str());
+                }
+            }
+
+            // next td contains file size, if fize size is "-", then it's a directory
+            td_element = lxb_dom_collection_element(td_collection, 2);
+            value = lxb_dom_node_text_content(NextChildTextNode(td_element), &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+
+            if (tmp_string.compare("-") == 0)
+            {
+                entry.isDir = true;
+                entry.selectable = true;
+                entry.file_size = 0;
+                sprintf(entry.display_size, "%s", lang_strings[STR_FOLDER]);
+            }
+            else
+            {
+                entry.isDir = false;
+                entry.selectable = true;
+                uint64_t multiplier = 0;
+                std::string size_formatted = tmp_string.substr(0, tmp_string.size()-1);
+                Util::ReplaceAll(size_formatted, ",", "");
+                float fsize = std::stof(size_formatted);
+                switch (tmp_string[tmp_string.size()-1]) {
+                    case 'B':
+                        multiplier = 1;
+                        break;
+                    case 'K':
+                        multiplier = 1024;
+                        break;
+                    case 'M':
+                        multiplier = 1048576;
+                        break;
+                    case 'G':
+                        multiplier = 1073741824;
+                        break;
+                    default:
+                        multiplier = 1;
+                }
+                entry.file_size = fsize * multiplier;
+                DirEntry::SetDisplaySize(&entry);
+            }
+
+            lxb_dom_collection_destroy(td_collection, true);
+            out.push_back(entry);
+        }
+
+        lxb_dom_collection_destroy(tr_collection, true);
+        lxb_dom_collection_destroy(table_collection, true);
+        lxb_html_document_destroy(document);
+    }
+    else
+    {
+        sprintf(this->response, "%s", httplib::to_string(res.error()).c_str());
+        return out;
+    }
+
+finish:
+    return out;
+}
@@ -0,0 +1,17 @@
+#ifndef EZ_ARCHIVEORG_H
+#define EZ_ARCHIVEORG_H
+
+#include <string>
+#include <vector>
+#include "http/httplib.h"
+#include "clients/remote_client.h"
+#include "clients/baseclient.h"
+#include "common.h"
+
+class ArchiveOrgClient : public BaseClient
+{
+public:
+    std::vector<DirEntry> ListDir(const std::string &path);
+};
+
+#endif
@@ -90,6 +90,27 @@ int BaseClient::Size(const std::string &path, int64_t *size)
                *size = atoll(content_length.c_str());
            return 1;
        }
+        else // Server doesn't support HEAD request. Try get range with 0 bytes and grab size from the response header 
+             // example: Content-Range: bytes 0-10/4372785
+        {
+            Headers headers = {{"Range", "bytes=0-1"}};
+            if (auto range_res = client->Get(GetFullPath(path), headers))
+            {
+                if (HTTP_SUCCESS(range_res->status))
+                {
+                    if (range_res->has_header("Content-Range"))
+                    {
+                        std::string range = range_res->get_header_value("Content-Range");
+                        std::vector<std::string> range_parts = Util::Split(range, "/");
+                        if (range_parts.size() == 2)
+                        {
+                            *size = atoll(range_parts[1].c_str());
+                            return 1;
+                        }
+                    }
+                }
+            }
+        }
    }
    else
    {
@@ -122,6 +143,29 @@ int BaseClient::Get(const std::string &outputfile, const std::string &path, uint
    return 0;
 }

+int BaseClient::Get(SplitFile *split_file, const std::string &path, uint64_t offset)
+{
+    if (auto res = client->Get(GetFullPath(path),
+                               [&](const char *data, size_t data_length)
+                               {
+                                   if (!split_file->IsClosed())
+                                   {
+                                        split_file->Write((char*)data, data_length);
+                                        return true;
+                                   }
+                                   else
+                                        return false;
+                               }))
+    {
+        return 1;
+    }
+    else
+    {
+        sprintf(this->response, "%s", httplib::to_string(res.error()).c_str());
+    }
+    return 0;
+}
+
 int BaseClient::GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset)
 {
    char range_header[64];
@@ -8,6 +8,7 @@
 #include "http/httplib.h"
 #include "clients/remote_client.h"
 #include "http/httplib.h"
+#include "split_file.h"
 #include "common.h"

 class BaseClient : public RemoteClient
@@ -21,6 +22,7 @@ public:
    int Rmdir(const std::string &path, bool recursive);
    int Size(const std::string &path, int64_t *size);
    int Get(const std::string &outputfile, const std::string &path, uint64_t offset=0);
+    int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0);
    int GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset);
    int GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset);
    int GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset);
@@ -880,6 +880,32 @@ int FtpClient::FtpXfer(const std::string &localfile, const std::string &path, ft
 	return FtpClose(nData);
 }

+/*
+ * FtpXfer - issue a command and transfer data
+ *
+ * return 1 if successful, 0 otherwise
+ */
+int FtpClient::FtpXfer(SplitFile *split_file, const std::string &path, ftphandle *nControl, accesstype type, transfermode mode)
+{
+	int l, c;
+	char *dbuf;
+	ftphandle *nData;
+
+	if (!FtpAccess(path, type, mode, nControl, &nData))
+	{
+		return 0;
+	}
+
+	dbuf = static_cast<char *>(malloc(FTP_CLIENT_BUFSIZ));
+	while ((l = FtpRead(dbuf, FTP_CLIENT_BUFSIZ, nData)) > 0)
+	{
+		split_file->Write(dbuf, l);
+	}
+
+	free(dbuf);
+	return FtpClose(nData);
+}
+
 /*
 * FtpWrite - write to a data connection
 */
@@ -1283,6 +1309,15 @@ int FtpClient::Get(const std::string &outputfile, const std::string &path, uint6
 		return FtpXfer(outputfile, path, mp_ftphandle, FtpClient::filereadappend, FtpClient::transfermode::image);
 }

+int FtpClient::Get(SplitFile *split_file, const std::string &path, uint64_t offset)
+{
+	mp_ftphandle->offset = offset;
+	if (offset == 0)
+		return FtpXfer(split_file, path, mp_ftphandle, FtpClient::fileread, FtpClient::transfermode::image);
+	else
+		return FtpXfer(split_file, path, mp_ftphandle, FtpClient::filereadappend, FtpClient::transfermode::image);
+}
+
 int FtpClient::GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset)
 {
 	ftphandle *nData;
@@ -1787,7 +1822,7 @@ int FtpClient::Head(const std::string &path, void *buffer, uint64_t len)

 void *FtpClient::Open(const std::string &path, int flags)
 {
-    return nullptr;
+	return nullptr;
 }

 void FtpClient::Close(void *fp)
@@ -1796,10 +1831,10 @@ void FtpClient::Close(void *fp)

 int FtpClient::GetRange(void *fp, DataSink &sink, uint64_t size, uint64_t offset)
 {
-    return -1;
+	return -1;
 }

 int FtpClient::GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset)
 {
-    return -1;
+	return -1;
 }
@@ -79,6 +79,7 @@ public:
 	int Rmdir(const std::string &path, bool recursive);
 	int Size(const std::string &path, int64_t *size);
 	int Get(const std::string &outputfile, const std::string &path, uint64_t offset = 0);
+	int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0);
 	int GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset);
 	int GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset);
 	int GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset);
@@ -128,6 +129,7 @@ private:
 	int CorrectPasvResponse(int *v);
 	int FtpAccess(const std::string &path, accesstype type, transfermode mode, ftphandle *nControl, ftphandle **nData);
 	int FtpXfer(const std::string &localfile, const std::string &path, ftphandle *nControl, accesstype type, transfermode mode);
+	int FtpXfer(SplitFile *split_file, const std::string &path, ftphandle *nControl, accesstype type, transfermode mode);
 	int FtpWrite(void *buf, int len, ftphandle *nData);
 	int FtpRead(void *buf, int max, ftphandle *nData);
 	int FtpClose(ftphandle *nData);
@@ -332,6 +332,34 @@ int GDriveClient::Get(const std::string &outputfile, const std::string &path, ui
    return 0;
 }

+int GDriveClient::Get(SplitFile *split_file, const std::string &path, uint64_t offset)
+{
+    std::string id = GetValue(path_id_map, path);
+    std::string drive_id = GetDriveId(path);
+    std::string url = std::string("/drive/v3/files/") + BaseClient::Escape(id) + "?alt=media";
+    if (!drive_id.empty())
+        url += "&supportsAllDrives=true";
+    if (auto res = client->Get(url,
+                               [&](const char *data, size_t data_length)
+                               {
+                                   if (!split_file->IsClosed())
+                                   {
+                                        split_file->Write((char*)data, data_length);
+                                        return true;
+                                   }
+                                   else
+                                        return false;
+                               }))
+    {
+        return 1;
+    }
+    else
+    {
+        sprintf(this->response, "%s", httplib::to_string(res.error()).c_str());
+    }
+    return 0;
+}
+
 int GDriveClient::GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset)
 {
    size_t bytes_read = 0;
@@ -20,6 +20,7 @@ public:
    int Connect(const std::string &url, const std::string &user, const std::string &pass);
    int Rename(const std::string &src, const std::string &dst);
    int Get(const std::string &outputfile, const std::string &path, uint64_t offset=0);
+    int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0);
    int GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset);
    int GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset);
    int GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset);
@@ -0,0 +1,241 @@
+#include <lexbor/html/parser.h>
+#include <lexbor/dom/interfaces/element.h>
+#include <lexbor/dom/interfaces/node.h>
+#include <fstream>
+#include <map>
+#include "common.h"
+#include "clients/remote_client.h"
+#include "clients/myrient.h"
+#include "lang.h"
+#include "util.h"
+#include "system.h"
+#include "windows.h"
+
+using httplib::Client;
+using httplib::Headers;
+using httplib::Result;
+
+static std::map<std::string, int> month_map = {{"Jan", 1}, {"Feb", 2}, {"Mar", 3}, {"Apr", 4}, {"May", 5}, {"Jun", 6}, {"Jul", 7}, {"Aug", 8}, {"Sep", 9}, {"Oct", 10}, {"Nov", 11}, {"Dec", 12}};
+
+std::vector<DirEntry> MyrientClient::ListDir(const std::string &path)
+{
+    std::vector<DirEntry> out;
+    DirEntry entry;
+    Util::SetupPreviousFolder(path, &entry);
+    out.push_back(entry);
+
+    std::string encoded_path = httplib::detail::encode_url(GetFullPath(path) + "/");
+    if (auto res = client->Get(encoded_path))
+    {
+        lxb_status_t status;
+        lxb_dom_attr_t *attr;
+        lxb_dom_element_t *table_element, *tr_element, *td_element;
+        lxb_html_document_t *document;
+        lxb_dom_collection_t *table_collection;
+        lxb_dom_collection_t *tr_collection;
+        lxb_dom_collection_t *td_collection;
+        std::string tmp_string;
+        const lxb_char_t *value;
+        size_t value_len;
+
+        document = lxb_html_document_create();
+        status = lxb_html_document_parse(document, (lxb_char_t *)res->body.c_str(), res->body.length());
+        if (status != LXB_STATUS_OK)
+        {
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        table_collection = lxb_dom_collection_make(&document->dom_document, 1);
+        if (table_collection == NULL)
+        {
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        tr_collection = lxb_dom_collection_make(&document->dom_document, 128);
+        if (tr_collection == NULL)
+        {
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        status = lxb_dom_elements_by_tag_name(lxb_dom_interface_element(document->body),
+                                              table_collection, (const lxb_char_t *)"table", 5);
+        if (status != LXB_STATUS_OK)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        if (lxb_dom_collection_length(table_collection) < 1)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        for (size_t i = 0; i < lxb_dom_collection_length(table_collection); i++)
+        {
+            table_element = lxb_dom_collection_element(table_collection, i);
+            value = lxb_dom_element_id(table_element, &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            if (tmp_string.compare("list") == 0)
+                break;
+            table_element = nullptr;
+        }
+
+        if (table_element == nullptr)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        status = lxb_dom_elements_by_tag_name(table_element,
+                                              tr_collection, (const lxb_char_t *)"tr", 2);
+        if (status != LXB_STATUS_OK && lxb_dom_collection_length(tr_collection) < 2)
+        {
+            lxb_dom_collection_destroy(tr_collection, true);
+            lxb_dom_collection_destroy(table_collection, true);
+            lxb_html_document_destroy(document);
+            goto finish;
+        }
+
+        // skip row 0 , since it has the previous folder header
+        for (size_t i = 2; i < lxb_dom_collection_length(tr_collection); i++)
+        {
+            DirEntry entry;
+            std::string title, aclass;
+            memset(&entry.modified, 0, sizeof(DateTime));
+
+            tr_element = lxb_dom_collection_element(tr_collection, i);
+
+            td_collection = lxb_dom_collection_make(&document->dom_document, 5);
+            status = lxb_dom_elements_by_tag_name(tr_element,
+                                                  td_collection, (const lxb_char_t *)"td", 2);
+            if (status != LXB_STATUS_OK || lxb_dom_collection_length(td_collection) < 3)
+            {
+                lxb_dom_collection_destroy(td_collection, true);
+                lxb_dom_collection_destroy(tr_collection, true);
+                lxb_dom_collection_destroy(table_collection, true);
+                lxb_html_document_destroy(document);
+                goto finish;
+            }
+
+            // td0 contains the <a> tag
+            td_element = lxb_dom_collection_element(td_collection, 0);
+            lxb_dom_node_t *a_node = NextChildElement(td_element);
+            value = lxb_dom_element_local_name(lxb_dom_interface_element(a_node), &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            if (tmp_string.compare("a") != 0)
+            {
+                lxb_dom_collection_destroy(td_collection, true);
+                lxb_dom_collection_destroy(tr_collection, true);
+                lxb_dom_collection_destroy(table_collection, true);
+                lxb_html_document_destroy(document);
+                goto finish;
+            }
+            value = lxb_dom_element_get_attribute(lxb_dom_interface_element(a_node), (const lxb_char_t *)"href", 4, &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            if (tmp_string[tmp_string.length()-1] == '/')
+                tmp_string = tmp_string.substr(0, tmp_string.length()-1);
+            tmp_string = BaseClient::UnEscape(tmp_string);
+            sprintf(entry.name, "%s", tmp_string.c_str());
+            sprintf(entry.directory, "%s", path.c_str());
+            if (path.length() > 0 && path[path.length() - 1] == '/')
+            {
+                sprintf(entry.path, "%s%s", path.c_str(), entry.name);
+            }
+            else
+            {
+                sprintf(entry.path, "%s/%s", path.c_str(), entry.name);
+            }
+
+            // next td contains file size, if fize size is "-", then it's a directory
+            td_element = lxb_dom_collection_element(td_collection, 1);
+            value = lxb_dom_node_text_content(NextChildTextNode(td_element), &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+
+            if (tmp_string.compare("-") == 0)
+            {
+                entry.isDir = true;
+                entry.selectable = true;
+                entry.file_size = 0;
+                sprintf(entry.display_size, "%s", lang_strings[STR_FOLDER]);
+            }
+            else
+            {
+                entry.isDir = false;
+                entry.selectable = true;
+                uint64_t multiplier = 1;
+                std::vector<std::string> fsize_parts = Util::Split(tmp_string, " ");
+
+                float fsize = std::stof(fsize_parts[0]);
+
+                if (fsize_parts.size() > 1)
+                {
+                    switch (fsize_parts[1][0])
+                    {
+                        case 'K':
+                            multiplier = 1024;
+                            break;
+                        case 'M':
+                            multiplier = 1048576;
+                            break;
+                        case 'G':
+                            multiplier = 1073741824;
+                            break;
+                        default:
+                            multiplier = 1;
+                    }
+                }
+                entry.file_size = fsize * multiplier;
+                DirEntry::SetDisplaySize(&entry);
+            }
+
+            // next td contains the date
+            td_element = lxb_dom_collection_element(td_collection, 2);
+            value = lxb_dom_node_text_content(NextChildTextNode(td_element), &value_len);
+            tmp_string = std::string((const char *)value, value_len);
+            std::vector<std::string> date_time = Util::Split(tmp_string, " ");
+
+            if (date_time.size() > 1)
+            {
+                std::vector<std::string> adate = Util::Split(date_time[0], "-");
+                if (adate.size() == 3)
+                {
+                    entry.modified.day = atoi(adate[0].c_str());
+                    entry.modified.month = month_map[adate[1]];
+                    entry.modified.year = atoi(adate[2].c_str());
+                }
+
+                std::vector<std::string> atime = Util::Split(date_time[1], ":");
+                if (atime.size() == 2)
+                {
+                    entry.modified.hours = atoi(atime[0].c_str());
+                    entry.modified.minutes = atoi(atime[1].c_str());
+                }
+            }
+
+            lxb_dom_collection_destroy(td_collection, true);
+            out.push_back(entry);
+        }
+
+        lxb_dom_collection_destroy(tr_collection, true);
+        lxb_dom_collection_destroy(table_collection, true);
+        lxb_html_document_destroy(document);
+    }
+    else
+    {
+        sprintf(this->response, "%s", httplib::to_string(res.error()).c_str());
+        return out;
+    }
+
+finish:
+    return out;
+}
@@ -0,0 +1,17 @@
+#ifndef EZ_MYRIENT_H
+#define EZ_MYRIENT_H
+
+#include <string>
+#include <vector>
+#include "http/httplib.h"
+#include "clients/remote_client.h"
+#include "clients/baseclient.h"
+#include "common.h"
+
+class MyrientClient : public BaseClient
+{
+public:
+    std::vector<DirEntry> ListDir(const std::string &path);
+};
+
+#endif
@@ -17,7 +17,7 @@
 #include "util.h"
 #include "system.h"

-#define BUF_SIZE 256*1024
+#define BUF_SIZE 256 * 1024

 NfsClient::NfsClient()
 {
@@ -37,7 +37,8 @@ int NfsClient::Connect(const std::string &url, const std::string &user, const st
 	}

 	struct nfs_url *nfsurl = nfs_parse_url_full(nfs, url.c_str());
-	if (nfsurl == nullptr) {
+	if (nfsurl == nullptr)
+	{
 		sprintf(response, "%s", nfs_get_error(nfs));
 		nfs_destroy_context(nfs);
 		return 0;
@@ -203,7 +204,7 @@ int NfsClient::Get(const std::string &outputfile, const std::string &ppath, uint
 		return 0;
 	}

-	FILE* out = FS::Create(outputfile);
+	FILE *out = FS::Create(outputfile);
 	if (out == NULL)
 	{
 		sprintf(response, "%s", lang_strings[STR_FAILED]);
@@ -221,7 +222,7 @@ int NfsClient::Get(const std::string &outputfile, const std::string &ppath, uint
 			sprintf(response, "%s", nfs_get_error(nfs));
 			FS::Close(out);
 			nfs_close(nfs, nfsfh);
-			free((void*)buff);
+			free((void *)buff);
 			return 0;
 		}
 		FS::Write(out, buff, count);
@@ -229,7 +230,36 @@ int NfsClient::Get(const std::string &outputfile, const std::string &ppath, uint
 	}
 	FS::Close(out);
 	nfs_close(nfs, nfsfh);
-	free((void*)buff);
+	free((void *)buff);
+
+	return 1;
+}
+
+int NfsClient::Get(SplitFile *split_file, const std::string &ppath, uint64_t offset)
+{
+	struct nfsfh *nfsfh = nullptr;
+	int ret = nfs_open(nfs, ppath.c_str(), 0400, &nfsfh);
+	if (ret != 0)
+	{
+		sprintf(response, "%s", nfs_get_error(nfs));
+		return 0;
+	}
+
+	void *buff = malloc(BUF_SIZE);
+	int count = 0;
+	while ((count = nfs_read(nfs, nfsfh, BUF_SIZE, buff)) > 0)
+	{
+		if (count < 0)
+		{
+			sprintf(response, "%s", nfs_get_error(nfs));
+			nfs_close(nfs, nfsfh);
+			free((void *)buff);
+			return 0;
+		}
+		split_file->Write((char *)buff, count);
+	}
+	nfs_close(nfs, nfsfh);
+	free((void *)buff);

 	return 1;
 }
@@ -260,29 +290,29 @@ int NfsClient::GetRange(void *fp, DataSink &sink, uint64_t size, uint64_t offset
 	}

 	void *buff = malloc(BUF_SIZE);
-    int count = 0;
-    size_t bytes_remaining = size;
-    do
-    {
-        size_t bytes_to_read = std::min<size_t>(BUF_SIZE, bytes_remaining);
-        count = nfs_read(nfs, nfsfh, bytes_to_read, buff);
-        if (count > 0)
-        {
-            bytes_remaining -= count;
-            bool ok = sink.write((char*)buff, count);
+	int count = 0;
+	size_t bytes_remaining = size;
+	do
+	{
+		size_t bytes_to_read = std::min<size_t>(BUF_SIZE, bytes_remaining);
+		count = nfs_read(nfs, nfsfh, bytes_to_read, buff);
+		if (count > 0)
+		{
+			bytes_remaining -= count;
+			bool ok = sink.write((char *)buff, count);
 			if (!ok)
 			{
 				free((void *)buff);
 				return 0;
 			}
-        }
-        else
-        {
-            break;
-        }
-    } while (1);
+		}
+		else
+		{
+			break;
+		}
+	} while (1);

-    free((void *)buff);
+	free((void *)buff);
 	return 1;
 }

@@ -304,7 +334,7 @@ int NfsClient::GetRange(const std::string &ppath, void *buffer, uint64_t size, u

 int NfsClient::GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset)
 {
-	struct nfsfh *nfsfh = (struct nfsfh *) fp;
+	struct nfsfh *nfsfh = (struct nfsfh *)fp;

 	int ret = nfs_lseek(nfs, nfsfh, offset, SEEK_SET, NULL);
 	if (ret != 0)
@@ -358,13 +388,13 @@ int NfsClient::Put(const std::string &inputfile, const std::string &ppath, uint6
 		return 0;
 	}

-	FILE* in = FS::OpenRead(inputfile);
+	FILE *in = FS::OpenRead(inputfile);
 	if (in == NULL)
 	{
 		sprintf(response, "%s", lang_strings[STR_FAILED]);
 		return 0;
 	}
-	
+
 	struct nfsfh *nfsfh = nullptr;
 	int ret;
 	if (!FileExists(ppath))
@@ -380,7 +410,7 @@ int NfsClient::Put(const std::string &inputfile, const std::string &ppath, uint6
 		return 0;
 	}

-	void* buff = malloc(BUF_SIZE);
+	void *buff = malloc(BUF_SIZE);
 	uint64_t count = 0;
 	bytes_transfered = 0;
 	sceRtcGetCurrentTick(&prev_tick);
@@ -459,7 +489,8 @@ std::vector<DirEntry> NfsClient::ListDir(const std::string &path)
 	struct nfsdirent *nfsdirent;

 	int ret = nfs_opendir(nfs, path.c_str(), &nfsdir);
-	if (ret != 0) {
+	if (ret != 0)
+	{
 		sprintf(response, "%s", nfs_get_error(nfs));
 		return out;
 	}
@@ -526,7 +557,6 @@ std::vector<DirEntry> NfsClient::ListDir(const std::string &path)
 		}
 		if (strcmp(entry.name, "..") != 0 && strcmp(entry.name, ".") != 0)
 			out.push_back(entry);
-
 	}
 	nfs_closedir(nfs, nfsdir);

@@ -569,13 +599,14 @@ int NfsClient::Head(const std::string &ppath, void *buffer, uint64_t len)
 void *NfsClient::Open(const std::string &path, int flags)
 {
 	struct nfsfh *nfsfh = nullptr;
-    nfs_open(nfs, path.c_str(), 0400, &nfsfh);;
+	nfs_open(nfs, path.c_str(), 0400, &nfsfh);
+	;
 	return nfsfh;
 }

 void NfsClient::Close(void *fp)
 {
-    nfs_close(nfs, (struct nfsfh*)fp);
+	nfs_close(nfs, (struct nfsfh *)fp);
 }

 ClientType NfsClient::clientType()
@@ -23,6 +23,7 @@ public:
 	int Rmdir(const std::string &path, bool recursive);
 	int Size(const std::string &path, int64_t *size);
 	int Get(const std::string &outputfile, const std::string &path, uint64_t offset=0);
+	int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0);
 	int GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset);
 	int GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset);
 	int GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset);
@@ -5,6 +5,7 @@
 #include <vector>
 #include "common.h"
 #include "http/httplib.h"
+#include "split_file.h"

 enum RemoteActions
 {
@@ -49,6 +50,7 @@ public:
    virtual int Rmdir(const std::string &path, bool recursive) = 0;
    virtual int Size(const std::string &path, int64_t *size) = 0;
    virtual int Get(const std::string &outputfile, const std::string &path, uint64_t offset=0) = 0;
+    virtual int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0) = 0;
    virtual int Put(const std::string &inputfile, const std::string &path, uint64_t offset=0) = 0;
    virtual int Rename(const std::string &src, const std::string &dst) = 0;
    virtual int Delete(const std::string &path) = 0;
@@ -306,6 +306,36 @@ int SFTPClient::Get(const std::string &outputfile, const std::string &path, uint
    return 1;
 }

+int SFTPClient::Get(SplitFile *split_file, const std::string &path, uint64_t offset)
+{
+    LIBSSH2_SFTP_HANDLE *sftp_handle = libssh2_sftp_open(sftp_session, path.c_str(), LIBSSH2_FXF_READ, 0);
+    if (!sftp_handle)
+    {
+        sprintf(response, "Unable to open file with SFTP: %ld", libssh2_sftp_last_error(sftp_session));
+        return 0;
+    }
+
+    char *buff = (char *)malloc(FTP_CLIENT_BUFSIZ);
+    int rc, count = 0;
+
+    do
+    {
+        rc = libssh2_sftp_read(sftp_handle, buff, FTP_CLIENT_BUFSIZ);
+        if (rc > 0)
+        {
+            split_file->Write(buff, rc);
+        }
+        else
+        {
+            break;
+        }
+    } while (1);
+    free((char *)buff);
+    libssh2_sftp_close(sftp_handle);
+
+    return 1;
+}
+
 int SFTPClient::GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset)
 {
    LIBSSH2_SFTP_HANDLE *sftp_handle = libssh2_sftp_open(sftp_session, path.c_str(), LIBSSH2_FXF_READ, 0);
@@ -323,8 +353,8 @@ int SFTPClient::GetRange(const std::string &path, DataSink &sink, uint64_t size,

 int SFTPClient::GetRange(void *fp, DataSink &sink, uint64_t size, uint64_t offset)
 {
-    LIBSSH2_SFTP_HANDLE *sftp_handle = (LIBSSH2_SFTP_HANDLE *) fp;
-    
+    LIBSSH2_SFTP_HANDLE *sftp_handle = (LIBSSH2_SFTP_HANDLE *)fp;
+
    libssh2_sftp_seek64(sftp_handle, offset);

    char *buff = (char *)malloc(FTP_CLIENT_BUFSIZ);
@@ -352,7 +382,7 @@ int SFTPClient::GetRange(void *fp, DataSink &sink, uint64_t size, uint64_t offse

    free((char *)buff);

-	return 1;
+    return 1;
 }

 int SFTPClient::GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset)
@@ -377,7 +407,7 @@ int SFTPClient::GetRange(const std::string &path, void *buffer, uint64_t size, u

 int SFTPClient::GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset)
 {
-    LIBSSH2_SFTP_HANDLE *sftp_handle = (LIBSSH2_SFTP_HANDLE *) fp;
+    LIBSSH2_SFTP_HANDLE *sftp_handle = (LIBSSH2_SFTP_HANDLE *)fp;

    libssh2_sftp_seek64(sftp_handle, offset);
    int count = libssh2_sftp_read(sftp_handle, (char *)buffer, size);
@@ -20,6 +20,7 @@ public:
    int Rmdir(const std::string &path);
    int Size(const std::string &path, int64_t *size);
    int Get(const std::string &outputfile, const std::string &path, uint64_t offset=0);
+    int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0);
    int GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset);
    int GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset);
    int GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset);
@@ -197,21 +197,21 @@ int SmbClient::Get(const std::string &outputfile, const std::string &ppath, uint
 		return 0;
 	}

-	struct smb2fh* in = smb2_open(smb2, path.c_str(), O_RDONLY);
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), O_RDONLY);
 	if (in == NULL)
 	{
 		sprintf(response, "%s", smb2_get_error(smb2));
 		return 0;
 	}

-	FILE* out = FS::Create(outputfile);
+	FILE *out = FS::Create(outputfile);
 	if (out == NULL)
 	{
 		sprintf(response, "%s", lang_strings[STR_FAILED]);
 		return 0;
 	}

-	uint8_t *buff = (uint8_t*)malloc(max_read_size);
+	uint8_t *buff = (uint8_t *)malloc(max_read_size);
 	int count = 0;
 	bytes_transfered = 0;
 	sceRtcGetCurrentTick(&prev_tick);
@@ -223,7 +223,7 @@ int SmbClient::Get(const std::string &outputfile, const std::string &ppath, uint
 			sprintf(response, "%s", smb2_get_error(smb2));
 			FS::Close(out);
 			smb2_close(smb2, in);
-			free((void*)buff);
+			free((void *)buff);
 			return 0;
 		}
 		FS::Write(out, buff, count);
@@ -231,7 +231,39 @@ int SmbClient::Get(const std::string &outputfile, const std::string &ppath, uint
 	}
 	FS::Close(out);
 	smb2_close(smb2, in);
-	free((void*)buff);
+	free((void *)buff);
+	return 1;
+}
+
+int SmbClient::Get(SplitFile *split_file, const std::string &ppath, uint64_t offset)
+{
+	std::string path = std::string(ppath);
+	path = Util::Trim(path, "/");
+
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), O_RDONLY);
+	if (in == NULL)
+	{
+		sprintf(response, "%s", smb2_get_error(smb2));
+		return 0;
+	}
+
+	uint8_t *buff = (uint8_t *)malloc(max_read_size);
+	int count = 0;
+
+	while ((count = smb2_read(smb2, in, buff, max_read_size)) > 0)
+	{
+		if (count < 0)
+		{
+			sprintf(response, "%s", smb2_get_error(smb2));
+			smb2_close(smb2, in);
+			free((void *)buff);
+			return 0;
+		}
+		split_file->Write((char*)buff, count);
+	}
+
+	smb2_close(smb2, in);
+	free((void *)buff);
 	return 1;
 }

@@ -239,7 +271,7 @@ int SmbClient::GetRange(const std::string &ppath, DataSink &sink, uint64_t size,
 {
 	std::string path = std::string(ppath);
 	path = Util::Trim(path, "/");
-	struct smb2fh* in = smb2_open(smb2, path.c_str(), O_RDONLY);
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), O_RDONLY);
 	if (in == NULL)
 	{
 		return 0;
@@ -253,34 +285,34 @@ int SmbClient::GetRange(const std::string &ppath, DataSink &sink, uint64_t size,

 int SmbClient::GetRange(void *fp, DataSink &sink, uint64_t size, uint64_t offset)
 {
-	struct smb2fh* in = (struct smb2fh*)fp;
+	struct smb2fh *in = (struct smb2fh *)fp;

-    smb2_lseek(smb2, in, offset, SEEK_SET, NULL);
+	smb2_lseek(smb2, in, offset, SEEK_SET, NULL);

-	uint8_t *buff = (uint8_t*)malloc(max_read_size);
-    int count = 0;
-    size_t bytes_remaining = size;
-    do
-    {
-        size_t bytes_to_read = std::min<size_t>(max_read_size, bytes_remaining);
-        count = smb2_read(smb2, in, buff, bytes_to_read);
-        if (count > 0)
-        {
-            bytes_remaining -= count;
-            bool ok = sink.write((char*)buff, count);
+	uint8_t *buff = (uint8_t *)malloc(max_read_size);
+	int count = 0;
+	size_t bytes_remaining = size;
+	do
+	{
+		size_t bytes_to_read = std::min<size_t>(max_read_size, bytes_remaining);
+		count = smb2_read(smb2, in, buff, bytes_to_read);
+		if (count > 0)
+		{
+			bytes_remaining -= count;
+			bool ok = sink.write((char *)buff, count);
 			if (!ok)
 			{
 				free((uint8_t *)buff);
 				return 0;
 			}
-        }
-        else
-        {
-            break;
-        }
-    } while (1);
+		}
+		else
+		{
+			break;
+		}
+	} while (1);

-    free((char *)buff);
+	free((char *)buff);

 	return 1;
 }
@@ -295,7 +327,7 @@ int SmbClient::GetRange(const std::string &ppath, void *buffer, uint64_t size, u
 		return 0;
 	}

-	struct smb2fh* in = smb2_open(smb2, path.c_str(), O_RDONLY);
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), O_RDONLY);
 	if (in == NULL)
 	{
 		return 0;
@@ -309,13 +341,27 @@ int SmbClient::GetRange(const std::string &ppath, void *buffer, uint64_t size, u

 int SmbClient::GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset)
 {
-	struct smb2fh* in = (struct smb2fh*) fp;
+	struct smb2fh *in = (struct smb2fh *)fp;

 	smb2_lseek(smb2, in, offset, SEEK_SET, NULL);

-	int count = smb2_read(smb2, in, (uint8_t*)buffer, size);
-	if (count != size)
-		return 0;
+	uint8_t *buff = (uint8_t *)buffer;
+	int count = 0;
+	size_t bytes_remaining = size;
+	do
+	{
+		size_t bytes_to_read = std::min<size_t>(max_read_size, bytes_remaining);
+		count = smb2_read(smb2, in, buff, bytes_to_read);
+		if (count > 0)
+		{
+			bytes_remaining -= count;
+			buff += count;
+		}
+		else
+		{
+			break;
+		}
+	} while (1);

 	return 1;
 }
@@ -342,14 +388,14 @@ int SmbClient::CopyToSocket(const std::string &ppath, int socket_fd)
 		return 0;
 	}

-	struct smb2fh* in = smb2_open(smb2, path.c_str(), O_RDONLY);
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), O_RDONLY);
 	if (in == NULL)
 	{
 		sprintf(response, "%s", smb2_get_error(smb2));
 		return 0;
 	}

-	uint8_t *buff = (uint8_t*)malloc(max_read_size);
+	uint8_t *buff = (uint8_t *)malloc(max_read_size);
 	int count = 0;
 	while ((count = smb2_read(smb2, in, buff, max_read_size)) > 0)
 	{
@@ -357,7 +403,7 @@ int SmbClient::CopyToSocket(const std::string &ppath, int socket_fd)
 		{
 			sprintf(response, "%s", smb2_get_error(smb2));
 			smb2_close(smb2, in);
-			free((void*)buff);
+			free((void *)buff);
 			return 0;
 		}
 		int ret = sceNetSend(socket_fd, buff, count, 0);
@@ -367,7 +413,7 @@ int SmbClient::CopyToSocket(const std::string &ppath, int socket_fd)
 		}
 	}
 	smb2_close(smb2, in);
-	free((void*)buff);
+	free((void *)buff);
 	return 1;
 }

@@ -403,21 +449,21 @@ int SmbClient::Put(const std::string &inputfile, const std::string &ppath, uint6
 		return 0;
 	}

-	FILE* in = FS::OpenRead(inputfile);
+	FILE *in = FS::OpenRead(inputfile);
 	if (in == NULL)
 	{
 		sprintf(response, "%s", lang_strings[STR_FAILED]);
 		return 0;
 	}
-	
-	struct smb2fh* out = smb2_open(smb2, path.c_str(), O_WRONLY | O_CREAT | O_TRUNC);
+
+	struct smb2fh *out = smb2_open(smb2, path.c_str(), O_WRONLY | O_CREAT | O_TRUNC);
 	if (out == NULL)
 	{
 		sprintf(response, "%s", smb2_get_error(smb2));
 		return 0;
 	}

-	uint8_t* buff = (uint8_t*)malloc(max_write_size);
+	uint8_t *buff = (uint8_t *)malloc(max_write_size);
 	int count = 0;
 	bytes_transfered = 0;
 	sceRtcGetCurrentTick(&prev_tick);
@@ -440,7 +486,6 @@ int SmbClient::Put(const std::string &inputfile, const std::string &ppath, uint6
 	free(buff);

 	return 1;
-
 }

 int SmbClient::Rename(const std::string &src, const std::string &dst)
@@ -574,13 +619,13 @@ int SmbClient::Head(const std::string &ppath, void *buffer, uint64_t len)
 		return 0;
 	}

-	struct smb2fh* in = smb2_open(smb2, path.c_str(), O_RDONLY);
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), O_RDONLY);
 	if (in == NULL)
 	{
 		return 0;
 	}

-	int count = smb2_read(smb2, in, (uint8_t*)buffer, len);
+	int count = smb2_read(smb2, in, (uint8_t *)buffer, len);
 	smb2_close(smb2, in);
 	if (count != len)
 		return 0;
@@ -593,13 +638,13 @@ void *SmbClient::Open(const std::string &ppath, int flags)
 	std::string path = std::string(ppath);
 	path = Util::Trim(path, "/");

-    struct smb2fh* in = smb2_open(smb2, path.c_str(), flags);
-    return in;
+	struct smb2fh *in = smb2_open(smb2, path.c_str(), flags);
+	return in;
 }

 void SmbClient::Close(void *fp)
 {
-    smb2_close(smb2, (struct smb2fh*)fp);
+	smb2_close(smb2, (struct smb2fh *)fp);
 }

 ClientType SmbClient::clientType()
@@ -24,6 +24,7 @@ public:
 	int Rmdir(const std::string &path, bool recursive);
 	int Size(const std::string &path, int64_t *size);
 	int Get(const std::string &outputfile, const std::string &path, uint64_t offset=0);
+	int Get(SplitFile *split_file, const std::string &path, uint64_t offset=0);
 	int GetRange(const std::string &path, void *buffer, uint64_t size, uint64_t offset);
 	int GetRange(const std::string &path, DataSink &sink, uint64_t size, uint64_t offset);
 	int GetRange(void *fp, void *buffer, uint64_t size, uint64_t offset);
@@ -10,10 +10,10 @@
 #include "windows.h"

 using httplib::Client;
+using httplib::ContentProvider;
 using httplib::Headers;
 using httplib::Progress;
 using httplib::Result;
-using httplib::ContentProvider;

 static const char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

@@ -43,6 +43,50 @@ Result WebDAVClient::PropFind(const std::string &path, int depth)
    return client->send(req);
 }

+int WebDAVClient::Size(const std::string &path, int64_t *size)
+{
+    std::string encoded_path = httplib::detail::encode_url(GetFullPath(path));
+    if (auto res = PropFind(encoded_path, 0))
+    {
+        if (HTTP_SUCCESS(res->status))
+        {
+            pugi::xml_document document;
+            document.load_buffer(res->body.c_str(), res->body.length());
+            auto multistatus = document.select_node("*[local-name()='multistatus']").node();
+            auto responses = multistatus.select_nodes("*[local-name()='response']");
+            for (auto response : responses)
+            {
+                pugi::xml_node href = response.node().select_node("*[local-name()='href']").node();
+                std::string resource_path = httplib::detail::decode_url(href.first_child().value(), true);
+
+                auto target_path_without_sep = GetFullPath(path);
+                if (!target_path_without_sep.empty() && target_path_without_sep.back() == '/')
+                    target_path_without_sep.resize(target_path_without_sep.length() - 1);
+                auto resource_path_without_sep = resource_path.erase(resource_path.find_last_not_of('/') + 1);
+                size_t pos = resource_path_without_sep.find(this->host_url);
+                if (pos != std::string::npos)
+                    resource_path_without_sep.erase(pos, this->host_url.length());
+
+                if (resource_path_without_sep != target_path_without_sep)
+                    continue;
+
+                auto propstat = response.node().select_node("*[local-name()='propstat']").node();
+                auto prop = propstat.select_node("*[local-name()='prop']").node();
+                std::string content_length = prop.select_node("*[local-name()='getcontentlength']").node().first_child().value();
+
+                *size = std::strtoll(content_length.c_str(), nullptr, 10);
+                return 1;
+            }
+        }
+    }
+    else
+    {
+        sprintf(this->response, "%s", httplib::to_string(res.error()).c_str());
+    }
+
+    return 0;
+}
+
 std::vector<DirEntry> WebDAVClient::ListDir(const std::string &path)
 {
    std::vector<DirEntry> out;
@@ -152,12 +196,11 @@ int WebDAVClient::Put(const std::string &inputfile, const std::string &path, uin
    size_t bytes_remaining = FS::GetSize(inputfile);
    bytes_transfered = 0;
    sceRtcGetCurrentTick(&prev_tick);
-    
-    FILE* in = FS::OpenRead(inputfile);

-    if (auto res = client->Put(GetFullPath(path),
-        [&](size_t offset, DataSink &sink)
-        {
+    FILE *in = FS::OpenRead(inputfile);
+
+    if (auto res = client->Put(GetFullPath(path), [&](size_t offset, DataSink &sink)
+                               {
            size_t buf_size = MIN(bytes_remaining, CPPHTTPLIB_RECV_BUFSIZ);
            char* buf = (char*) malloc(buf_size);
            FS::Seek(in, offset);
@@ -171,9 +214,7 @@ int WebDAVClient::Put(const std::string &inputfile, const std::string &path, uin
            }
            sink.done();
            free(buf);
-            return true;
-        },
-        "application/octet-stream"))
+            return true; }, "application/octet-stream"))
    {
        if (HTTP_SUCCESS(res->status))
        {
@@ -230,15 +271,14 @@ int WebDAVClient::Delete(const std::string &path)
        if (HTTP_SUCCESS(res->status))
            return 1;
    }
-    
-    return 0;

+    return 0;
 }

 int WebDAVClient::Copy(const std::string &from, const std::string &to)
 {
    Request req;
-    Headers header = {{"Accept", "*/*"}, {"Destination", httplib::detail::encode_url(GetFullPath(to)) }};
+    Headers header = {{"Accept", "*/*"}, {"Destination", httplib::detail::encode_url(GetFullPath(to))}};

    req.method = "COPY";
    req.path = httplib::detail::encode_url(GetFullPath(from));
@@ -257,7 +297,7 @@ int WebDAVClient::Copy(const std::string &from, const std::string &to)
 int WebDAVClient::Move(const std::string &from, const std::string &to)
 {
    Request req;
-    Headers header = {{"Accept", "*/*"}, {"Destination", httplib::detail::encode_url(GetFullPath(to)) }};
+    Headers header = {{"Accept", "*/*"}, {"Destination", httplib::detail::encode_url(GetFullPath(to))}};

    req.method = "MOVE";
    req.path = httplib::detail::encode_url(GetFullPath(from));
@@ -19,6 +19,7 @@ public:
    int Copy(const std::string &from, const std::string &to);
    int Move(const std::string &from, const std::string &to);
    int Put(const std::string &inputfile, const std::string &path, uint64_t offset = 0);
+    int Size(const std::string &path, int64_t *size);
    std::vector<DirEntry> ListDir(const std::string &path);
    ClientType clientType();
    uint32_t SupportedActions();
@@ -152,14 +152,17 @@ namespace CONFIG
            FS::MkDirs(DATA_PATH);
        }

+        memset(&install_pkg_url, 0, sizeof(install_pkg_url));
+        install_pkg_url.enable_rpi = true;
+
        sites = {"Site 1", "Site 2", "Site 3", "Site 4", "Site 5", "Site 6", "Site 7", "Site 8", "Site 9", "Site 10",
                 "Site 11", "Site 12", "Site 13", "Site 14", "Site 15", "Site 16", "Site 17", "Site 18", "Site 19", "Site 20"};

        langs = { "Default", "Arabic", "Catalan", "Croatian", "Dutch", "English", "Euskera", "French", "Galego", "German", "Greek", 
                  "Hungarian", "Indonesian", "Italiano", "Japanese", "Korean", "Polish", "Portuguese_BR", "Russian", "Romanian", "Ryukyuan", "Spanish", "Turkish",
-                  "Simplified Chinese", "Traditional Chinese", "Thai", "Ukrainian"};
+                  "Simplified Chinese", "Traditional Chinese", "Thai", "Ukrainian", "Vietnamese"};

-        http_servers = {HTTP_SERVER_APACHE, HTTP_SERVER_MS_IIS, HTTP_SERVER_NGINX, HTTP_SERVER_NPX_SERVE, HTTP_SERVER_RCLONE};
+        http_servers = {HTTP_SERVER_APACHE, HTTP_SERVER_MS_IIS, HTTP_SERVER_NGINX, HTTP_SERVER_NPX_SERVE, HTTP_SERVER_RCLONE, HTTP_SERVER_ARCHIVEORG, HTTP_SERVER_MYRIENT};
        text_file_extensions = { ".txt", ".ini", ".log", ".json", ".xml", ".html", ".xhtml", ".conf", ".config" };
        image_file_extensions = { ".bmp", ".jpg", ".jpeg", ".png", ".webp" };

@@ -298,6 +301,9 @@ namespace CONFIG
            setting.enable_rpi = ReadBool(sites[i].c_str(), CONFIG_ENABLE_RPI, true);
            WriteBool(sites[i].c_str(), CONFIG_ENABLE_RPI, setting.enable_rpi);

+            setting.enable_disk_cache = ReadBool(sites[i].c_str(), CONFIG_REMOTE_ENABLE_DISK_CACHE, false);
+            WriteBool(sites[i].c_str(), CONFIG_REMOTE_ENABLE_DISK_CACHE, setting.enable_disk_cache);
+
            sprintf(setting.http_server_type, "%s", ReadString(sites[i].c_str(), CONFIG_REMOTE_HTTP_SERVER_TYPE, HTTP_SERVER_APACHE));
            WriteString(sites[i].c_str(), CONFIG_REMOTE_HTTP_SERVER_TYPE, setting.http_server_type);

@@ -371,6 +377,7 @@ namespace CONFIG
        WriteString(last_site, CONFIG_REMOTE_SERVER_USER, remote_settings->username);
        WriteString(last_site, CONFIG_REMOTE_SERVER_PASSWORD, encrypted_text.c_str());
        WriteBool(last_site, CONFIG_ENABLE_RPI, remote_settings->enable_rpi);
+        WriteBool(last_site, CONFIG_REMOTE_ENABLE_DISK_CACHE, remote_settings->enable_disk_cache);
        WriteString(last_site, CONFIG_REMOTE_HTTP_SERVER_TYPE, remote_settings->http_server_type);
        WriteString(last_site, CONFIG_REMOTE_DEFAULT_DIRECTORY, remote_settings->default_directory);
        WriteString(CONFIG_GLOBAL, CONFIG_LAST_SITE, last_site);
@@ -57,6 +57,7 @@
 #define CONFIG_ENABLE_RPI "remote_server_enable_rpi"
 #define CONFIG_REMOTE_HTTP_SERVER_TYPE "remote_server_http_server_type"
 #define CONFIG_REMOTE_DEFAULT_DIRECTORY "remote_server_default_directory"
+#define CONFIG_REMOTE_ENABLE_DISK_CACHE "remote_server_enable_disk_cache"

 #define CONFIG_ALLDEBRID_API_KEY "alldebrid_api_key"
 #define CONFIG_REALDEBRID_API_KEY "realdebrid_api_key"
@@ -81,6 +82,8 @@
 #define HTTP_SERVER_NGINX "Nginx"
 #define HTTP_SERVER_NPX_SERVE "Serve"
 #define HTTP_SERVER_RCLONE "RClone"
+#define HTTP_SERVER_ARCHIVEORG "Archive.org"
+#define HTTP_SERVER_MYRIENT "Myrient"

 #define MAX_EDIT_FILE_SIZE 32768

@@ -110,6 +113,7 @@ struct RemoteSettings
    char http_server_type[24];
    GoogleAccountInfo gg_account;
    char default_directory[256];
+    bool enable_disk_cache;
 };

 struct PackageUrlInfo
@@ -117,6 +121,10 @@ struct PackageUrlInfo
    char url[512];
    char username[33];
    char password[25];
+    bool enable_alldebrid;
+    bool enable_realdebrid;
+    bool enable_disk_cache;
+    bool enable_rpi;
 };

 extern std::vector<std::string> sites;
@@ -84,6 +84,8 @@
 #define BUTTON_RIGHT 0x00000020
 #define BUTTON_UP 0x00000040
 #define BUTTON_DOWN 0x00000080
+#define BUTTON_C 0x00000100
+#define BUTTON_D 0x00000200

 static uint32_t previous_down = 0;
 static int repeat_count = 0;
@@ -531,8 +533,15 @@ static void ImGui_ImplSDL2_UpdateGamepads()
        down |= BUTTON_DOWN;
    else if (SDL_GameControllerGetAxis(game_controller, SDL_CONTROLLER_AXIS_LEFTY)  < -ANALOG_THRESHOLD)
        down |= BUTTON_UP;
+    else if (SDL_GameControllerGetAxis(game_controller, SDL_CONTROLLER_AXIS_TRIGGERLEFT) > ANALOG_THRESHOLD)
+        down |= BUTTON_C;
+    else if (SDL_GameControllerGetAxis(game_controller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT) > ANALOG_THRESHOLD)
+        down |= BUTTON_D;

    uint32_t pressed = down & ~previous_down;
+    io.AddKeyEvent(ImGuiKey_C, (pressed & BUTTON_C) != 0);
+    io.AddKeyEvent(ImGuiKey_D, (pressed & BUTTON_D) != 0);
+
    if (previous_down == down)
    {
        uint64_t delay = 300;
@@ -26,7 +26,8 @@

 struct BgProgressCheck
 {
-	ArchivePkgInstallData* pkg_data;
+	ArchivePkgInstallData *archive_pkg_data;
+	SplitPkgInstallData *split_pkg_data;
 	int task_id;
 	std::string hash;
 };
@@ -36,6 +37,7 @@ static OrbisBgftInitParams s_bgft_init_params;
 static bool s_bgft_initialized = false;

 static std::map<std::string, ArchivePkgInstallData *> archive_pkg_install_data_list;
+static std::map<std::string, SplitPkgInstallData *> split_pkg_install_data_list;

 namespace INSTALLER
 {
@@ -107,22 +109,22 @@ namespace INSTALLER
 		s_bgft_initialized = false;
 	}

-    std::string GetRemotePkgTitle(RemoteClient *client, const std::string &path, pkg_header *header)
-    {
+	std::string GetRemotePkgTitle(RemoteClient *client, const std::string &path, pkg_header *header)
+	{
 		size_t entry_count = BE32(header->pkg_entry_count);
 		uint32_t entry_table_offset = BE32(header->pkg_table_offset);
 		uint64_t entry_table_size = entry_count * sizeof(pkg_table_entry);
 		void *entry_table_data = malloc(entry_table_size);

-        int ret = client->GetRange(path, entry_table_data, entry_table_size, entry_table_offset);
-        if (ret == 0)
-        {
-            free(entry_table_data);
-            return "";
-        }
+		int ret = client->GetRange(path, entry_table_data, entry_table_size, entry_table_offset);
+		if (ret == 0)
+		{
+			free(entry_table_data);
+			return "";
+		}

 		pkg_table_entry *entries = (pkg_table_entry *)entry_table_data;
-		void* param_sfo_data = nullptr;
+		void *param_sfo_data = nullptr;
 		uint32_t param_sfo_offset = 0;
 		uint32_t param_sfo_size = 0;
 		for (size_t i = 0; i < entry_count; ++i)
@@ -132,7 +134,7 @@ namespace INSTALLER
 				param_sfo_offset = BE32(entries[i].offset);
 				param_sfo_size = BE32(entries[i].size);
 				break;
-            }
+			}
 		}
 		free(entry_table_data);

@@ -140,10 +142,10 @@ namespace INSTALLER
 		if (param_sfo_offset > 0 && param_sfo_size > 0)
 		{
 			param_sfo_data = malloc(param_sfo_size);
-            int ret = client->GetRange(path, param_sfo_data, param_sfo_size, param_sfo_offset);
-            if (ret)
+			int ret = client->GetRange(path, param_sfo_data, param_sfo_size, param_sfo_offset);
+			if (ret)
 			{
-				const char* tmp_title = SFO::GetString((const char*)param_sfo_data, param_sfo_size, "TITLE");
+				const char *tmp_title = SFO::GetString((const char *)param_sfo_data, param_sfo_size, "TITLE");
 				if (tmp_title != nullptr)
 					title = std::string(tmp_title);
 			}
@@ -151,7 +153,7 @@ namespace INSTALLER
 		}

 		return title;
-    }
+	}

 	std::string GetLocalPkgTitle(const std::string &path, pkg_header *header)
 	{
@@ -165,7 +167,7 @@ namespace INSTALLER
 		FS::Read(fd, entry_table_data, entry_table_size);

 		pkg_table_entry *entries = (pkg_table_entry *)entry_table_data;
-		void* param_sfo_data = NULL;
+		void *param_sfo_data = NULL;
 		uint32_t param_sfo_offset = 0;
 		uint32_t param_sfo_size = 0;
 		void *icon0_png_data = NULL;
@@ -188,7 +190,7 @@ namespace INSTALLER
 			param_sfo_data = malloc(param_sfo_size);
 			FS::Seek(fd, param_sfo_offset);
 			FS::Read(fd, param_sfo_data, param_sfo_size);
-			const char* tmp_title = SFO::GetString((const char*)param_sfo_data, param_sfo_size, "TITLE");
+			const char *tmp_title = SFO::GetString((const char *)param_sfo_data, param_sfo_size, "TITLE");
 			if (tmp_title != nullptr)
 				title = std::string(tmp_title);
 			free(param_sfo_data);
@@ -219,8 +221,8 @@ namespace INSTALLER
 		}
 		else
 		{
-			std::string encoded_path =  httplib::detail::encode_url(path);
-			std::string encoded_site_name =  httplib::detail::encode_url(remote_settings->site_name);
+			std::string encoded_path = httplib::detail::encode_url(path);
+			std::string encoded_site_name = httplib::detail::encode_url(remote_settings->site_name);
 			std::string full_url = std::string("http://localhost:") + std::to_string(http_server_port) + "/rmt_inst/" + encoded_site_name + encoded_path;
 			return full_url;
 		}
@@ -232,7 +234,7 @@ namespace INSTALLER
 	{
 		bool completed = false;
 		OrbisBgftTaskProgress progress_info;
-		BgProgressCheck *bg_check_data = (BgProgressCheck*) argp;
+		BgProgressCheck *bg_check_data = (BgProgressCheck *)argp;
 		int ret;

 		while (!completed)
@@ -253,15 +255,27 @@ namespace INSTALLER
 			sceKernelUsleep(500000);
 		}
 	finish:
-		if (bg_check_data->pkg_data != nullptr)
+		if (bg_check_data->archive_pkg_data != nullptr)
 		{
-			bg_check_data->pkg_data->stop_write_thread = true;
-			pthread_join(bg_check_data->pkg_data->thread, NULL);
-			delete(bg_check_data->pkg_data->split_file);
-			free(bg_check_data->pkg_data);
+			bg_check_data->archive_pkg_data->stop_write_thread = true;
+			pthread_join(bg_check_data->archive_pkg_data->thread, NULL);
+			delete (bg_check_data->archive_pkg_data->split_file);
+			free(bg_check_data->archive_pkg_data);
 			RemoveArchivePkgInstallData(bg_check_data->hash);
 			free(bg_check_data);
 		}
+		else if (bg_check_data->split_pkg_data != nullptr)
+		{
+			bg_check_data->split_pkg_data->stop_write_thread = true;
+			bg_check_data->split_pkg_data->split_file->Close();
+			pthread_join(bg_check_data->split_pkg_data->thread, NULL);
+			delete (bg_check_data->split_pkg_data->split_file);
+			if (bg_check_data->split_pkg_data->delete_client)
+				delete (bg_check_data->split_pkg_data->remote_client);
+			free(bg_check_data->split_pkg_data);
+			RemoveSplitPkgInstallData(bg_check_data->hash);
+			free(bg_check_data);
+		}
 		activity_inprogess = false;
 		file_transfering = false;
 		Windows::SetModalMode(false);
@@ -388,7 +402,7 @@ namespace INSTALLER
 		if (prompt)
 		{
 			file_transfering = true;
-			bytes_to_download = 100;
+			bytes_to_download = header->pkg_content_size;
 			bytes_transfered = 0;
 			sceRtcGetCurrentTick(&prev_tick);

@@ -398,7 +412,7 @@ namespace INSTALLER
 				ret = sceBgftServiceDownloadGetProgress(task_id, &progress_info);
 				if (ret || (progress_info.transferred > 0 && progress_info.errorResult != 0))
 					return 0;
-				
+
 				if (progress_info.length > 0)
 				{
 					completed = progress_info.transferred == progress_info.length;
@@ -410,9 +424,10 @@ namespace INSTALLER
 		}
 		else
 		{
-			BgProgressCheck *bg_check_data = (BgProgressCheck*) malloc(sizeof(BgProgressCheck));
+			BgProgressCheck *bg_check_data = (BgProgressCheck *)malloc(sizeof(BgProgressCheck));
 			memset(bg_check_data, 0, sizeof(BgProgressCheck));
-			bg_check_data->pkg_data = nullptr;
+			bg_check_data->archive_pkg_data = nullptr;
+			bg_check_data->split_pkg_data = nullptr;
 			bg_check_data->task_id = task_id;
 			bg_check_data->hash = "";
 			ret = pthread_create(&bk_install_thid, NULL, CheckBgInstallTaskThread, bg_check_data);
@@ -489,8 +504,9 @@ namespace INSTALLER
 		Util::Notify("%s queued", display_title.c_str());

 		file_transfering = true;
-		bytes_to_download = 100;
+		bytes_to_download = header.pkg_content_size;
 		bytes_transfered = 0;
+		sceRtcGetCurrentTick(&prev_tick);

 		while (!completed)
 		{
@@ -517,13 +533,13 @@ namespace INSTALLER
 	{
 		int ret;
 		bool completed = false;
-		
+
 		if (strncmp(path.c_str(), "/data/", 6) != 0 &&
 			strncmp(path.c_str(), "/user/data/", 11) != 0 &&
 			strncmp(path.c_str(), "/mnt/usb", 8) != 0)
 			return -1;

-		std::string filename = path.substr(path.find_last_of("/")+1);
+		std::string filename = path.substr(path.find_last_of("/") + 1);
 		char filepath[1024];
 		snprintf(filepath, 1023, "%s", path.c_str());
 		if (strncmp(path.c_str(), "/data/", 6) == 0)
@@ -601,7 +617,7 @@ namespace INSTALLER
 		}

 		sprintf(activity_message, "%s", lang_strings[STR_WAIT_FOR_INSTALL_MSG]);
-		bytes_to_download = 1;
+		bytes_to_download = header->pkg_content_size;
 		bytes_transfered = 0;
 		sceRtcGetCurrentTick(&prev_tick);

@@ -643,7 +659,7 @@ namespace INSTALLER
 		FS::Read(fd, entry_table_data, entry_table_size);

 		pkg_table_entry *entries = (pkg_table_entry *)entry_table_data;
-		void* param_sfo_data = NULL;
+		void *param_sfo_data = NULL;
 		uint32_t param_sfo_offset = 0;
 		uint32_t param_sfo_size = 0;
 		void *icon0_png_data = NULL;
@@ -714,7 +730,7 @@ namespace INSTALLER
 			return false;

 		pkg_table_entry *entries = (pkg_table_entry *)entry_table_data;
-		void* param_sfo_data = NULL;
+		void *param_sfo_data = NULL;
 		uint32_t param_sfo_offset = 0;
 		uint32_t param_sfo_size = 0;
 		void *icon0_png_data = NULL;
@@ -782,7 +798,7 @@ namespace INSTALLER

 	void AddArchivePkgInstallData(const std::string &hash, ArchivePkgInstallData *pkg_data)
 	{
-		std::pair<std::string, ArchivePkgInstallData*> pair = std::make_pair(hash, pkg_data);
+		std::pair<std::string, ArchivePkgInstallData *> pair = std::make_pair(hash, pkg_data);
 		archive_pkg_install_data_list.erase(hash);
 		archive_pkg_install_data_list.insert(pair);
 	}
@@ -792,10 +808,10 @@ namespace INSTALLER
 		archive_pkg_install_data_list.erase(hash);
 	}

-	bool InstallArchivePkg(const std::string &path, ArchivePkgInstallData* pkg_data, bool bg)
+	bool InstallArchivePkg(const std::string &path, ArchivePkgInstallData *pkg_data, bool bg)
 	{
 		pkg_header header;
-		pkg_data->split_file->Read((char*)&header, sizeof(pkg_header), 0);
+		pkg_data->split_file->Read((char *)&header, sizeof(pkg_header), 0);

 		int ret;
 		std::string cid = std::string((char *)header.pkg_content_id);
@@ -919,7 +935,7 @@ namespace INSTALLER
 		if (!bg)
 		{
 			file_transfering = true;
-			bytes_to_download = 100;
+			bytes_to_download = header.pkg_content_size;
 			bytes_transfered = 0;
 			sceRtcGetCurrentTick(&prev_tick);

@@ -932,7 +948,6 @@ namespace INSTALLER
 					ret = 0;
 					goto finish;
 				}
-				bytes_transfered = (uint32_t)(((float)progress_info.transferred / progress_info.length) * 100.f);
 				if (progress_info.length > 0)
 				{
 					completed = progress_info.transferred == progress_info.length;
@@ -944,9 +959,10 @@ namespace INSTALLER
 		}
 		else
 		{
-			BgProgressCheck *bg_check_data = (BgProgressCheck*) malloc(sizeof(BgProgressCheck));
+			BgProgressCheck *bg_check_data = (BgProgressCheck *)malloc(sizeof(BgProgressCheck));
 			memset(bg_check_data, 0, sizeof(BgProgressCheck));
-			bg_check_data->pkg_data = pkg_data;
+			bg_check_data->archive_pkg_data = pkg_data;
+			bg_check_data->split_pkg_data = nullptr;
 			bg_check_data->task_id = task_id;
 			bg_check_data->hash = hash;
 			ret = pthread_create(&bk_install_thid, NULL, CheckBgInstallTaskThread, bg_check_data);
@@ -956,11 +972,202 @@ namespace INSTALLER
 	finish:
 		pkg_data->stop_write_thread = true;
 		pthread_join(pkg_data->thread, NULL);
-		delete(pkg_data->split_file);
+		delete (pkg_data->split_file);
 		free(pkg_data);
 		RemoveArchivePkgInstallData(hash);
 		return ret;
-
 	}

+	SplitPkgInstallData *GetSplitPkgInstallData(const std::string &hash)
+	{
+		return split_pkg_install_data_list[hash];
+	}
+
+	void AddSplitPkgInstallData(const std::string &hash, SplitPkgInstallData *pkg_data)
+	{
+		std::pair<std::string, SplitPkgInstallData *> pair = std::make_pair(hash, pkg_data);
+		split_pkg_install_data_list.erase(hash);
+		split_pkg_install_data_list.insert(pair);
+	}
+
+	void RemoveSplitPkgInstallData(const std::string &hash)
+	{
+		split_pkg_install_data_list.erase(hash);
+	}
+
+	bool InstallSplitPkg(const std::string &path, SplitPkgInstallData *pkg_data, bool bg)
+	{
+		pkg_header header;
+		pkg_data->split_file->Read((char *)&header, sizeof(pkg_header), 0);
+
+		int ret;
+		std::string cid = std::string((char *)header.pkg_content_id);
+		cid = cid.substr(cid.find_first_of("-") + 1, 9);
+		std::string display_title = cid;
+		int user_id;
+		ret = sceUserServiceGetForegroundUser(&user_id);
+		const char *package_type;
+		uint32_t content_type = BE32(header.pkg_content_type);
+		uint32_t flags = BE32(header.pkg_content_flags);
+		bool is_patch = false;
+		bool completed = false;
+
+		switch (content_type)
+		{
+		case PKG_CONTENT_TYPE_GD:
+			package_type = "PS4GD";
+			break;
+		case PKG_CONTENT_TYPE_AC:
+			package_type = "PS4AC";
+			break;
+		case PKG_CONTENT_TYPE_AL:
+			package_type = "PS4AL";
+			break;
+		case PKG_CONTENT_TYPE_DP:
+			package_type = "PS4DP";
+			break;
+		default:
+			package_type = NULL;
+			return 0;
+			break;
+		}
+
+		if (flags & PKG_CONTENT_FLAGS_FIRST_PATCH ||
+			flags & PKG_CONTENT_FLAGS_SUBSEQUENT_PATCH ||
+			flags & PKG_CONTENT_FLAGS_DELTA_PATCH ||
+			flags & PKG_CONTENT_FLAGS_CUMULATIVE_PATCH)
+		{
+			is_patch = true;
+		}
+
+		std::string hash = Util::UrlHash(path);
+		std::string full_url = std::string("http://localhost:") + std::to_string(http_server_port) + "/split_inst/" + hash;
+		AddSplitPkgInstallData(hash, pkg_data);
+
+		OrbisBgftTaskProgress progress_info;
+		OrbisBgftDownloadParam params;
+		memset(&params, 0, sizeof(params));
+		{
+			params.userId = user_id;
+			params.entitlementType = 5;
+			params.id = (char *)header.pkg_content_id;
+			params.contentUrl = full_url.c_str();
+			params.contentName = display_title.c_str();
+			params.iconPath = "";
+			params.playgoScenarioId = "0";
+			params.option = ORBIS_BGFT_TASK_OPT_DISABLE_CDN_QUERY_PARAM;
+			params.packageType = package_type;
+			params.packageSubType = "";
+			params.packageSize = BE64(header.pkg_size);
+		}
+
+	retry:
+		int task_id = -1;
+		if (!is_patch)
+			ret = sceBgftServiceIntDownloadRegisterTask(&params, &task_id);
+		else
+			ret = sceBgftServiceIntDebugDownloadRegisterPkg(&params, &task_id);
+		if (ret == 0x80990088 || ret == 0x80990015)
+		{
+			if (!bg)
+			{
+				sprintf(confirm_message, "%s - %s?", display_title.c_str(), lang_strings[STR_REINSTALL_CONFIRM_MSG]);
+				confirm_state = CONFIRM_WAIT;
+				action_to_take = selected_action;
+				activity_inprogess = false;
+				while (confirm_state == CONFIRM_WAIT)
+				{
+					sceKernelUsleep(100000);
+				}
+				activity_inprogess = true;
+				selected_action = action_to_take;
+
+				if (confirm_state == CONFIRM_YES)
+				{
+					ret = sceAppInstUtilAppUnInstall(cid.c_str());
+					if (ret != 0)
+					{
+						ret = 0;
+						goto finish;
+					}
+					goto retry;
+				}
+			}
+			else
+			{
+				ret = sceAppInstUtilAppUnInstall(cid.c_str());
+				if (ret != 0)
+				{
+					ret = 0;
+					goto finish;
+				}
+				goto retry;
+			}
+		}
+		else if (ret > 0)
+		{
+			ret = 0;
+			goto finish;
+		}
+
+		ret = sceBgftServiceDownloadStartTask(task_id);
+		if (ret)
+		{
+			ret = 0;
+			goto finish;
+		}
+
+		Util::Notify("%s queued", display_title.c_str());
+
+		if (!bg)
+		{
+			file_transfering = true;
+			bytes_to_download = pkg_data->size;
+			bytes_transfered = 0;
+			sceRtcGetCurrentTick(&prev_tick);
+
+			while (!completed)
+			{
+				memset(&progress_info, 0, sizeof(progress_info));
+				ret = sceBgftServiceDownloadGetProgress(task_id, &progress_info);
+				if (ret || (progress_info.transferred > 0 && progress_info.errorResult != 0))
+				{
+					ret = 0;
+					goto finish;
+				}
+				if (progress_info.length > 0)
+				{
+					completed = progress_info.transferred == progress_info.length;
+					bytes_to_download = progress_info.length;
+					bytes_transfered = progress_info.transferred;
+				}
+				sceSystemServicePowerTick();
+			}
+		}
+		else
+		{
+			BgProgressCheck *bg_check_data = (BgProgressCheck *)malloc(sizeof(BgProgressCheck));
+			memset(bg_check_data, 0, sizeof(BgProgressCheck));
+			bg_check_data->split_pkg_data = pkg_data;
+			bg_check_data->archive_pkg_data = nullptr;
+			bg_check_data->task_id = task_id;
+			bg_check_data->hash = hash;
+			ret = pthread_create(&bk_install_thid, NULL, CheckBgInstallTaskThread, bg_check_data);
+			return 1;
+		}
+		ret = 1;
+	finish:
+		pkg_data->stop_write_thread = true;
+		pkg_data->split_file->Close();
+		pthread_join(pkg_data->thread, NULL);
+		delete (pkg_data->split_file);
+		if (pkg_data->delete_client)
+			delete (pkg_data->remote_client);
+		free(pkg_data);
+		RemoveSplitPkgInstallData(hash);
+		activity_inprogess = false;
+		file_transfering = false;
+		Windows::SetModalMode(false);
+		return ret;
+	}
 }
@@ -129,6 +129,17 @@ struct ArchivePkgInstallData
    bool stop_write_thread;
 };

+struct SplitPkgInstallData
+{
+    SplitFile *split_file;
+    RemoteClient *remote_client;
+    std::string path;
+    int64_t size;
+    pthread_t thread;
+    bool stop_write_thread;
+    bool delete_client;
+};
+
 static pthread_t bk_install_thid;

 namespace INSTALLER
@@ -149,4 +160,8 @@ namespace INSTALLER
    void AddArchivePkgInstallData(const std::string &hash, ArchivePkgInstallData *pkg_data);
    void RemoveArchivePkgInstallData(const std::string &hash);
    bool InstallArchivePkg(const std::string &path, ArchivePkgInstallData* pkg_data, bool bg = false);
+    SplitPkgInstallData *GetSplitPkgInstallData(const std::string &hash);
+    void AddSplitPkgInstallData(const std::string &hash, SplitPkgInstallData *pkg_data);
+    void RemoveSplitPkgInstallData(const std::string &hash);
+    bool InstallSplitPkg(const std::string &path, SplitPkgInstallData* pkg_data, bool bg = false);
 }
@@ -172,6 +172,11 @@ char lang_strings[LANG_STRINGS_NUM][LANG_STR_SIZE] = {
 	"Temp Directory",																				  // STR_TEMP_DIRECTORY
 	"Real-Debrid",																					  // STR_REALDEBRID
 	"Package install is running in the background. Don't close the app while install is in progress", // STR_BACKGROUND_INSTALL_INPROGRESS
+	"Enable disk caching. Can improve package install speed in cases where connection to remote is slow, but breaks resuming of install",          // STR_ENABLE_DISC_CACHE_MSG
+	"DC",                                                                                             // STR_ENABLE_DISK_CACHE
+	"Install Via AllDebrid",                                                                          // STR_ENABLE_ALLDEBRID_MSG
+	"Install Via RealDebrid",                                                                         // STR_ENABLE_REALDEBRID_MSG
+	"Enable Disk Cache",                                                                              // STR_ENABLE_DISKCACHE_DESC
 };

 bool needs_extended_font = false;
@@ -165,7 +165,12 @@
 	FUNC(STR_LANGUAGE)                      \
 	FUNC(STR_TEMP_DIRECTORY)                \
 	FUNC(STR_REALDEBRID)                    \
-	FUNC(STR_BACKGROUND_INSTALL_INPROGRESS)
+	FUNC(STR_BACKGROUND_INSTALL_INPROGRESS) \
+	FUNC(STR_ENABLE_DISC_CACHE_MSG)         \
+	FUNC(STR_ENABLE_DISK_CACHE)             \
+	FUNC(STR_ENABLE_ALLDEBRID_MSG)          \
+	FUNC(STR_ENABLE_REALDEBRID_MSG)         \
+	FUNC(STR_ENABLE_DISKCACHE_DESC)

 #define GET_VALUE(x) x,
 #define GET_STRING(x) #x,
@@ -175,7 +180,7 @@ enum
 	FOREACH_STR(GET_VALUE)
 };

-#define LANG_STRINGS_NUM 162
+#define LANG_STRINGS_NUM 167
 #define LANG_ID_SIZE 64
 #define LANG_STR_SIZE 384
 extern char lang_identifiers[LANG_STRINGS_NUM][LANG_ID_SIZE];
@@ -139,41 +139,43 @@ void InitImgui()
 	sceSystemServiceParamGetInt( ORBIS_SYSTEM_SERVICE_PARAM_ID_LANG, &lang_idx );

 	lang = Util::Trim(lang, " ");
-	if (lang.compare("Korean") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_KOREAN))
+	bool use_system_lang = lang.empty() || lang.compare("Default") == 0;
+
+	if (lang.compare("Korean") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_KOREAN))
 	{
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, NULL, io.Fonts->GetGlyphRangesKorean());
 	}
-	else if (lang.compare("Simplified Chinese") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_CHINESE_S))
+	else if (lang.compare("Simplified Chinese") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_CHINESE_S))
 	{
 		ImFontConfig config;
 		config.OversampleH = 1;
 		config.OversampleV = 1;
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, &config, io.Fonts->GetGlyphRangesChineseFull());
 	}
-	else if (lang.compare("Traditional Chinese") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_CHINESE_T))
+	else if (lang.compare("Traditional Chinese") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_CHINESE_T))
 	{
 		ImFontConfig config;
 		config.OversampleH = 1;
 		config.OversampleV = 1;
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, &config, io.Fonts->GetGlyphRangesChineseFull());
 	}
-	else if (lang.compare("Japanese") == 0 || lang.compare("Ryukyuan") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_JAPANESE))
+	else if (lang.compare("Japanese") == 0 || lang.compare("Ryukyuan") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_JAPANESE))
 	{
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
 	}
-	else if (lang.compare("Thai") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_THAI))
+	else if (lang.compare("Thai") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_THAI))
 	{
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, NULL, io.Fonts->GetGlyphRangesThai());
 	}
-	else if (lang.compare("Vietnamese") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_VIETNAMESE))
+	else if (lang.compare("Vietnamese") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_VIETNAMESE))
 	{
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, NULL, io.Fonts->GetGlyphRangesVietnamese());
 	}
-	else if (lang.compare("Greek") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_GREEK))
+	else if (lang.compare("Greek") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_GREEK))
 	{
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, NULL, io.Fonts->GetGlyphRangesGreek());
 	}
-	else if (lang.compare("Arabic") == 0 || (lang.empty() && lang_idx == ORBIS_SYSTEM_PARAM_LANG_ARABIC))
+	else if (lang.compare("Arabic") == 0 || (use_system_lang && lang_idx == ORBIS_SYSTEM_PARAM_LANG_ARABIC))
 	{
 		io.Fonts->AddFontFromFileTTF("/app0/assets/fonts/Roboto_ext.ttf", 26.0f, NULL, arabic);
 	}
@@ -10,6 +10,7 @@
 #include "clients/nfsclient.h"
 #include "clients/webdav.h"
 #include "clients/apache.h"
+#include "clients/archiveorg.h"
 #include "clients/iis.h"
 #include "clients/nginx.h"
 #include "clients/npxserve.h"
@@ -23,7 +24,6 @@
 #include "zip_util.h"
 #include "util.h"
 #include "installer.h"
-// #include "dbglogger.h"

 #define SERVER_CERT_FILE "/app0/assets/certs/domain.crt"
 #define SERVER_PRIVATE_KEY_FILE "/app0/assets/certs/domain.key"
@@ -250,6 +250,8 @@ namespace HttpServer
                tmp_client = new NpxServeClient();
            else if (strcmp(remote_settings->http_server_type, HTTP_SERVER_RCLONE) == 0)
                tmp_client = new RCloneClient();
+            else if (strcmp(remote_settings->http_server_type, HTTP_SERVER_ARCHIVEORG) == 0)
+                tmp_client = new ArchiveOrgClient();
        }

        if (tmp_client->clientType() != CLIENT_TYPE_GOOGLE)
@@ -1169,12 +1171,75 @@ namespace HttpServer
                    });
            } });

+        svr->Get("/split_inst/(.*)", [&](const Request &req, Response &res)
+        {
+            std::string hash = req.matches[1];
+
+            SplitPkgInstallData *pkg_data = INSTALLER::GetSplitPkgInstallData(hash);
+
+            if (pkg_data == nullptr)
+            {
+                failed(res, 500, "Cannot resume split_inst");
+                return;
+            }
+
+            if (req.method == "HEAD")
+            {
+                res.status = 204;
+                res.set_header("Content-Length", std::to_string(pkg_data->size));
+                res.set_header("Accept-Ranges", "bytes");
+                return;
+            }
+
+            if (req.ranges.empty())
+            {
+                res.status = 200;
+                res.set_content_provider(
+                    131072, "application/octet-stream",
+                    [pkg_data](size_t offset, size_t length, DataSink &sink) {
+                        char *buf = (char*) malloc(131072);
+                        size_t bytes_read = pkg_data->split_file->Read(buf, 131072, offset);
+                        sink.write(buf, bytes_read);
+                        free(buf);
+                        return true;
+                    },
+                    [](bool success) {
+                        return true;
+                    });
+            }
+            else
+            {
+                res.status = 206;
+                size_t range_len = (req.ranges[0].second - req.ranges[0].first) + 1;
+                if (req.ranges[0].second >= 18000000000000000000ul)
+                {
+                    range_len = PKG_INITIAL_REQUEST_SIZE;
+                    res.set_header("Content-Length", std::to_string(range_len));
+                    res.set_header("Content-Range", std::string("bytes ") + std::to_string(req.ranges[0].first)+"-" + std::to_string(req.ranges[0].first+PKG_INITIAL_REQUEST_SIZE-1) + "/"+std::to_string(range_len));
+                    sceRtcGetCurrentTick(&prev_tick);
+                }
+                std::pair<ssize_t, ssize_t> range = req.ranges[0];
+                res.set_content_provider(
+                    range_len, "application/octet-stream",
+                    [pkg_data, range, range_len](size_t offset, size_t length, DataSink &sink) {
+                        char *buf = (char*) malloc(range_len);
+                        size_t bytes_read = pkg_data->split_file->Read(buf, range_len, range.first);
+                        sink.write(buf, bytes_read);
+                        free(buf);
+                        return true;
+                    },
+                    [](bool success) {
+                        return true;
+                    });
+            } });
+
        svr->Post("/__local__/install_url", [&](const Request &req, Response &res)
                  {
            std::string url;
            const char *url_param;
            bool use_alldebrid = false;
            bool use_realdebrid = false;
+            bool use_disk_cache = false;

            json_object *jobj = json_tokener_parse(req.body.c_str());
            if (jobj != nullptr)
@@ -1182,6 +1247,8 @@ namespace HttpServer
                url_param = json_object_get_string(json_object_object_get(jobj, "url"));
                use_alldebrid  = json_object_get_boolean(json_object_object_get(jobj, "use_alldebrid"));
                use_realdebrid = json_object_get_boolean(json_object_object_get(jobj, "use_realdebrid"));
+                use_disk_cache = json_object_get_boolean(json_object_object_get(jobj, "use_disk_cache"));
+
                if (url_param == nullptr)
                {
                    bad_request(res, "Required url_param parameter missing");
@@ -1228,7 +1295,6 @@ namespace HttpServer
                Windows::SetModalMode(true);
                return;
            }
-
            delete(filehost);

 			size_t scheme_pos = download_url.find("://");
@@ -1242,20 +1308,53 @@ namespace HttpServer
            baseclient->Head(path, &header, sizeof(pkg_header));

            if (BE32(header.pkg_magic) == 0x7F434E54)
-            {            
+            {
+                bytes_to_download = header.pkg_content_size;
                FileHost::AddCacheDownloadUrl(hash, download_url);
                std::string title = INSTALLER::GetRemotePkgTitle(baseclient, path, &header);
-                delete(baseclient);

-                std::string remote_install_url = std::string("http://localhost:") + std::to_string(http_server_port) + "/rmt_inst/Site%2099/" + hash;
-                int rc = INSTALLER::InstallRemotePkg(remote_install_url, &header, title, false);
-                if (rc == 0)
+                if (!use_disk_cache)
                {
-                    failed(res, 200, lang_strings[STR_FAIL_INSTALL_FROM_URL_MSG]);
-                    activity_inprogess = false;
-                    file_transfering = false;
-                    Windows::SetModalMode(true);
-                    return;
+                    std::string remote_install_url = std::string("http://localhost:") + std::to_string(http_server_port) + "/rmt_inst/Site%2099/" + hash;
+                    int rc = INSTALLER::InstallRemotePkg(remote_install_url, &header, title, false);
+                    if (rc == 0)
+                    {
+                        failed(res, 200, lang_strings[STR_FAIL_INSTALL_FROM_URL_MSG]);
+                        activity_inprogess = false;
+                        file_transfering = false;
+                        Windows::SetModalMode(true);
+                        return;
+                    }
+                }
+                else
+                {
+                    SplitPkgInstallData *install_data = (SplitPkgInstallData*) malloc(sizeof(SplitPkgInstallData));
+                    memset(install_data, 0, sizeof(SplitPkgInstallData));
+
+                    OrbisTick tick;
+                    sceRtcGetCurrentTick(&tick);
+                    std::string install_pkg_path = std::string(temp_folder) + "/" + std::to_string(tick.mytick) + ".pkg";
+                    SplitFile *sp = new SplitFile(install_pkg_path, INSTALL_ARCHIVE_PKG_SPLIT_SIZE/2);
+
+                    install_data->split_file = sp;
+                    install_data->remote_client = baseclient;
+                    install_data->path = path;
+                    baseclient->Size(path, &install_data->size);
+                    install_data->stop_write_thread = false;
+                    install_data->delete_client = true;
+
+                    int ret = pthread_create(&install_data->thread, NULL, Actions::DownloadSplitPkg, install_data);
+
+                    ret = INSTALLER::InstallSplitPkg(download_url, install_data, true);
+
+                    if (ret == 0)
+                    {
+                        failed(res, 200, lang_strings[STR_FAIL_INSTALL_FROM_URL_MSG]);
+                        activity_inprogess = false;
+                        file_transfering = false;
+                        Windows::SetModalMode(false);
+                        return;
+                    }
                }
            }
            else
@@ -1282,6 +1381,7 @@ namespace HttpServer
                        failed(res, 200, lang_strings[STR_FAIL_INSTALL_FROM_URL_MSG]);
                        activity_inprogess = false;
                        file_transfering = false;
+                        free(install_data);
                        Windows::SetModalMode(false);
                        return;
                    }
@@ -155,7 +155,7 @@ size_t SplitFile::Write(char *buf, size_t buf_size)
    size_t total_bytes_written = 0;
    size_t remaining_to_write = buf_size;

-    while (remaining_to_write > 0)
+    while (remaining_to_write > 0 && !this->complete)
    {
        block_space_remaining = this->block_size - block_in_progress->size;
        bytes_to_write = MIN(remaining_to_write, block_space_remaining);
@@ -192,6 +192,9 @@ size_t SplitFile::Write(char *buf, size_t buf_size)

 int SplitFile::Close()
 {
+    if (this->complete)
+        return 0;
+
    if (block_in_progress->fd != nullptr)
    {
        fflush(block_in_progress->fd);
@@ -207,6 +210,11 @@ int SplitFile::Close()
    return 0;
 }

+bool SplitFile::IsClosed()
+{
+    return this->complete;
+}
+
 FileBlock *SplitFile::NewBlock()
 {
    FileBlock *block = (FileBlock *)malloc(sizeof(FileBlock));
@@ -31,6 +31,7 @@ public:
    size_t Write(char* buf, size_t buf_size);
    int Open();
    int Close();
+    bool IsClosed();

 private:
    std::vector<FileBlock*> file_blocks;
@@ -327,11 +327,13 @@ namespace Windows
        if (ImGui::BeginCombo("##Site", display_site, ImGuiComboFlags_PopupAlignLeft | ImGuiComboFlags_HeightLargest | ImGuiComboFlags_NoArrowButton))
        {
            static char site_id[64];
+            static char site_display[512];
            for (int n = 0; n < sites.size(); n++)
            {
                const bool is_selected = strcmp(sites[n].c_str(), last_site) == 0;
                sprintf(site_id, "%s %d", lang_strings[STR_SITE], n + 1);
-                if (ImGui::Selectable(site_id, is_selected))
+                sprintf(site_display, "%s %d    %s", lang_strings[STR_SITE], n + 1, site_settings[sites[n]].server);
+                if (ImGui::Selectable(site_display, is_selected))
                {
                    sprintf(last_site, "%s", sites[n].c_str());
                    sprintf(display_site, "%s", site_id);
@@ -448,13 +450,33 @@ namespace Windows
        }
        if (ImGui::IsItemHovered())
        {
-            ImGui::SetNextWindowSize(ImVec2(450, 70));
+            ImGui::SetNextWindowSize(ImVec2(450, 110));
            ImGui::BeginTooltip();
            ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + 440);
            ImGui::Text("%s", lang_strings[STR_ENABLE_RPI_FTP_SMB_MSG]);
            ImGui::PopTextWrapPos();
            ImGui::EndTooltip();
        }
+
+        ImGui::SameLine();
+        ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 5);
+        ImGui::TextColored(colors[ImGuiCol_ButtonHovered], "%s:", lang_strings[STR_ENABLE_DISK_CACHE]);
+        ImGui::SameLine();
+
+        if (ImGui::Checkbox("###enable_disk_cache", &remote_settings->enable_disk_cache))
+        {
+            CONFIG::SaveConfig();
+        }
+        if (ImGui::IsItemHovered())
+        {
+            ImGui::SetNextWindowSize(ImVec2(550, 110));
+            ImGui::BeginTooltip();
+            ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + 540);
+            ImGui::Text("%s", lang_strings[STR_ENABLE_DISC_CACHE_MSG]);
+            ImGui::PopTextWrapPos();
+            ImGui::EndTooltip();
+        }
+
        ImGui::PopStyleVar();

        ImGui::SameLine();
@@ -856,6 +878,23 @@ namespace Windows
        ImGui::Columns(1);
        ImGui::EndChild();
        EndGroupPanel();
+
+        if (ImGui::IsKeyPressed(ImGuiKey_C) && !paused)
+        {
+            if (selected_browser & LOCAL_BROWSER)
+            {
+                selected_local_file = local_files[0];
+                selected_action = ACTION_CHANGE_LOCAL_DIRECTORY;
+            }
+            else if (selected_browser & REMOTE_BROWSER)
+            {
+                if (remoteclient != nullptr && remote_files.size() > 0)
+                {
+                    selected_remote_file = remote_files[0];
+                    selected_action = ACTION_CHANGE_REMOTE_DIRECTORY;
+                }
+            }
+        }
    }

    void StatusPanel()
@@ -1417,7 +1456,7 @@ namespace Windows
                    progress = bytes_transfered * 1.0f / (float)bytes_to_download;
                    transfer_speed = (bytes_transfered * 1.0f / tick_delta) / 1048576.0f;

-                    sprintf(progress_text, "%.2fMB/s", transfer_speed);
+                    sprintf(progress_text, "%.2f MB/s", transfer_speed);
                    ImGui::ProgressBar(progress, ImVec2(625, 0), progress_text);
                }

@@ -1459,7 +1498,52 @@ namespace Windows
            {
                ImVec2 cur_pos = ImGui::GetCursorPos();
                char id[128];
-                if (ImGui::Button(lang_strings[STR_ONETIME_URL], ImVec2(535, 0)))
+                
+                ImGui::Checkbox("##enable_alldebrid_install_uril", &install_pkg_url.enable_alldebrid);
+                ImGui::SameLine();
+                ImGui::Text("%s", lang_strings[STR_ENABLE_ALLDEBRID_MSG]);
+
+                ImGui::SameLine();
+                ImGui::SetCursorPosX(ImGui::GetCursorPosX()+40);
+                ImGui::Checkbox("##enable_realdebrid_install_uril", &install_pkg_url.enable_realdebrid);
+                ImGui::SameLine();
+                ImGui::Text("%s", lang_strings[STR_ENABLE_REALDEBRID_MSG]);
+
+                ImGui::SameLine();
+                ImGui::SetCursorPosX(ImGui::GetCursorPosX()+40);
+                ImGui::Checkbox("##enable_rpi_install_url", &install_pkg_url.enable_rpi);
+                if (ImGui::IsItemHovered())
+                {
+                    ImGui::SetNextWindowSize(ImVec2(550, 110));
+                    ImGui::BeginTooltip();
+                    ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + 540);
+                    ImGui::Text("%s", lang_strings[STR_ENABLE_RPI_WEBDAV_MSG]);
+                    ImGui::PopTextWrapPos();
+                    ImGui::EndTooltip();
+                }
+                ImGui::SameLine();
+                ImGui::Text("%s", lang_strings[STR_ENABLE_RPI]);
+
+                if (install_pkg_url.enable_rpi)
+                {
+                    ImGui::SameLine();
+                    ImGui::SetCursorPosX(ImGui::GetCursorPosX()+40);
+                    ImGui::Checkbox("##enable_diskcache_install_uril", &install_pkg_url.enable_disk_cache);
+                    if (ImGui::IsItemHovered())
+                    {
+                        ImGui::SetNextWindowSize(ImVec2(550, 110));
+                        ImGui::BeginTooltip();
+                        ImGui::PushTextWrapPos(ImGui::GetCursorPos().x + 540);
+                        ImGui::Text("%s", lang_strings[STR_ENABLE_DISC_CACHE_MSG]);
+                        ImGui::PopTextWrapPos();
+                        ImGui::EndTooltip();
+                    }
+                    ImGui::SameLine();
+                    ImGui::Text("%s", lang_strings[STR_ENABLE_DISKCACHE_DESC]);
+                }
+
+                ImGui::Separator();
+                if (ImGui::Button(lang_strings[STR_ONETIME_URL], ImVec2(1070, 0)))
                {
                    ResetImeCallbacks();
                    sprintf(install_pkg_url.url, "%s", "");
@@ -1473,14 +1557,6 @@ namespace Windows
                    SetModalMode(false);
                    ImGui::CloseCurrentPopup();
                }
-                ImGui::SameLine();
-                sprintf(id, "%s##favoriteurl", lang_strings[STR_CANCEL]);
-                if (ImGui::Button(id, ImVec2(535, 0)))
-                {
-                    select_url_inprogress = false;
-                    SetModalMode(false);
-                    ImGui::CloseCurrentPopup();
-                }

                ImGui::Separator();
                for (int j = 0; j < MAX_FAVORITE_URLS; j++)
@@ -1528,6 +1604,13 @@ namespace Windows
                    }
                }

+                if (ImGui::IsKeyPressed(ImGuiKey_GamepadFaceRight, false))
+                {
+                    select_url_inprogress = false;
+                    SetModalMode(false);
+                    ImGui::CloseCurrentPopup();
+                }
+
                ImGui::EndPopup();
            }
        }
@@ -2556,6 +2639,14 @@ namespace Windows
        if (ime_result == IME_DIALOG_RESULT_FINISHED)
        {
            CONFIG::SetClientType(remote_settings);
+            if (strncasecmp(remote_settings->server, "https://archive.org/", 20) == 0)
+            {
+                sprintf(remote_settings->http_server_type, "%s", HTTP_SERVER_ARCHIVEORG);
+            }
+            else if (strncasecmp(remote_settings->server, "https://myrient.erista.me/", 26) == 0)
+            {
+                sprintf(remote_settings->http_server_type, "%s", HTTP_SERVER_MYRIENT);
+            }
        }
    }

@@ -290,7 +290,7 @@ namespace ZipUtil
    static int extract2fd(struct archive *a, const std::string &pathname, int fd)
    {
        ssize_t len;
-        unsigned char *buffer = (unsigned char *) malloc(ARCHIVE_TRANSFER_SIZE);
+        unsigned char *buffer = (unsigned char *)malloc(ARCHIVE_TRANSFER_SIZE);
        bytes_transfered = 0;
        sceRtcGetCurrentTick(&prev_tick);

@@ -312,7 +312,7 @@ namespace ZipUtil
                return 0;
            }
            bytes_transfered += len;
-            
+
            if (write(fd, buffer, len) != len)
            {
                sprintf(status_message, "error write('%s')", pathname.c_str());
@@ -479,7 +479,7 @@ namespace ZipUtil
            ret = data->client->GetRange((data->fp), data->buf, to_read, data->offset);
        else
            ret = data->client->GetRange(data->path, data->buf, to_read, data->offset);
-        
+
        if (ret == 0)
            return -1;
        data->offset = data->offset + to_read;
@@ -521,7 +521,7 @@ namespace ZipUtil
        return data->offset;
    }

-    int64_t	SkipRemoteArchive(struct archive *, void *client_data, int64_t request)
+    int64_t SkipRemoteArchive(struct archive *, void *client_data, int64_t request)
    {
        RemoteArchiveData *data = (RemoteArchiveData *)client_data;

@@ -529,7 +529,7 @@ namespace ZipUtil

        return request;
    }
-    
+
    /*
     * Main loop: open the zipfile, iterate over its contents and decide what
     * to do with each entry.
@@ -577,10 +577,6 @@ namespace ZipUtil
            ret = archive_read_open2(a, client_data, NULL, ReadRemoteArchive, SkipRemoteArchive, CloseRemoteArchive);
            if (ret < ARCHIVE_OK)
            {
-                if (client_data != nullptr)
-                {
-                    free(client_data);
-                }
                sprintf(status_message, "%s", "archive_read_open failed");
                return 0;
            }
@@ -622,7 +618,10 @@ namespace ZipUtil
        int ret;

        if ((a = archive_read_new()) == NULL)
+        {
            sprintf(status_message, "%s", "archive_read_new failed");
+            return nullptr;
+        }

        archive_read_support_format_all(a);
        archive_read_support_filter_all(a);
@@ -656,10 +655,6 @@ namespace ZipUtil
            ret = archive_read_open2(a, client_data, NULL, ReadRemoteArchive, SkipRemoteArchive, CloseRemoteArchive);
            if (ret < ARCHIVE_OK)
            {
-                if (client_data != nullptr)
-                {
-                    free(client_data);
-                }
                sprintf(status_message, "%s", "archive_read_open_filename failed");
                return nullptr;
            }
@@ -672,16 +667,14 @@ namespace ZipUtil
            if (ret < ARCHIVE_OK)
            {
                sprintf(status_message, "%s", "archive_read_next_header failed");
-                if (client_data != nullptr)
-                {
-                    free(client_data);
-                }
                archive_read_free(a);
                return nullptr;
            }

            if (ret == ARCHIVE_EOF)
+            {
                break;
+            }

            if ((pathname = pathdup(archive_entry_pathname(e))) == NULL)
            {
@@ -750,10 +743,6 @@ namespace ZipUtil
            if (ret < ARCHIVE_OK)
            {
                sprintf(status_message, "%s", "archive_read_next_header failed");
-                if (client_data != nullptr)
-                {
-                    free(client_data);
-                }
                archive_read_free(a);
                return nullptr;
            }
@@ -10,7 +10,7 @@
 #include "common.h"
 #include "fs.h"

-#define ARCHIVE_TRANSFER_SIZE 5242880
+#define ARCHIVE_TRANSFER_SIZE 20971520

 static uint8_t MAGIC_ZIP_1[4] = {0x50, 0x4B, 0x03, 0x04};
 static uint8_t MAGIC_ZIP_2[4] = {0x50, 0x4B, 0x05, 0x06};
Author	SHA1	Message	Date
Chee Yee	a71bd1eb28	enchancements to install from url	2024-10-08 20:50:42 -07:00
Chee Yee	0a1420dd96	add support for myrient.erista.me website	2024-07-20 02:45:52 -07:00
Chee Yee	dcdc1fc54b	use spaces for separator, seems less overcrowded	2024-07-16 21:27:12 -07:00
Chee Yee	5c254589e6	Merge branch 'master' of github.com:cy33hc/ps4-ezremote-client	2024-07-16 20:59:32 -07:00
Chee Yee	2b25272379	display server url in the sites drop down to easily identify site	2024-07-16 20:59:23 -07:00
cy33hc	6b66d39eba	Update README.md	2024-07-16 10:42:18 -07:00
Chee Yee	b143c3e3c5	add archive org screenshot	2024-07-15 19:15:25 -07:00
Chee Yee	c3cc6d5954	add screenshots for archive org retrieve download URL	2024-07-15 15:02:55 -07:00
Chee Yee	cfcb420b9d	add support for archive.org	2024-07-14 01:54:54 -07:00
Chee Yee	294455c735	add ability to use L2 button to navigate back to previous directory	2024-07-13 19:40:20 -07:00
Chee Yee	4ff119b34d	fix crash on failed install split pkg	2024-07-03 09:12:49 -07:00
Chee Yee	114c1974e1	enable disk caching for all remote types	2024-06-28 02:26:03 -07:00
Chee Yee	a99bf163d8	implement download to split_file for all remote clients	2024-06-28 00:35:02 -07:00
Chee Yee	b9ab71577f	fix crash installing from real-debrid webdav	2024-06-27 22:04:06 -07:00
Chee Yee	f80b3112c6	increase archive read buffer size to improve extraction speed	2024-06-27 11:11:33 -07:00
Chee Yee	e0c72c85e5	fix crash while error reading from archive	2024-06-27 11:10:56 -07:00
Chee Yee	01f568feac	update javascript	2024-06-27 00:55:57 -07:00
Chee Yee	2046a0e096	add disk cache option for installing from WebUi	2024-06-26 21:33:47 -07:00
Chee Yee	49f535dfde	set the proper start time when overwrite prompt	2024-06-16 21:19:02 -07:00