{-# LINE 1 "Magic/Operations.hsc" #-}
{- -*- Mode: haskell; -*-
Haskell magic Interface
Copyright (C) 2005 John Goerzen <jgoerzen@complete.org>

This code is under a 3-clause BSD license; see COPYING for details.
-}

{- |
   Module     : Magic.Init
   Copyright  : Copyright (C) 2005 John Goerzen
   License    : BSD

   Maintainer : Joey Hess,
   Maintainer : id\@joeyh.name
   Stability  : provisional
   Portability: portable

Operations for magic programs

Written by John Goerzen, jgoerzen\@complete.org
-}

module Magic.Operations(-- * Guessing the type
                        magicFile, magicStdin, magicFD,
                        magicString, magicCString,
                        -- * Other operations
                        magicSetFlags)
where

import Foreign.Ptr
import Foreign.C.String
import Magic.Types
import Foreign.C.Types
import Data.Word
import Magic.Utils
import Magic.TypesLL
import System.OsPath.Types
import GHC.IO.FD
import qualified Data.ByteString as BS
import qualified Data.ByteString.Short as SBS

{- | Calls the Magic system on the specified file. -}
magicFile :: Magic -> OsPath -> IO BS.ByteString
magicFile :: Magic -> OsPath -> IO ByteString
magicFile Magic
magic OsPath
fp =
    Magic -> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a. Magic -> (Ptr CMagic -> IO a) -> IO a
withMagicPtr Magic
magic ((Ptr CMagic -> IO ByteString) -> IO ByteString)
-> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a b. (a -> b) -> a -> b
$ \Ptr CMagic
cmagic -> do
      sbsfp <- OsPath -> IO ShortByteString
decodeOsPath OsPath
fp
      SBS.useAsCString sbsfp $ \CString
cfp -> do
        res <- String -> Ptr CMagic -> IO CString -> IO CString
forall a. String -> Ptr CMagic -> IO (Ptr a) -> IO (Ptr a)
throwErrorIfNull String
"magicFile" Ptr CMagic
cmagic (Ptr CMagic -> CString -> IO CString
magic_file Ptr CMagic
cmagic CString
cfp)
        BS.packCString res

{- | Calls the Magic system on stdin. -}
magicStdin :: Magic -> IO BS.ByteString
magicStdin :: Magic -> IO ByteString
magicStdin Magic
magic =
    Magic -> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a. Magic -> (Ptr CMagic -> IO a) -> IO a
withMagicPtr Magic
magic ((Ptr CMagic -> IO ByteString) -> IO ByteString)
-> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a b. (a -> b) -> a -> b
$ \Ptr CMagic
cmagic ->
     do res <- String -> Ptr CMagic -> IO CString -> IO CString
forall a. String -> Ptr CMagic -> IO (Ptr a) -> IO (Ptr a)
throwErrorIfNull String
"magicStdin" Ptr CMagic
cmagic (Ptr CMagic -> CString -> IO CString
magic_file Ptr CMagic
cmagic CString
forall a. Ptr a
nullPtr)
        BS.packCString res

{- | Calls the Magic system on the contents of the file descriptor. -}
magicFD :: Magic -> FD -> IO BS.ByteString
magicFD :: Magic -> FD -> IO ByteString
magicFD Magic
magic FD
fd =
    Magic -> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a. Magic -> (Ptr CMagic -> IO a) -> IO a
withMagicPtr Magic
magic ((Ptr CMagic -> IO ByteString) -> IO ByteString)
-> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a b. (a -> b) -> a -> b
$ \Ptr CMagic
cmagic ->
     do res <- String -> Ptr CMagic -> IO CString -> IO CString
forall a. String -> Ptr CMagic -> IO (Ptr a) -> IO (Ptr a)
throwErrorIfNull String
"magicFD" Ptr CMagic
cmagic (Ptr CMagic -> CInt -> IO CString
magic_descriptor Ptr CMagic
cmagic (FD -> CInt
fdFD FD
fd))
        BS.packCString res

{- | Calls the Magic system to process the given String.  Please note:
it is not evaluated lazily. -}
magicString :: Magic -> String -> IO BS.ByteString
magicString :: Magic -> String -> IO ByteString
magicString Magic
m String
s = String -> (CStringLen -> IO ByteString) -> IO ByteString
forall a. String -> (CStringLen -> IO a) -> IO a
withCStringLen String
s (Magic -> CStringLen -> IO ByteString
magicCString Magic
m)

{- | Lower-level function used to call the Magic system to process a C 
string. -}
magicCString :: Magic -> CStringLen -> IO BS.ByteString
magicCString :: Magic -> CStringLen -> IO ByteString
magicCString Magic
magic (CString
cstr, Int
len) =
    Magic -> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a. Magic -> (Ptr CMagic -> IO a) -> IO a
withMagicPtr Magic
magic ((Ptr CMagic -> IO ByteString) -> IO ByteString)
-> (Ptr CMagic -> IO ByteString) -> IO ByteString
forall a b. (a -> b) -> a -> b
$ \Ptr CMagic
cmagic ->
     do res <- String -> Ptr CMagic -> IO CString -> IO CString
forall a. String -> Ptr CMagic -> IO (Ptr a) -> IO (Ptr a)
throwErrorIfNull String
"magicCString" Ptr CMagic
cmagic (Ptr CMagic -> CString -> Word64 -> IO CString
magic_buffer Ptr CMagic
cmagic CString
cstr (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len))
        BS.packCString res

{- | Change the flags on an already-created object. -}
magicSetFlags :: Magic -> [MagicFlag] -> IO ()
magicSetFlags :: Magic -> [MagicFlag] -> IO ()
magicSetFlags Magic
m [MagicFlag]
mfl = Magic -> (Ptr CMagic -> IO ()) -> IO ()
forall a. Magic -> (Ptr CMagic -> IO a) -> IO a
withMagicPtr Magic
m ((Ptr CMagic -> IO ()) -> IO ()) -> (Ptr CMagic -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr CMagic
cmagic ->
     String -> Ptr CMagic -> IO CInt -> IO ()
checkIntError String
"magicSetFlags" Ptr CMagic
cmagic (IO CInt -> IO ()) -> IO CInt -> IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CMagic -> CInt -> IO CInt
magic_setflags Ptr CMagic
cmagic CInt
flags
    where flags :: CInt
flags = [MagicFlag] -> CInt
flaglist2int [MagicFlag]
mfl

-- Does file I/O -> safe
foreign import ccall safe "magic.h magic_file"
  magic_file :: Ptr CMagic -> CString -> IO CString

-- Does file I/O -> safe
foreign import ccall safe "magic.h magic_descriptor"
  magic_descriptor :: Ptr CMagic -> CInt -> IO CString

-- Does not do I/O -> unsafe
foreign import ccall unsafe "magic.h magic_buffer"
  magic_buffer :: Ptr CMagic -> CString -> Word64 -> IO CString
{-# LINE 95 "Magic/Operations.hsc" #-}

-- Does not do I/O -> unsafe
foreign import ccall unsafe "magic.h magic_setflags"
  magic_setflags :: Ptr CMagic -> CInt -> IO CInt