SysTutorials

Handling Ctrl-C Interrupts in Bash Scripts

· Q A · updated April 12, 2026

Handling Ctrl-C gracefully in a Bash script is essential when you need to perform cleanup operations, save state, or notify users before exiting. The trap builtin makes this straightforward.

Basic Trap Setup

The fundamental approach uses the trap command to catch the INT signal (which Ctrl-C generates):

trap ctrl_c INT

function ctrl_c() {
    echo "Ctrl-C detected"
    # Cleanup code here
    exit 0
}

# Your script continues below

When a user presses Ctrl-C, the ctrl_c() function executes before the script terminates. The INT signal handler runs synchronously, so you have full control over the exit process.

Practical Example with Cleanup

Here’s a more complete example showing typical cleanup operations:

#!/bin/bash

# Cleanup function
cleanup() {
    echo ""
    echo "Cleaning up..."
    # Kill background processes if any
    if [ ! -z "$BG_PID" ]; then
        kill $BG_PID 2>/dev/null
    fi
    # Remove temporary files
    rm -f /tmp/myscript.lock
    echo "Done. Exiting."
    exit 0
}

trap cleanup INT TERM

# Main script logic
echo "Starting process..."
BG_PID=""

# Example: long-running operation
while true; do
    echo "Working... (Press Ctrl-C to stop)"
    sleep 1
done

Handling Multiple Signals

You can trap multiple signals with a single handler or separate ones:

#!/bin/bash

cleanup() {
    echo "Caught signal, cleaning up..."
    exit 0
}

# Trap both INT (Ctrl-C) and TERM (termination)
trap cleanup INT TERM

# Or use separate handlers:
trap 'echo "Interrupted"; exit 1' INT
trap 'echo "Terminated"; cleanup_on_term' TERM

Resetting Traps

To remove a trap and restore default behavior, use trap - or trap without arguments:

trap - INT        # Remove INT trap
trap - INT TERM   # Remove INT and TERM traps
trap              # List all current traps

Important Considerations

Exit Status: Return appropriate exit codes from your cleanup function. Use exit 0 for successful termination and exit 1 or higher for errors.

Subshell Concerns: Traps don’t automatically apply to subshells. If you spawn child processes, they won’t inherit your trap unless you explicitly set them:

trap cleanup INT

(
    # This subshell won't have the trap
    sleep 30
) &

trap cleanup INT TERM

Avoiding Multiple Executions: If your cleanup is expensive or non-idempotent, guard against multiple invocations:

cleanup_done=0

cleanup() {
    if [ $cleanup_done -eq 1 ]; then
        return
    fi
    cleanup_done=1

    echo "Cleaning up..."
    # Your cleanup code
    exit 0
}

trap cleanup INT TERM

Preserving Script Output: The blank line in the original example accounts for the newline Ctrl-C produces in the terminal. This is helpful for readability but optional.

Real-World Example: Monitoring Script

#!/bin/bash

log_file="/var/log/monitor.log"
pid_file="/var/run/monitor.pid"

cleanup() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Shutting down..." >> "$log_file"
    rm -f "$pid_file"
    exit 0
}

trap cleanup INT TERM

echo $$ > "$pid_file"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] Started" >> "$log_file"

while true; do
    # Your monitoring logic
    load=$(uptime | awk -F'load average:' '{print $2}')
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] Load: $load" >> "$log_file"
    sleep 5
done

Use trap consistently in production scripts where graceful shutdown matters. It’s especially critical for scripts managing system resources, temporary files, or background processes.

2026 Comprehensive Guide: Best Practices

This extended guide covers Handling Ctrl-C Interrupts in Bash Scripts with advanced techniques and troubleshooting tips for 2026. Following modern best practices ensures reliable, maintainable, and secure systems.

Advanced Implementation Strategies

For complex deployments, consider these approaches: Infrastructure as Code for reproducible environments, container-based isolation for dependency management, and CI/CD pipelines for automated testing and deployment. Always document your custom configurations and maintain separate development, staging, and production environments.

Security and Hardening

Security is foundational to all system administration. Implement layered defense: network segmentation, host-based firewalls, intrusion detection, and regular security audits. Use SSH key-based authentication instead of passwords. Encrypt sensitive data at rest and in transit. Follow the principle of least privilege for access controls.

Performance Optimization

Troubleshooting Methodology

Follow a systematic approach to debugging: reproduce the issue, isolate variables, check logs, test fixes. Keep detailed logs and document solutions found. For intermittent issues, add monitoring and alerting. Use verbose modes and debug flags when needed.

These tools complement the techniques covered in this article:

Integration with Modern Workflows

Modern operations emphasize automation, observability, and version control. Use orchestration tools like Ansible, Terraform, or Kubernetes for infrastructure. Implement centralized logging and metrics. Maintain comprehensive documentation for all systems and processes.

Quick Reference Summary

This comprehensive guide provides extended knowledge for Handling Ctrl-C Interrupts in Bash Scripts. For specialized requirements, refer to official documentation. Practice in test environments before production deployment. Keep backups of critical configurations and data.

← All posts