#!/usr/local/bin/scripts/sh
#
#.Y / 70 83 / / / / 105 / / / /  / /               ;A4_QUER.Y
#.YT 3 2 0 0 3 3 1 / / /
#.H!a!0:linux/<scripts>/io/disk/mediaAccess/mediaHandlers.d/A8A2BB24_78F0_11E6_B6F3_0000C00A45A9!0.!c
#
#/*******************************************************************************
#     io disk mediaAccess mediaHandlers.d/A8A2BB24_78F0_11E6_B6F3_0000C00A45A9
#     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
#     purpose             : media handler for a an encrypted media, with its
#                           key in a folder
#
#     begin               : Sun Dec 11 12:01:34 CEST 2016
#
#     changes             :
#
#     copyright           : (C) 2016 by Thomas Bruecker
#
#     email               : public@thomas-r-bruecker.ch
#
#     version             : -0.0.0
#
#*******************************************************************************/

#/***************************************************************************
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU General Public License as published by  *
# *   the Free Software Foundation; either version 2 of the License, or     *
# *   (at your option) any later version.                                   *
# *                                                                         *
# *   This program is distributed in the hope that it will be useful, but   *
# *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
# *   General Public License for more details.                              *
# *                                                                         *
# *   You should have received a copy of the GNU General Public License     *
# *   along with this program; if not, write to the Free Software           *
# *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,            *
# *   MA 02110-1301 USA.                                                    *
# *                                                                         *
# ***************************************************************************/

# MyHash("A8A2BB24_78F0_11E6_B6F3_0000C00A45A9") = 0x088C_24
#
# * for every function:
#   * if returned result is not commented, the function returns 0 on no-error.

. "/${SCRIPTS}/io/con/THIS"


disk_mediaAccess_A8A2BB24_78F0_11E6_B6F3_0000C00A45A9() {
  # handles an encrypted media, with its key in a folder;
  # $1: command, in {
  #       "2ChildDev", "2ChildMedia", "DESTROY", "REALIZE", "RealizeForced",
  #       "SIZE", "VERIFY", "WAIT", "_:", "__:"
  #     },
  #     * $1 in {
  #         "2ChildDev", "2ChildMedia", "DESTROY", "REALIZE", "RealizeForced",
  #         "SIZE", "VERIFY", "WAIT"
  #       }: see "../CommonCommandsSpecification.TXT".

  # global:  MediaInfoSize0x0EAA

  local      COMMAND FORCED INDEX MediaInfo ParentMedia ParentMediaPath

  COMMAND="$1"
  INDEX="$2"
  MediaInfo="$3"
  ParentMedia="$4"
  ParentMediaPath="$5"

  # echo  $COMMAND                                                >>/dev/stderr
  # echo  $INDEX                                                  >>/dev/stderr
  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMedia                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  # quick, for verifying and 'wait':
    disk_mediaAccess__VerifyNoWait  "$COMMAND"  && return 0
                                                   # if ok, return 0; no
                                                   # waiting for component
                                                   # medias at all.

  disk_mediaAccess__RealizeForced2Forced  "$COMMAND"
  # echo  FORCED: $FORCED                                         >>/dev/stderr

  case "$COMMAND" in
      2ChildDev)
        disk_mediaAccess___2ChildDev                                         \
                    "$INDEX" "$MediaInfo" "$ParentMedia" "$ParentMediaPath"  ;;
      2ChildMedia)
        disk_mediaAccess___2ChildMedia0                                      \
                             "$MediaInfo"                                    ;;
      CHECK)
        disk_mediaAccess__0x088C_24_CHECK                                    \
                    "$INDEX" "$MediaInfo" "$ParentMedia" "$ParentMediaPath"  ;;
      DESTROY)
        disk_mediaAccess___Destroy0                                          \
                             "$MediaInfo" ''                                 ;;
      REALIZE|RealizeForced)
        disk_mediaAccess__0x088C_24_REALIZE                                  \
          "$FORCED" "$INDEX" "$MediaInfo"                "$ParentMediaPath"  ;;
      REPAIR)
        disk_mediaAccess__0x088C_24_REPAIR                                   \
                    "$INDEX" "$MediaInfo" "$ParentMedia" "$ParentMediaPath"  ;;
      SIZE)
        disk_mediaAccess__Size0                                              \
          "$MediaInfoSize0x0EAA" "$MediaInfo"                                ;;
      _DestroyTestBlockMedia)
        disk_mediaAccess___0x088C_24_DestroyTestBlockMedia                   \
                             "$MediaInfo"                                    ;;
      _HashTestBlock)
        disk_mediaAccess___0x088C_24_HashTestBlock                           \
                             "$MediaInfo"                "$ParentMediaPath"  ;;
      _InitializeTestBlock)
        disk_mediaAccess___0x088C_24_InitializeTestBlock                     \
                    "$INDEX" "$MediaInfo" "$ParentMedia" "$ParentMediaPath"  ;;
      _RealizeTestBlockMedia)
        disk_mediaAccess___0x088C_24_RealizeTestBlockMedia                   \
                             "$MediaInfo"                "$ParentMediaPath"  ;;
      *)
        disk_mediaAccess___NoContainer                                       \
          "$COMMAND" "$INDEX" "$ParentMedia"                                 \
          || return                                # return on error.

        disk_mediaAccess__InvalidCommandError                                \
          "$COMMAND" "$INDEX"                                                \
          'A8A2BB24_78F0_11E6_B6F3_0000C00A45A9'                             \
          "$ParentMedia"                                                     ;;
    esac                                           # return result of previous
}                                                  # command.


disk_mediaAccess__0x088C_24_CHECK() {
  # check for correct decryption;
  # $1: <INDEX>,
  # $2: <MediaInfo>,
  # $3: <ParentMedia>,
  # $4: <ParentMediaPath>.

  local  CalculatedTestBlockHash ChildMediaFolderPath ChildMediaName MediaInfo
  local  ParentMedia ParentMediaPath TestBlockHash

  INDEX="$1"
  MediaInfo="$2"
  ParentMedia="$3"
  ParentMediaPath="$4"

  # echo  $INDEX                                                  >>/dev/stderr
  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMedia                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  ChildMediaName="$(disk_mediaAccess___2ChildUuid  "$MediaInfo")"         \
    || return                                      # return on error.
  ChildMediaFolderPath="$(
    disk_mediaAccess___0x088C_24_ChildMediaFolderPath  "$ChildMediaName"
  )"  || return                                    # return on error.

  # echo  $ChildMediaName                                         >>/dev/stderr
  # echo  $ChildMediaFolderPath                                   >>/dev/stderr

  # get test block hash:
    [ -f "${ChildMediaFolderPath}/TestBlockHash.TXT" ]  || return  251
      .  "${ChildMediaFolderPath}/TestBlockHash.TXT"

  CalculatedTestBlockHash="$(
    disk_mediaAccess___0x088C_24_HashTestBlock                            \
      "$MediaInfo" "$ParentMediaPath"
  )"  || return                                    # return on error.

  # echo  $CalculatedTestBlockHash                                >>/dev/stderr
  # echo  $TestBlockHash                                          >>/dev/stderr

  [ "$TestBlockHash" != "$CalculatedTestBlockHash" ]  || return  0
    disk_mediaAccess___GeneralError                                       \
      'The Media may not be decrypted correctly'                          \
      "$INDEX" 'A8A2BB24_78F0_11E6_B6F3_0000C00A45A9' "$ParentMedia"
    return  "$FileSystemErrorsLeftUncorrected0x0EAA"
}


disk_mediaAccess__0x088C_24_REALIZE() {
  # realize media or realize media forced;
  # $1: <FORCED>,
  # $2: <INDEX>,
  # $3: <MediaInfo>,
  # $4: <ParentMediaPath>.

  # global:  MediaInfoSize0x0EAA

  local      ChildMediaName FORCED INDEX MediaInfo ParametersFile ParentMedia

  # parameters:
    local    COPYRIGHT CopyrightDetails KERNEL NOTES OnlyOnHosts
    local    RealizationOptions SIZE START URL UUID

  FORCED="$1"
  INDEX="$2"
  MediaInfo="$3"
  ParentMediaPath="$4"

  # echo  $FORCED                                                 >>/dev/stderr
  # echo  $INDEX                                                  >>/dev/stderr
  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  # clear global optional not ignored parameters.
    OnlyOnHosts=''
    RealizationOptions=''

  ParametersFile="$(disk_mediaAccess__Parameters2File  "$MediaInfo")"  \
    || return                                      # return on error.
    .  "$ParametersFile"  || return                # return on error.

  # echo  $COPYRIGHT                                              >>/dev/stderr
  # echo  $CopyrightDetails                                       >>/dev/stderr
  # echo  $KERNEL                                                 >>/dev/stderr
  # echo  $NOTES                                                  >>/dev/stderr
  # echo  $OnlyOnHosts                                            >>/dev/stderr
  # echo  $RealizationOptions                                     >>/dev/stderr
  # echo  $SIZE                                                   >>/dev/stderr
  # echo  $START                                                  >>/dev/stderr
  # echo  $URL                                                    >>/dev/stderr
  # echo  $UUID                                                   >>/dev/stderr

  disk_mediaAccess_isHandled                                              \
    "$FORCED" "$OnlyOnHosts" "$RealizationOptions"  || return 0

  ChildMediaName="$UUID"
  ChildMediaFolderPath="$(
    disk_mediaAccess___0x088C_24_ChildMediaFolderPath  "$ChildMediaName"
  )"  || return                                    # return on error.
  # echo $ChildMediaFolderPath                                    >>/dev/stderr

  let "START += MediaInfoSize0x0EAA"

  disk_mediaAccess___0x088C_24_CryptTable                                 \
    "$ChildMediaFolderPath" "$ChildMediaName" "$ParentMediaPath"          \
    "$RealizationOptions" "$SIZE" "$START"                                \
    || return                                      # return on error.

  disk_mediaAccess__LinkAndMap                                            \
    "$ChildMediaName" "$INDEX" "$ParentMediaPath"
}


disk_mediaAccess__0x088C_24_REPAIR() {
  # check or repair the media;
  # $1: <INDEX>,
  # $2: <MediaInfo>,
  # $3: <ParentMedia>,
  # $4: <ParentMediaPath>.

  local  INDEX MediaInfo ParentMedia ParentMediaPath

  INDEX="$1"
  MediaInfo="$2"
  ParentMedia="$3"
  ParentMediaPath="$4"

  # echo  $INDEX                                                  >>/dev/stderr
  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMedia                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  disk_mediaAccess__0x088C_24_CHECK                                          \
    "$INDEX" "$MediaInfo" "$ParentMedia" "$ParentMediaPath"                  \
    && return                                      # checking is ok.

  echo  -e   "\nThis media may not be repaired automatically;"    >>/dev/stderr
  echo  -e   "Please contact your system-administrator."          >>/dev/stderr
                                                                  >>/dev/stderr
  disk_mediaAccess___GeneralMediaDescription                                 \
        "$INDEX" 'A8A2BB24_78F0_11E6_B6F3_0000C00A45A9' "$ParentMedia" '  '

  return  "$FileSystemErrorsLeftUncorrected0x0EAA"
}


disk_mediaAccess___0x088C_24_ChildMediaFolderPath() {
  # checks, if the child-media-folder is present an writes its path to
  # "stdout";
  # $1: <ChildMediaName>.

  # global:    DisksByUuidMountPath0x0EAA MissingFolder0x0EAA

  local        ChildMediaFolderPath
  local  -l    ChildMediaFolderPathLC              # converts to lower case.
  local        ChildMediaName

  ChildMediaName="$1"
  # echo  $ChildMediaName                                         >>/dev/stderr

  ChildMediaFolderPathLC="${ChildMediaName}.D"
  ChildMediaFolderPath="$DisksByUuidMountPath0x0EAA/$ChildMediaFolderPathLC"
    [ -d "$ChildMediaFolderPath" ]  || return "$MissingFolder0x0EAA"

  echo "$ChildMediaFolderPath"
}


disk_mediaAccess___0x088C_24_CryptTable() {
  # creates a crypt-table for a child-media;
  # $1: <ChildMediaFolderPath>,
  # $2: <ChildMediaName>,
  # $3: <ParentMediaPath>,
  # $4: <RealizationOptions>,
  # $5: <SIZE>,
  # $6: <START>.

  local  ChildMediaName ChildMediaFolderPath ParentMediaPath RealizationOptions
  local  RESULT ResultText SIZE START TABLE

  ChildMediaFolderPath="$1"
  ChildMediaName="$2"
  ParentMediaPath="$3"
  RealizationOptions="$4"
  SIZE="$5"
  START="$6"

  # echo  $ChildMediaFolderPath                                   >>/dev/stderr
  # echo  $ChildMediaName                                         >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr
  # echo  $RealizationOptions                                     >>/dev/stderr
  # echo  $SIZE                                                   >>/dev/stderr
  # echo  $START                                                  >>/dev/stderr

  # get cipher:
    [ -f "${ChildMediaFolderPath}/CIPHER.TXT" ]       || return  251
      ResultText='OK: CIPHER.TXT .'
      . "${ChildMediaFolderPath}/CIPHER.TXT"
    # echo $CIPHER                                                >>/dev/stderr

  # get iv:
    [ -f "${ChildMediaFolderPath}/IV.TXT" ]           || {
      echo   -e  "$ResultText"                                    >>/dev/stderr
      return  251
    }
      ResultText+='\nOK: IV.TXT .'
      . "${ChildMediaFolderPath}/IV.TXT"
    # echo $IV                                                    >>/dev/stderr

  # get key:
    [ -f "${ChildMediaFolderPath}/KEY.TXT" ]          || {
      echo   -e  "$ResultText"                                    >>/dev/stderr
      return  251
    }
      ResultText+='\nOK: KEY.TXT .'
      . "${ChildMediaFolderPath}/KEY.TXT"
    # echo $KEY                                                   >>/dev/stderr

  TABLE="0 $SIZE  crypt  $CIPHER $KEY $IV  $ParentMediaPath $START"
    # echo $TABLE                                                 >>/dev/stderr
    echo  -n  "$TABLE"  | disk_mediaAccess__DmCreate                          \
      "$ChildMediaName" "$RealizationOptions"         || {
       RESULT="$?"
       echo  -e  "$ResultText"                                    >>/dev/stderr
       return    "$RESULT"                        # return on error.
    }
}


disk_mediaAccess___0x088C_24_DestroyTestBlockMedia() {
  # destroys the test-block-media;
  # $1: <MediaInfo>.

  local  MediaInfo TestBlockMediaName

  MediaInfo="$1"
  # echo  "$MediaInfo"                                            >>/dev/stderr

  TestBlockMediaName="$(
    disk_mediaAccess___0x088C_24_TestBlockMediaName  "$MediaInfo"
  )"  || return                                    # return on error.

  disk_mediaAccess___Destroy1  "$TestBlockMediaName"
}


disk_mediaAccess___0x088C_24_HashTestBlock() {
  # writes the sha512-sum of the test-block to "stdout";
  # the child-media for the parent-media must have been realized;
  # $1: <MediaInfo>,
  # $2: <ParentMediaPath>.

  # global:  ColRm0x0EAA Sha512Sum0x0EAA

  local      MediaInfo ParentMediaPath TestBlockMedia TestBlockMediaPath

  MediaInfo="$1"
  ParentMediaPath="$2"

  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  TestBlockMedia="$(
    disk_mediaAccess___0x088C_24_RealizeTestBlockMedia                  \
      "$MediaInfo" "$ParentMediaPath"
  )"  || return                                    # return on error.

  TestBlockMediaPath="$(
    disk_mediaAccess___QualifiedUuid2ByUuidPath  "$TestBlockMedia"
  )"

  # echo  $TestBlockMedia                                         >>/dev/stderr
  # echo  $TestBlockMediaPath                                     >>/dev/stderr

  "$Sha512Sum0x0EAA"  -b  "$TestBlockMediaPath"  | "$ColRm0x0EAA"  129

  disk_mediaAccess___0x088C_24_DestroyTestBlockMedia  "$MediaInfo"
}


disk_mediaAccess___0x088C_24_InitializeTestBlock() {
  # initializes the test-block;
  # $1: <INDEX>,
  # $2: <MediaInfo>,
  # $3: <ParentMedia>,
  # $4: <ParentMediaPath>.

  # global:  DD0x0EAA

  local      INDEX MediaInfo ParentMedia ParentMediaPath RESULT TestBlockMedia
  local      TestBlockMediaPath

  INDEX="$1"
  MediaInfo="$2"
  ParentMedia="$3"
  ParentMediaPath="$4"

  # echo  $INDEX                                                  >>/dev/stderr
  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMedia                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  echo  -e   "\n\nDo you really want to initialize the \"TestBlock\"?"        \
                                                                  >>/dev/stderr
  echo  -n   "Initializing a \"TestBlock\" on the wrong media may destroy "   \
                                                                  >>/dev/stderr
  echo       "the media!!!"                                                   \
                                                                  >>/dev/stderr
  disk_mediaAccess___GeneralMediaDescription                                  \
        "$INDEX" 'A8A2BB24_78F0_11E6_B6F3_0000C00A45A9' "$ParentMedia" '  '
  echo  -en  "\nEnter \"yes\", if you really want to initialize " >>/dev/stderr
  echo  -e  "the \"TestBlock\"."                                  >>/dev/stderr

  con_YesQ                                                        >>/dev/stderr
  RESULT="$?"
  [ '0' != "$RESULT" ]  && return                  # do not initialize.

  TestBlockMedia="$(
    disk_mediaAccess___0x088C_24_RealizeTestBlockMedia                        \
      "$MediaInfo" "$ParentMediaPath"
  )"  || return                                    # return on error.

  TestBlockMediaPath="$(
    disk_mediaAccess___QualifiedUuid2ByUuidPath  "$TestBlockMedia"
  )"

  # echo  $TestBlockMedia                                         >>/dev/stderr
  # echo  $TestBlockMediaPath                                     >>/dev/stderr

  echo  -en  "\nInitializing the \"TestBlock\"."                  >>/dev/stderr
  "$DD0x0EAA"  bs=4096  if=/dev/urandom  of="$TestBlockMediaPath"   2>/dev/null

  disk_mediaAccess___0x088C_24_DestroyTestBlockMedia  "$MediaInfo"
}


disk_mediaAccess___0x088C_24_RealizeTestBlockMedia() {
  # realizes the test-block-media and writes its qualified path to "stdout";
  # the child-media for the parent-media must have been realized;
  # $1: <MediaInfo>,
  # $2: <ParentMediaPath>.

  # global:  DeviceMapperBasePath0x0EAA MediaInfoSize0x0EAA

  local      ChildMediaFolderPath ChildMediaName MediaInfo ParametersFile
  local      ParentMediaPath TargetPath TestBlockMediaName

  # parameters:
    local    START UUID

  MediaInfo="$1"
  ParentMediaPath="$2"

  # echo  "$MediaInfo"                                            >>/dev/stderr
  # echo  $ParentMediaPath                                        >>/dev/stderr

  ParametersFile="$(disk_mediaAccess__Parameters2File  "$MediaInfo")"     \
    || return                                      # return on error.
    .  "$ParametersFile"  || return                # return on error.

  # echo $START                                                   >>/dev/stderr
  # echo $UUID                                                    >>/dev/stderr

  ChildMediaName="$UUID"
  ChildMediaFolderPath="$(
    disk_mediaAccess___0x088C_24_ChildMediaFolderPath  "$ChildMediaName"
  )"  || return                                    # return on error.
  TestBlockMediaName="$(
    disk_mediaAccess___0x088C_24_TestBlockMediaName  "$MediaInfo"
  )"  || return                                    # return on error.
  TargetPath="${DeviceMapperBasePath0x0EAA}/$TestBlockMediaName"

  # echo  $ChildMediaFolderPath                                   >>/dev/stderr
  # echo  $ChildMediaName                                         >>/dev/stderr
  # echo  $TestBlockMediaName                                     >>/dev/stderr
  # echo  $TargetPath                                             >>/dev/stderr

  disk_mediaAccess___0x088C_24_CryptTable                                 \
    "$ChildMediaFolderPath" "$TestBlockMediaName" "$ParentMediaPath"      \
    'readahead=auto' "$MediaInfoSize0x0EAA" "$START"                      \
    || return                                      # return on error.

  disk_mediaAccess___Link  "$TestBlockMediaName"
}


disk_mediaAccess___0x088C_24_TestBlockMediaName() {
  # writes the name of the test-block-media to "stdout";
  # $1: <MediaInfo>.

  local  ChildMediaName MediaInfo

  MediaInfo="$1"
  # echo  "$MediaInfo"                                            >>/dev/stderr

  ChildMediaName="$(disk_mediaAccess___2ChildUuid  "$MediaInfo")"  \
    || return                                      # return on error.

  echo  "${ChildMediaName}.TestBlock"
}