pre-commit.hook

#!/usr/bin/env bash

# Ensure that the common script exists and is readable, then verify it has no
# syntax errors and defines the required function.
common_script="$(dirname "$0")/../../scripts/common.sh"
[ -r "$common_script" ] || { echo "[!] '$common_script' not found or not readable." >&2; exit 1; }
bash -n "$common_script" >/dev/null 2>&1 || { echo "[!] '$common_script' contains syntax errors." >&2; exit 1; }
source "$common_script"
declare -F set_colors >/dev/null 2>&1 || { echo "[!] '$common_script' does not define the required function." >&2; exit 1; }

# Build unmatched suppressions for each *.c file.
cppcheck_build_unmatched() {
  local file suppression=""
  for file in *.c tools/*.c; do
    suppression+=" --suppress=unmatchedSuppression:$file"
  done
  echo "$suppression"
}

cppcheck_suppressions() {
  # Array of suppression keys (plain elements, without "--suppress=")
  local -a suppr_keys=(
    "checkersReport"
    "unmatchedSuppression"
    "normalCheckLevelMaxBranches"
    "missingIncludeSystem"
    "noValidConfiguration"
    "unusedFunction"
    "identicalInnerCondition:log2_lshift16.h"
    "checkLevelNormal:log2_lshift16.h"
    "nullPointerRedundantCheck:report.c"
    "returnDanglingLifetime:report.c"
    "nullPointerRedundantCheck:harness.c"
    "nullPointerOutOfMemory:harness.c"
    "staticFunction:harness.c"
    "nullPointerRedundantCheck:queue.c"
    "constParameterPointer:queue.c"
    "memleak:queue.c"
    "nullPointer:queue.c"
    "nullPointer:qtest.c"
    "constParameterCallback:console.c"
    "constParameterPointer:console.c"
    "staticFunction:console.c"
    "preprocessorErrorDirective:random.h"
    "constVariablePointer:linenoise.c"
    "staticFunction:linenoise.c"
    "nullPointerOutOfMemory:web.c"
    "staticFunction:web.c"
    "constParameterCallback:tools/fmtscan.c"
  )

  # Array for additional cppcheck options (non-suppressions)
  local -a other_flags=(
    "--inline-suppr harness.c --inline-suppr tools/fmtscan.c"
  )

  local out=""
  # Append other flags.
  for flag in "${other_flags[@]}"; do
    out+="$flag "
  done

  # Append each suppression flag separately.
  for key in "${suppr_keys[@]}"; do
    out+="--suppress=$key "
  done

  # Trim trailing whitespace and output the final string.
  printf "%s" "$out" | sed 's/[[:space:]]*$//'
}

# Generation of standard compliance for GCC/Clang
detect_cc_std() {
  local STDC_VERSION=""
  local EXTRA_DEFINES=""
  if command -v cc >/dev/null 2>&1; then
    if cc --version 2>/dev/null | grep -q "clang"; then
      STDC_VERSION=$(cc -dM -E -xc /dev/null | awk '/__STDC_VERSION__/ {print $3}')
      EXTRA_DEFINES="-D__clang__=1"
    elif cc --version 2>/dev/null | grep -q "Free Software Foundation"; then
      STDC_VERSION=$(cc -dM -E -xc /dev/null | awk '/__STDC_VERSION__/ {print $3}')
      EXTRA_DEFINES="-D__GNUC__=1"
    fi
  fi
  if [ -n "$STDC_VERSION" ]; then
    EXTRA_DEFINES+=" -D__STDC__=1 -D__STDC_VERSION__=${STDC_VERSION}"
  fi
  echo "$EXTRA_DEFINES"
}

CPPCHECK_OPTS="-I. --enable=all --error-exitcode=1"
CPPCHECK_OPTS+=" $(detect_cc_std)"
CPPCHECK_OPTS+=" --force $(cppcheck_suppressions) $(cppcheck_build_unmatched)"
CPPCHECK_OPTS+=" --cppcheck-build-dir=.out ."

set_colors

RETURN=0

# Disallow non-ASCII characters in workspace path
workspace=$(git rev-parse --show-toplevel)
if echo "$workspace" | grep -q "[一-龥]"; then
  throw "The workspace path '$workspace' contains non-ASCII characters."
fi

# Check for merge conflict markers in staged changes.
# Assemble the conflict marker regex without embedding it directly.
CONFLICT_MARKERS=$(printf '%s|%s|%s' "<<<<<<<" "=======" ">>>>>>>")
# Get staged files that contain conflict markers, but exclude hook files.
CONFLICT_FILES=$(git diff --cached --name-only -G "${CONFLICT_MARKERS}" | \
                 grep -vE '(^|/)\.git/hooks/|(^|/)(pre-commit|commit-msg|prepare-commit-msg|pre-push)\.hook$')
if [ -n "${CONFLICT_FILES}" ]; then
  throw "Conflict markers are still present in the following files:\n%s" ${CONFLICT_FILES}
fi

CLANG_FORMAT=$(which clang-format)
if [ $? -ne 0 ]; then
  throw "clang-format not installed. Unable to check source file format policy."
fi

CPPCHECK=$(which cppcheck)
mkdir -p .out
if [ $? -ne 0 ]; then
  throw "cppcheck not installed. Unable to perform static analysis."
fi

# Check that cppcheck's version is at least 1.90.
cppcheck_ver=$("$CPPCHECK" --version)
if echo "$cppcheck_ver" | grep -qE '^Cppcheck\s2'; then
  : # Version 2.x is acceptable.
else
  # For version 1.x, extract the minor version and compare.
  minor_version=$(echo "$cppcheck_ver" | sed -Ee 's/Cppcheck 1\.([0-9]+)/\1/;q')
  if [ "$minor_version" -lt 90 ]; then
    throw "cppcheck version must be at least 1.90.\n\
    See Developer Info for building cppcheck from source:\n\
        https://cppcheck.sourceforge.io/devinfo/"
  fi
fi

ASPELL=$(which aspell)
if [ $? -ne 0 ]; then
  throw "aspell not installed. Unable to do spelling check."
fi
if [ -z "$(aspell dump dicts | grep -E '^en$')" ]; then
  throw "aspell-en not installed. Unable to do spelling check."
fi

DIFF=$(which colordiff)
if [ $? -ne 0 ]; then
  DIFF=diff
fi

if command -v sha1sum >/dev/null 2>&1; then
  SHA1SUM="sha1sum"
elif command -v shasum >/dev/null 2>&1; then
  SHA1SUM="shasum"
else
  throw "sha1sum or shasum not installed."
fi

# Get staged filenames (added, copied, or modified) into an array.
FILES=($(git diff --cached --name-only --diff-filter=ACM))
binary_files=()

for file in "${FILES[@]}"; do
  # Get MIME info for the file.
  mime_info=$(file --mime "$file")
  # Extract a friendly filename (everything before the colon).
  name=$(file "$file" | cut -d ":" -f1)

  if echo "$mime_info" | grep -qi binary; then
    binary_files+=("$name")
    printf "${RED}[!]${NC} '${YELLOW}$name${NC}' appears to be a binary blob.\n"
  fi
done

if [ "${#binary_files[@]}" -gt 0 ]; then
  printf "${RED}[!]${NC} Binary data found.\n"
fi

FILES=$(git diff --cached --name-only --diff-filter=ACMR | grep -E "\.(c|cpp|h)$")
for FILE in $FILES; do
  nf=$(git checkout-index --temp $FILE | cut -f 1)
  tempdir=$(mktemp -d) || exit 1
  newfile=$(mktemp ${tempdir}/${nf}.XXXXXX) || exit 1
  basename=$(basename $FILE)

  source="${tempdir}/${basename}"
  mv $nf $source
  cp .clang-format $tempdir
  $CLANG_FORMAT $source > $newfile 2>> /dev/null
  $DIFF -u -p -B \
        --label="modified $FILE" --label="expected coding style" \
        "${source}" "${newfile}"
  r=$?
  rm -rf "${tempdir}"
  if [ $r != 0 ] ; then
    echo "[!] $FILE does not follow the consistent coding style." >&2
    RETURN=1
  fi
  if [ $RETURN -eq 1 ]; then
    echo "" >&2
    echo "Make sure you indent as the following:" >&2
    echo "    clang-format -i $FILE" >&2
    echo
  fi
done

if [ ! -z "${FILES[*]}" ]; then
  echo "Following files were changed:"
  echo "${FILES[*]}"
fi

$SHA1SUM -c scripts/checksums 2>/dev/null >/dev/null
if [ $? -ne 0 ]; then
  throw "You are not allowed to change the header file queue.h or list.h"
fi

# Prevent unsafe functions
root=$(git rev-parse --show-toplevel)
banned="([^f]gets\()|(sprintf\()|(strcpy\()"
status=0
for file in $(git diff --staged --name-only | grep -E "\.(c|cc|cpp|h|hh|hpp)\$")
do
  filepath="${root}/${file}"
  output=$(grep -nrE "${banned}" "${filepath}")
  if [ ! -z "${output}" ]; then
    echo "Dangerous function detected in ${filepath}"
    echo "${output}"
    echo
    echo "Read 'Common vulnerabilities guide for C programmers' carefully."
    echo "    https://security.web.cern.ch/security/recommendations/en/codetools/c.shtml"
    RETURN=1
  fi
done

# format string checks
if [ ! -f fmtscan ]; then
    make fmtscan
    if [ ! -f fmtscan ]; then
       throw "Fail to build 'fmtscan' tools"
    fi
fi
if git diff --cached --name-only | grep -qiE "\.(c|h|cpp|hpp)$"; then
  echo "Running fmtscan..."
  ./fmtscan
  if [ $? -ne 0 ]; then
    throw "Check format strings for spelling"
  fi
fi

# static analysis
echo "Running static analysis..."
$CPPCHECK $CPPCHECK_OPTS >/dev/null
if [ $? -ne 0 ]; then
  RETURN=1
  echo "" >&2
  echo "Fail to pass static analysis." >&2
  echo
fi

# non-ASCII filenames are not allowed.
# Cross platform projects tend to avoid non-ASCII filenames; prevent
# them from being added to the repository.
if test $(git diff --cached --name-only --diff-filter=A -z $against |
          LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
then
  cat <<\EOF
ERROR: Attempt to add a non-ASCII file name.
This can cause problems if you want to work with people on other platforms.
To be portable it is advisable to rename the file.
EOF
  RETURN=1
fi

exit $RETURN