mirror of
https://github.com/simplex-chat/simplex-chat.git
synced 2026-11-22 17:48:15 +00:00
* WIP: Haskell impl of resizeImageToStrSize * WIP: add FFI export wrapper * WIP: switch ios resizeImageToStrSizeSync to backend * WIP: fix resizeImageToStrSizeSync * WIP: add JNI wrappers * Add non-base64 resize and cWriteImage * WIP: add chat_write_image * fix resizeToStr * fixes * fix syntax, raise jpeg quality back * add chatWriteImage * Fix cfArgs in tests * Use jpeg-turbo encoder * add nix pins * bump jpeg-turbo * add CI deps * add encoding funs to android lib * bump jpeg-turbo for 20.04 fix * jpeg-turbo fix for 8.10 * android fixes * Bump jpeg-turbo * set static flag for jpeg-turbo * Fix nix for aarch64/android * Fix android C api * Fix resize in android * Bump hs-libjpeg-turbo * target correct override * override android lib from android pkgs * add macos build tweaks * bump hs-jpeg-turbo for 8.10 fixes * more build fixes * make ios compile * Always use pkgconfig for libjpeg-turbo * WIP: debug libjpeg in ubuntu pkg-config CI * Add pkg-config to dockerfiles * Add libturbojpeg to dockerfiles * Use -dev version of libturbojpeg in dockerfiles * Install pkg-config in windows CI * Disable flag for custom libturbojpeg linking options Workarounds relocation error on x86_64-linux with gcc: /usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/libturbojpeg.a(turbojpeg.c.o): relocation R_X86_64_TPOFF32 against `errStr' can not be used when making a shared object; recompile with -fPIC /usr/bin/ld: failed to set dynamic section sizes: bad value * WIP: debug libjpeg in windows pkg-config CI * WIP: debug libjpeg package in windows CI * core: image resize module and buffer FFI * ci: link libjpeg-turbo statically on all platforms * ui: resize images in the core * core: rename image resize functions to chat_resize_image and chat_resize_image_uri * ci: restore whitespace in build.yml * ci: build libjpeg-turbo 3.1.4.1 from a submodule * core: hs-jpeg-turbo from github.com/simplex-chat * nodejs: resize images * python: resize images * core: hs-jpeg-turbo from gitlab.com, the GitHub import lacks LFS objects * core: generate /img previews * ci: link libjpeg-turbo on Windows without pkg-config * ci: build libjpeg-turbo on Windows with the GHC toolchain * docs: plan for image resizing in the core * docs: update image resizing plan * ios: prevent crash when wallpaper image cannot be resized * android, desktop: raise an error when an image cannot be resized * docs: update spec references for image resizing * docker: build the CLI image from a clone without submodules * docs: apply review fixes to image resizing plan * docker: build the CLI from a git worktree with the submodule present * docs: apply second review to image resizing plan * docs: point image resizing plan at the rewritten commit * core: choose image format by transparency in chat_resize_image * nodejs: resize images to the app sizes * python: resize images to the app sizes * nodejs, python: describe the core modules as used for image resizing * docs: add license notices of the image libraries * ci: describe the avatar method without attributing it to the apps * ci, ios, nix: remove the libjpeg-turbo build outside cabal * python: name resize_image in the core module text * nodejs, python: describe resizing to the app image sizes * core: refuse images larger than the supported size * core: resize to JPEG images with a side above 65500 pixels * docs: record image resizing decisions for the bundled libjpeg-turbo * core, docs: build libjpeg-turbo and stb from the fork submodules * docs: record the fork pins in the image resizing plan * core: resize images to at most 4320 pixels per side, refuse above 16384 * docs: record the image side limits in the image resizing plan * core: pin the rebased hs-jpeg-turbo fork * core: pin the hs-jpeg-turbo fork without package.yaml * docs: plan scaled JPEG decoding and EXIF orientation of images * docs: copy the JuicyPixels-stbir licence of the pinned fork * core: pin the hs-jpeg-turbo fork with scaled JPEG decoding * core: decode JPEG at the display size, up to 65500 pixels per side * core: rotate JPEG images by their EXIF orientation * docs: refer the image plan to the JPEG decoding code * docs: record the approved image processing decisions * core: limit JPEG decoding memory to 1024 MB outside iOS and Android * docs: name JPEG decoding in the libjpeg-turbo notice * docs: plan image resizing from files and the decisions of 26 Oct * core: scale images in one Catmull-Rom pass with sharpening * docs: plan image sizes at a fixed quality * core: resize images at a fixed quality to fill the size limit * core: resize images from a file path or a file descriptor * ios, android, desktop: resize picked images from their files * core: encode resized images with mozjpeg * tests: check descriptor closing by the file it refers to * core: raise JPEG quality only for a full-size image below 97% of the limit * ci: name the mozjpeg submodule in the Windows cleanup comments * docs: refer the image plan to the current code * docs: refer the image plan to the code merged with master * core: export every image resizing function from each library * core: close the file descriptor when its handle cannot be created * docs: count the C sources of mozjpeg with the arithmetic decoder * core: use the reviewed hs-jpeg-turbo and JuicyPixels-stbir forks * ci: build the armv7a Android core library on request * core: round image heights half up in the size search * ios: describe the file image resizing functions in SimpleX.h * ci: pick, preview and send images in the Claude app tests * core: decode PNG images with libspng and refuse other formats * core: encode PNG with libspng, keeping the smaller filter choice * ci: pick, preview and send images in the scripted app smoke tests * flake: build the PNG decoder package in nix builds * ios: remove the copy of a picked image after sending it * core: refuse image files larger than the decode memory limit * core: scale a JPEG image to its largest size once per resize * core: bisect JPEG quality without a step function * core: reduce the memory used to sharpen and to decode PNG images * android, desktop: pass the image format to the core as an integer * android, desktop: fuse the preview conditions of picked media * android, desktop, ci: check that the core resized the smoke test images * python: remove the docstrings of the explicit image resizing functions * docs: add the second review fixes to the image plan * ci: tap the iOS attachment button by its accessibility label * core: keep the colour profiles of resized images * docs: add the colour profiles to the image plan * ci: wait up to 30 s for the new group screens in the iOS smoke test * ci: pick the Android smoke test images from their own photo folders * ci: tap the iOS photo picker by position, as its tree is not shown * ci: pick the test card and the logo by their iOS picker positions * core: update JuicyPixels-stbir with the stb_image_resize licence terms * core: write a fixed Display P3 profile for Display P3 images only * core: do not keep the input image in memory for its colour profile * core: read the JPEG segments once for the orientation and the profile * core: read an image file into one buffer of its size * docs: add the third review fixes to the image plan * core: resize images with Display P3 or no profile, not profile bytes * ci: check the pixel sizes of the images sent in the iOS smoke test * core: update hs-jpeg-turbo with PNG chunk limits and encoder fixes * docs: list Compact ICC Profiles, libspng and miniz in the dependencies * android, desktop: reword the picked media preview comment * docs: refer the image plan to the code merged with master * ci: render the iOS snapshots before the images case * ci: dismiss the snapshot tests' camera alert before the iOS images case * core: update hs-jpeg-turbo with tests and the JuicyPixels-spng synopsis * core: pin hs-jpeg-turbo and JuicyPixels-stbir in simplex-chat repositories * update ios core library * core, ui: accept only JPEG and PNG image data * core: update JuicyPixels-stbir * docs: plan for the iOS copy of picked images --------- Co-authored-by: IC Rainbow <aenor.realm@gmail.com> Co-authored-by: Evgeny Poberezkin <evgeny@poberezkin.com> Co-authored-by: Alexandre Esteves <alexfmpe@proton.me>
436 lines
18 KiB
Haskell
436 lines
18 KiB
Haskell
{-# LANGUAGE CPP #-}
|
|
{-# LANGUAGE DuplicateRecordFields #-}
|
|
{-# LANGUAGE GADTs #-}
|
|
{-# LANGUAGE LambdaCase #-}
|
|
{-# LANGUAGE NamedFieldPuns #-}
|
|
{-# LANGUAGE OverloadedStrings #-}
|
|
{-# LANGUAGE TemplateHaskell #-}
|
|
{-# LANGUAGE TypeApplications #-}
|
|
{-# OPTIONS_GHC -fobject-code #-}
|
|
|
|
module Simplex.Chat.Mobile where
|
|
|
|
import Control.Concurrent.STM
|
|
import Control.Exception (SomeException, catch)
|
|
import Control.Monad
|
|
import Control.Monad.Except
|
|
import Control.Monad.Reader
|
|
import Data.Aeson (ToJSON (..))
|
|
import qualified Data.Aeson as J
|
|
import qualified Data.Aeson.TH as JQ
|
|
import Data.Bifunctor (first)
|
|
import qualified Data.ByteString.Base64.URL as U
|
|
import Data.ByteString.Char8 (ByteString)
|
|
import qualified Data.ByteString.Char8 as B
|
|
import qualified Data.ByteString.Lazy.Char8 as LB
|
|
import Data.Functor (($>))
|
|
import Data.List (find)
|
|
import qualified Data.List.NonEmpty as L
|
|
import Data.Maybe (fromMaybe)
|
|
import Data.Text (Text)
|
|
import Data.Text.Encoding (encodeUtf8)
|
|
import Data.Word (Word8)
|
|
import Foreign.C.String
|
|
import Foreign.C.Types (CInt (..))
|
|
import Foreign.Ptr
|
|
import Foreign.StablePtr
|
|
import Foreign.Storable (poke)
|
|
import GHC.IO.Encoding (setFileSystemEncoding, setForeignEncoding, setLocaleEncoding)
|
|
import Numeric.Natural (Natural)
|
|
import Simplex.Chat
|
|
import Simplex.Chat.Badges.Code (badgeCodeText, parseBadgeCode)
|
|
import Simplex.Chat.Controller
|
|
import Simplex.Chat.Library.Commands
|
|
import Simplex.Chat.Markdown (parseUri, parsedMarkdown, sanitizeUri)
|
|
import Simplex.Chat.Mobile.Badges
|
|
import Simplex.Chat.Mobile.File
|
|
import Simplex.Chat.Mobile.Shared
|
|
import Simplex.Chat.Mobile.WebRTC
|
|
import Simplex.Chat.Options
|
|
import Simplex.Chat.Options.DB
|
|
import Simplex.Chat.Remote.Types
|
|
import Simplex.Chat.Store
|
|
import Simplex.Chat.Store.Profiles
|
|
import Simplex.Chat.Types
|
|
import Simplex.Messaging.Agent.Client (agentClientStore)
|
|
import Simplex.Messaging.Agent.Env.SQLite (createAgentStore)
|
|
import Simplex.Messaging.Agent.Protocol (AgentErrorType)
|
|
import Simplex.Messaging.Agent.Store.Interface (closeDBStore, reopenDBStore)
|
|
import Simplex.Messaging.Agent.Store.Shared (MigrationConfig (..), MigrationConfirmation (..), MigrationError)
|
|
import qualified Simplex.Messaging.Crypto as C
|
|
import Simplex.Messaging.Encoding.String
|
|
import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, sumTypeJSON)
|
|
import Simplex.Messaging.Protocol (AProtoServerWithAuth (..), AProtocolType (..), BasicAuth (..), ProtoServerWithAuth (..), ProtocolServer (..))
|
|
import Simplex.Messaging.Util (catchAll, liftEitherWith, safeDecodeUtf8)
|
|
import System.IO (utf8)
|
|
import System.Timeout (timeout)
|
|
import qualified URI.ByteString as U
|
|
#if !defined(dbPostgres)
|
|
import Data.ByteArray (ScrubbedBytes)
|
|
import Database.SQLite.Simple (SQLError (..))
|
|
import qualified Database.SQLite.Simple as DB
|
|
import qualified Simplex.Messaging.Agent.Store.DB as DB
|
|
#endif
|
|
|
|
data DBMigrationResult
|
|
= DBMOk
|
|
| DBMInvalidConfirmation
|
|
| DBMInvalidQueueSize
|
|
| DBMErrorNotADatabase {dbFile :: String}
|
|
| DBMErrorMigration {dbFile :: String, migrationError :: MigrationError}
|
|
| DBMErrorSQL {dbFile :: String, migrationSQLError :: String}
|
|
| DBMAgentError {agentError :: AgentErrorType}
|
|
deriving (Show)
|
|
|
|
$(JQ.deriveToJSON (sumTypeJSON $ dropPrefix "DBM") ''DBMigrationResult)
|
|
|
|
data APIResult r
|
|
= APIResult {remoteHostId :: Maybe RemoteHostId, result :: r}
|
|
| APIError {remoteHostId :: Maybe RemoteHostId, error :: ChatError}
|
|
|
|
eitherToResult :: Maybe RemoteHostId -> Either ChatError r -> APIResult r
|
|
eitherToResult rhId = either (APIError rhId) (APIResult rhId)
|
|
{-# INLINE eitherToResult #-}
|
|
|
|
data ParsedUri = ParsedUri
|
|
{ uriInfo :: Maybe UriInfo,
|
|
parseError :: Text
|
|
}
|
|
|
|
data UriInfo = UriInfo
|
|
{ scheme :: Text,
|
|
sanitized :: Maybe Text
|
|
}
|
|
|
|
$(JQ.deriveJSON defaultJSON ''UriInfo)
|
|
|
|
$(JQ.deriveJSON defaultJSON ''ParsedUri)
|
|
|
|
$(pure [])
|
|
|
|
instance ToJSON r => ToJSON (APIResult r) where
|
|
toEncoding = $(JQ.mkToEncoding (defaultJSON {J.sumEncoding = J.UntaggedValue}) ''APIResult)
|
|
toJSON = $(JQ.mkToJSON (defaultJSON {J.sumEncoding = J.UntaggedValue}) ''APIResult)
|
|
|
|
foreign export ccall "chat_migrate_init" cChatMigrateInit :: CString -> CString -> CString -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
|
|
foreign export ccall "chat_migrate_init_key" cChatMigrateInitKey :: CString -> CString -> CInt -> CString -> CInt -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
|
|
foreign export ccall "chat_migrate_init_queue" cChatMigrateInitQueue :: CString -> CString -> CString -> CInt -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
|
|
foreign export ccall "chat_close_store" cChatCloseStore :: StablePtr ChatController -> IO CString
|
|
|
|
foreign export ccall "chat_reopen_store" cChatReopenStore :: StablePtr ChatController -> IO CString
|
|
|
|
foreign export ccall "chat_send_cmd" cChatSendCmd :: StablePtr ChatController -> CString -> IO CJSONString
|
|
|
|
foreign export ccall "chat_send_cmd_retry" cChatSendCmdRetry :: StablePtr ChatController -> CString -> CInt -> IO CJSONString
|
|
|
|
foreign export ccall "chat_send_remote_cmd" cChatSendRemoteCmd :: StablePtr ChatController -> CInt -> CString -> IO CJSONString
|
|
|
|
foreign export ccall "chat_send_remote_cmd_retry" cChatSendRemoteCmdRetry :: StablePtr ChatController -> CInt -> CString -> CInt -> IO CJSONString
|
|
|
|
foreign export ccall "chat_recv_msg" cChatRecvMsg :: StablePtr ChatController -> IO CJSONString
|
|
|
|
foreign export ccall "chat_recv_msg_wait" cChatRecvMsgWait :: StablePtr ChatController -> CInt -> IO CJSONString
|
|
|
|
foreign export ccall "chat_parse_markdown" cChatParseMarkdown :: CString -> IO CJSONString
|
|
|
|
foreign export ccall "chat_parse_server" cChatParseServer :: CString -> IO CJSONString
|
|
|
|
foreign export ccall "chat_parse_uri" cChatParseUri :: CString -> CInt -> IO CJSONString
|
|
|
|
foreign export ccall "chat_password_hash" cChatPasswordHash :: CString -> CString -> IO CString
|
|
|
|
foreign export ccall "chat_valid_name" cChatValidName :: CString -> IO CString
|
|
|
|
foreign export ccall "chat_parse_badge_code" cChatParseBadgeCode :: CString -> IO CString
|
|
|
|
foreign export ccall "chat_json_length" cChatJsonLength :: CString -> IO CInt
|
|
|
|
foreign export ccall "chat_badge_keygen" cChatBadgeKeygen :: IO CJSONString
|
|
|
|
foreign export ccall "chat_badge_issue" cChatBadgeIssue :: CString -> IO CJSONString
|
|
|
|
foreign export ccall "chat_encrypt_media" cChatEncryptMedia :: StablePtr ChatController -> CString -> Ptr Word8 -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_decrypt_media" cChatDecryptMedia :: CString -> Ptr Word8 -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_write_file" cChatWriteFile :: StablePtr ChatController -> CString -> Ptr Word8 -> CInt -> IO CJSONString
|
|
|
|
foreign export ccall "chat_read_file" cChatReadFile :: CString -> CString -> CString -> IO (Ptr Word8)
|
|
|
|
foreign export ccall "chat_encrypt_file" cChatEncryptFile :: StablePtr ChatController -> CString -> CString -> IO CJSONString
|
|
|
|
foreign export ccall "chat_decrypt_file" cChatDecryptFile :: CString -> CString -> CString -> CString -> IO CString
|
|
|
|
foreign export ccall "chat_resize_image_uri" cChatResizeImageUri :: Ptr Word8 -> CInt -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_resize_image" cChatResizeImage :: Ptr Word8 -> CInt -> CInt -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_resize_image_file_uri" cChatResizeImageFileUri :: CString -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_resize_image_file" cChatResizeImageFile :: CString -> CInt -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_resize_image_fd_uri" cChatResizeImageFdUri :: CInt -> CInt -> IO CString
|
|
|
|
foreign export ccall "chat_resize_image_fd" cChatResizeImageFd :: CInt -> CInt -> CInt -> IO CString
|
|
|
|
-- | check / migrate database and initialize chat controller on success
|
|
-- For postgres first param is schema prefix, second param is database connection string.
|
|
cChatMigrateInit :: CString -> CString -> CString -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
cChatMigrateInit fp key conf = cChatMigrateInitKey fp key 0 conf 0
|
|
|
|
-- For postgres first param is schema prefix, second param is database connection string.
|
|
cChatMigrateInitKey :: CString -> CString -> CInt -> CString -> CInt -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
cChatMigrateInitKey fp key keepKey conf background = cChatMigrateInit_ fp key (keepKey /= 0) conf (background /= 0) mobileQueueSize
|
|
|
|
-- | queueSize is the size of internal queues, same as terminal option --queue-size
|
|
cChatMigrateInitQueue :: CString -> CString -> CString -> CInt -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
cChatMigrateInitQueue fp key conf queueSize = cChatMigrateInit_ fp key False conf False (fromIntegral queueSize)
|
|
|
|
cChatMigrateInit_ :: CString -> CString -> Bool -> CString -> Bool -> Int -> Ptr (StablePtr ChatController) -> IO CJSONString
|
|
cChatMigrateInit_ fp key keepKey conf background queueSize ctrl = do
|
|
-- ensure we are set to UTF-8; iOS does not have locale, and will default to
|
|
-- US-ASCII all the time.
|
|
setLocaleEncoding utf8
|
|
setFileSystemEncoding utf8
|
|
setForeignEncoding utf8
|
|
|
|
chatDbOpts <- mobileDbOpts fp key
|
|
confirm <- peekCAString conf
|
|
r <-
|
|
chatMigrateInitKey chatDbOpts keepKey confirm background queueSize >>= \case
|
|
Right cc -> (newStablePtr cc >>= poke ctrl) $> DBMOk
|
|
Left e -> pure e
|
|
newCStringFromLazyBS $ J.encode r
|
|
|
|
cChatCloseStore :: StablePtr ChatController -> IO CString
|
|
cChatCloseStore cPtr = deRefStablePtr cPtr >>= chatCloseStore >>= newCAString
|
|
|
|
cChatReopenStore :: StablePtr ChatController -> IO CString
|
|
cChatReopenStore cPtr = do
|
|
c <- deRefStablePtr cPtr
|
|
newCAString =<< chatReopenStore c
|
|
|
|
-- | send command to chat
|
|
cChatSendCmd :: StablePtr ChatController -> CString -> IO CJSONString
|
|
cChatSendCmd cPtr cCmd = cChatSendCmdRetry cPtr cCmd 0
|
|
|
|
-- | send command to chat with retry count
|
|
cChatSendCmdRetry :: StablePtr ChatController -> CString -> CInt -> IO CJSONString
|
|
cChatSendCmdRetry cPtr cCmd cRetryNum = do
|
|
c <- deRefStablePtr cPtr
|
|
cmd <- B.packCString cCmd
|
|
newCStringFromLazyBS =<< chatSendRemoteCmdRetry c Nothing cmd (fromIntegral cRetryNum)
|
|
{-# INLINE cChatSendCmdRetry #-}
|
|
|
|
-- | send remote command to chat
|
|
cChatSendRemoteCmd :: StablePtr ChatController -> CInt -> CString -> IO CJSONString
|
|
cChatSendRemoteCmd cPtr cRhId cCmd = cChatSendRemoteCmdRetry cPtr cRhId cCmd 0
|
|
|
|
-- | send remote command to chat with retry count
|
|
cChatSendRemoteCmdRetry :: StablePtr ChatController -> CInt -> CString -> CInt -> IO CJSONString
|
|
cChatSendRemoteCmdRetry cPtr cRemoteHostId cCmd cRetryNum = do
|
|
c <- deRefStablePtr cPtr
|
|
cmd <- B.packCString cCmd
|
|
let rhId = Just $ fromIntegral cRemoteHostId
|
|
newCStringFromLazyBS =<< chatSendRemoteCmdRetry c rhId cmd (fromIntegral cRetryNum)
|
|
{-# INLINE cChatSendRemoteCmdRetry #-}
|
|
|
|
-- | receive message from chat (blocking)
|
|
cChatRecvMsg :: StablePtr ChatController -> IO CJSONString
|
|
cChatRecvMsg cc = deRefStablePtr cc >>= chatRecvMsg >>= newCStringFromLazyBS
|
|
|
|
-- | receive message from chat (blocking up to `t` microseconds (1/10^6 sec), returns empty string if times out)
|
|
cChatRecvMsgWait :: StablePtr ChatController -> CInt -> IO CJSONString
|
|
cChatRecvMsgWait cc t = deRefStablePtr cc >>= (`chatRecvMsgWait` fromIntegral t) >>= newCStringFromLazyBS
|
|
|
|
-- | parse markdown - returns ParsedMarkdown type JSON
|
|
cChatParseMarkdown :: CString -> IO CJSONString
|
|
cChatParseMarkdown s = newCStringFromLazyBS . chatParseMarkdown =<< B.packCString s
|
|
|
|
-- | parse server address - returns ParsedServerAddress JSON
|
|
cChatParseServer :: CString -> IO CJSONString
|
|
cChatParseServer s = newCStringFromLazyBS . chatParseServer =<< B.packCString s
|
|
|
|
-- | parse web URI - returns ParsedUri JSON
|
|
cChatParseUri :: CString -> CInt -> IO CJSONString
|
|
cChatParseUri s safe = newCStringFromLazyBS . chatParseUri (safe /= 0) =<< B.packCString s
|
|
|
|
cChatPasswordHash :: CString -> CString -> IO CString
|
|
cChatPasswordHash cPwd cSalt = do
|
|
pwd <- B.packCString cPwd
|
|
salt <- B.packCString cSalt
|
|
newCStringFromBS $ chatPasswordHash pwd salt
|
|
|
|
-- This function supports utf8 strings
|
|
cChatValidName :: CString -> IO CString
|
|
cChatValidName cName = newCString . mkValidName =<< peekCString cName
|
|
|
|
-- | canonical form of a code that passes its check character, empty string if it does not parse
|
|
cChatParseBadgeCode :: CString -> IO CString
|
|
cChatParseBadgeCode cCode = do
|
|
code <- safeDecodeUtf8 <$> B.packCString cCode
|
|
newCStringFromBS $ maybe "" (encodeUtf8 . badgeCodeText) $ parseBadgeCode code
|
|
|
|
-- | returns length of JSON encoded string
|
|
cChatJsonLength :: CString -> IO CInt
|
|
cChatJsonLength s = fromIntegral . subtract 2 . LB.length . J.encode . safeDecodeUtf8 <$> B.packCString s
|
|
|
|
mobileQueueSize :: Int
|
|
mobileQueueSize = 4096
|
|
|
|
mobileChatOpts :: ChatDbOpts -> Natural -> ChatOpts
|
|
mobileChatOpts dbOptions tbqSize =
|
|
ChatOpts
|
|
{ coreOptions =
|
|
CoreChatOpts
|
|
{ dbOptions,
|
|
smpServers = [],
|
|
xftpServers = [],
|
|
simpleNetCfg = defaultSimpleNetCfg,
|
|
logLevel = CLLImportant,
|
|
logConnections = False,
|
|
logServerHosts = True,
|
|
logAgent = Nothing,
|
|
logFile = Nothing,
|
|
tbqSize,
|
|
maxChats = 5000,
|
|
deviceName = Nothing,
|
|
chatRelay = False,
|
|
webPreviewConfig = Nothing,
|
|
chatRelayServer = Nothing,
|
|
headless = False,
|
|
highlyAvailable = False,
|
|
yesToUpMigrations = False,
|
|
migrationBackupPath = Just "",
|
|
maintenance = True
|
|
},
|
|
chatCmd = "",
|
|
chatCmdDelay = 3,
|
|
chatCmdLog = CCLNone,
|
|
chatServerPort = Nothing,
|
|
optFilesFolder = Nothing,
|
|
optTempDirectory = Nothing,
|
|
showReactions = False,
|
|
showFullLinks = False,
|
|
allowInstantFiles = True,
|
|
autoAcceptFileSize = 0,
|
|
muteNotifications = True,
|
|
markRead = False,
|
|
createBot = Nothing,
|
|
userDisplayName = Nothing,
|
|
userImageFile = Nothing
|
|
}
|
|
|
|
defaultMobileConfig :: ChatConfig
|
|
defaultMobileConfig =
|
|
defaultChatConfig
|
|
{ confirmMigrations = MCYesUp,
|
|
logLevel = CLLError,
|
|
deviceNameForRemote = "Mobile"
|
|
}
|
|
|
|
getActiveUser_ :: DBStore -> IO (Maybe User)
|
|
getActiveUser_ st = find activeUser <$> withTransaction st getUsers
|
|
|
|
#if !defined(dbPostgres)
|
|
-- only used in tests
|
|
chatMigrateInit :: String -> ScrubbedBytes -> String -> IO (Either DBMigrationResult ChatController)
|
|
chatMigrateInit dbFilePrefix dbKey confirm = do
|
|
let chatDBOpts = ChatDbOpts {dbFilePrefix, dbKey, trackQueries = DB.TQSlow 5000, vacuumOnMigration = True}
|
|
chatMigrateInitKey chatDBOpts False confirm False mobileQueueSize
|
|
#endif
|
|
|
|
chatMigrateInitKey :: ChatDbOpts -> Bool -> String -> Bool -> Int -> IO (Either DBMigrationResult ChatController)
|
|
chatMigrateInitKey chatDbOpts keepKey confirm backgroundMode queueSize = runExceptT $ do
|
|
unless (queueSize > 0) $ throwError DBMInvalidQueueSize
|
|
confirmMigrations <- liftEitherWith (const DBMInvalidConfirmation) $ strDecode $ B.pack confirm
|
|
let migrationConfig = MigrationConfig confirmMigrations (Just "")
|
|
chatStore <- migrate createChatStore (toDBOpts chatDbOpts chatSuffix keepKey chatDBFunctions) migrationConfig
|
|
agentStore <- migrate createAgentStore (toDBOpts chatDbOpts agentSuffix keepKey []) migrationConfig
|
|
ExceptT $ initialize chatStore ChatDatabase {chatStore, agentStore}
|
|
where
|
|
opts = mobileChatOpts (removeDbKey chatDbOpts) (fromIntegral queueSize)
|
|
initialize st db = do
|
|
user_ <- liftIO $ getActiveUser_ st
|
|
first DBMAgentError <$> newChatController db user_ defaultMobileConfig opts backgroundMode
|
|
migrate createStore dbOpts confirmMigrations =
|
|
ExceptT $
|
|
(first (DBMErrorMigration errDbStr) <$> createStore dbOpts confirmMigrations)
|
|
#if !defined(dbPostgres)
|
|
`catch` (pure . checkDBError)
|
|
#endif
|
|
`catchAll` (pure . dbError)
|
|
where
|
|
errDbStr = errorDbStr dbOpts
|
|
#if !defined(dbPostgres)
|
|
checkDBError e = case sqlError e of
|
|
DB.ErrorNotADatabase -> Left $ DBMErrorNotADatabase errDbStr
|
|
_ -> dbError e
|
|
#endif
|
|
dbError :: Show e => e -> Either DBMigrationResult DBStore
|
|
dbError e = Left . DBMErrorSQL errDbStr $ show e
|
|
|
|
chatCloseStore :: ChatController -> IO String
|
|
chatCloseStore ChatController {chatStore, smpAgent} = handleErr $ do
|
|
closeDBStore chatStore
|
|
closeDBStore $ agentClientStore smpAgent
|
|
|
|
chatReopenStore :: ChatController -> IO String
|
|
chatReopenStore ChatController {chatStore, smpAgent} = handleErr $ do
|
|
reopenDBStore chatStore
|
|
reopenDBStore (agentClientStore smpAgent)
|
|
|
|
handleErr :: IO () -> IO String
|
|
handleErr a = (a $> "") `catch` (pure . show @SomeException)
|
|
|
|
chatSendCmd :: ChatController -> B.ByteString -> IO JSONByteString
|
|
chatSendCmd cc cmd = chatSendRemoteCmdRetry cc Nothing cmd 0
|
|
{-# INLINE chatSendCmd #-}
|
|
|
|
chatSendRemoteCmdRetry :: ChatController -> Maybe RemoteHostId -> B.ByteString -> Int -> IO JSONByteString
|
|
chatSendRemoteCmdRetry cc rh s retryNum = J.encode . eitherToResult rh <$> runReaderT (execChatCommand (maybe CSLocal CSRemoteHost rh) s retryNum) cc
|
|
|
|
chatRecvMsg :: ChatController -> IO JSONByteString
|
|
chatRecvMsg ChatController {outputQ} = J.encode . uncurry eitherToResult <$> readChatResponse
|
|
where
|
|
readChatResponse =
|
|
atomically (readTBQueue outputQ) >>= \case
|
|
(_, Right CEvtTerminalEvent {}) -> readChatResponse
|
|
out -> pure out
|
|
|
|
chatRecvMsgWait :: ChatController -> Int -> IO JSONByteString
|
|
chatRecvMsgWait cc time = fromMaybe "" <$> timeout time (chatRecvMsg cc)
|
|
|
|
chatParseMarkdown :: ByteString -> JSONByteString
|
|
chatParseMarkdown = J.encode . parsedMarkdown . safeDecodeUtf8
|
|
{-# INLINE chatParseMarkdown #-}
|
|
|
|
chatParseServer :: ByteString -> JSONByteString
|
|
chatParseServer = J.encode . toServerAddress . strDecode
|
|
where
|
|
toServerAddress :: Either String AProtoServerWithAuth -> ParsedServerAddress
|
|
toServerAddress = \case
|
|
Right (AProtoServerWithAuth protocol (ProtoServerWithAuth ProtocolServer {host, port, keyHash = C.KeyHash kh} auth)) ->
|
|
let basicAuth = maybe "" (\(BasicAuth a) -> enc a) auth
|
|
in ParsedServerAddress (Just ServerAddress {serverProtocol = AProtocolType protocol, hostnames = L.map enc host, port, keyHash = enc kh, basicAuth}) ""
|
|
Left e -> ParsedServerAddress Nothing e
|
|
enc :: StrEncoding a => a -> String
|
|
enc = B.unpack . strEncode
|
|
|
|
chatParseUri :: Bool -> ByteString -> JSONByteString
|
|
chatParseUri safe s = J.encode $ case parseUri s of
|
|
Left e -> ParsedUri Nothing e
|
|
Right uri@U.URI {uriScheme = U.Scheme sch} ->
|
|
let sanitized = safeDecodeUtf8 . U.serializeURIRef' <$> sanitizeUri safe uri
|
|
uriInfo = UriInfo {scheme = safeDecodeUtf8 sch, sanitized}
|
|
in ParsedUri (Just uriInfo) ""
|
|
|
|
chatPasswordHash :: ByteString -> ByteString -> ByteString
|
|
chatPasswordHash pwd salt = either (const "") passwordHash salt'
|
|
where
|
|
salt' = U.decode salt
|
|
passwordHash = U.encode . C.sha512Hash . (pwd <>)
|