imap-send Git Command Guide

The git imap-send command uploads a mailbox generated by git format-patch to an IMAP drafts folder, enabling patch submission through email clients that cannot read mailbox files directly.

git imap-send Syntax:

git imap-send [-v] [-q] [--[no-]curl] [(--folder|-f) <folder>]
git imap-send --list

Options:

Option	Description
-v, --verbose	Enable verbose output
-q, --quiet	Suppress output
--curl	Use curl for IMAP operations (default)
--no-curl	Avoid curl, use alternative methods
-f <folder>	Specify IMAP folder (Drafts default)
--list	List available IMAP folders

Parameters:

Parameter	Description
<folder>	IMAP folder name for draft patches

Configuration Setup:

IMAP Server Configuration:

# Configure IMAP server credentials
git config --global sendemail.smtpserver imap.gmail.com
git config --global sendemail.smtpencryption tls
git config --global sendemail.smtpuser your.email@gmail.com

# Configure IMAP settings (for imap-send)
git config --global imap.host imaps://imap.gmail.com
git config --global imap.user your.email@gmail.com
git config --global imap.pass your-app-password
git config --global imap.folder "[Gmail]/Drafts"

App Password Setup (Gmail):

# Generate application-specific password:
# 1. Go to Google Account settings
# 2. Security > 2-Step Verification > App passwords
# 3. Generate password for "Mail"
# 4. Use that password in imap.pass

Usage Patterns:

Basic Patch Upload:

# Generate patches and upload to IMAP
git format-patch --signoff --stdout origin/master | git imap-send

# Upload specific patches
git format-patch HEAD~3..HEAD --stdout | git imap-send

# Send single patch
git format-patch HEAD~1 --stdout | git imap-send

Configuration Examples:

Gmail IMAP Setup:

git config imap.host imaps://imap.gmail.com:993
git config imap.user your.email@gmail.com
git config imap.pass your-app-password
git config imap.folder "[Gmail]/Drafts"

Office 365/Outlook:

git config imap.host imaps://outlook.office365.com:993
git config imap.user user@company.com
git config imap.pass your-password
git config imap.folder "Drafts"

Custom IMAP Server:

git config imap.host imaps://mail.example.com:993
git config imap.user developer@example.com
git config imap.pass your-password
git config imap.folder "INBOX.Drafts"

Folder Management:

# List available folders
git imap-send --list

# Upload to specific folder
git format-patch --stdout HEAD~1 | git imap-send --folder "Patches"

# Use custom folder
git imap-send -f "[Patches]/Review"

Workflows for Patch Submission:

Review Workflow:

# Create patches for code review
git format-patch --cover-letter --signoff --stdout > patches.mbox

# Upload to IMAP for client access
cat patches.mbox | git imap-send

# Then access via email client to send

Continuous Integration:

#!/bin/bash
# Generate and upload patches automatically
if git format-patch --stdout origin/master > patches.mbox; then
    cat patches.mbox | git imap-send -q
    echo "Patches uploaded for review"
fi

Collaborative Workflow:

# Developer creates patches
git format-patch --signoff --cover-letter -n HEAD~5 > patches.mbox

# Upload for team access
cat patches.mbox | git imap-send --verbose

# Notify team
echo "Patches available in email drafts folder"

Security Considerations:

Authentication Security:

# Use app passwords instead of main account password
git config imap.pass "16-character-app-password"

# Enable two-factor authentication
# Use app-specific passwords or OAuth tokens

Transport Security:

# Ensure encrypted connections
git config imap.sslverify true
git config imap.preconnect "imaps://"

Access Control:

# Limit access to patch folders only
git config imap.folder "INBOX.Patches"

# Use read-only access where possible

Troubleshooting:

Connection Issues:

# Test IMAP connection
openssl s_client -connect imap.gmail.com:993

# Enable verbose logging
git imap-send --verbose --list

# Debug mode
GIT_IMAP_DEBUG=1 git imap-send --list

Authentication Problems:

# Check credentials
curl -v --url "imaps://imap.gmail.com:993" \
     --user "user@gmail.com:app-password" \
     --request "LIST \"\" \"*\""

# Test with openssl
openssl s_client -connect imap.gmail.com:993 -crlf

Mailbox Format Issues:

# Validate mailbox format
git format-patch --stdout > test.mbox
git imap-send < test.mbox  # Test upload

Server Compatibility:

# Check server capabilities
git imap-send --list | head -10

# Verify folder naming conventions
git imap-send --list | grep -i draft

Advanced Usage:

Custom Mailbox Processing:

# Process patches with attachments
git format-patch --attach --stdout | git imap-send

# Handle large patchsets
git format-patch --no-numbered --stdout origin/release | \
    split -l 1000 - patch- && \
    for part in patch-*; do cat "$part" | git imap-send; done

Error Handling:

#!/bin/bash
# Robust upload script
if command -v git >/dev/null && [ -d .git ]; then
    git format-patch --stdout --signoff > /tmp/patches.mbox
    if cat /tmp/patches.mbox | git imap-send -q 2>/dev/null; then
        echo "Patches uploaded successfully"
        rm /tmp/patches.mbox
    else
        echo "Upload failed - check IMAP settings"
        exit 1
    fi
fi

Caution

IMAP credentials stored in plain text. Use app-specific passwords or OAuth where available. Avoid using main account passwords.

Real-world Examples:

Open Source Contribution Flow:

# Fork main repository
git clone https://github.com/project/repo.git
cd repo
git checkout -b feature-fix

# Make changes and commit
echo "Fix applied" >> CHANGELOG.md
git add CHANGELOG.md
git commit -m "fix: update changelog"

# Generate signed patches
git format-patch --signoff --cover-letter -n origin/master > patches.mbox

# Upload to IMAP for review
cat patches.mbox | git imap-send

echo "Patches available in email drafts - open email client to send"

Kernel Development Workflow:

# Generate formal patches for linux-kernel
git format-patch --subject-prefix="PATCH v5" --to=linux-kernel@vger.kernel.org \
                --cc=maintainer@example.com --no-chain-reply-to origin/master

# Upload for review process
cat *.patch | git imap-send -f "Kernel-Patches"

echo "Kernel patches uploaded to drafts folder"
echo "Review and send via email client"

Tip

Configure IMAP settings globally for consistent usage. Use email clients for final patch sending after IMAP upload. Test configurations before important patch submissions.

How does imap-send improve email patch workflow?

Traditional patch emailing requires manual mbox file handling. imap-send uploads patches directly to email drafts, enabling review in comfortable email clients before sending.

Can I send patches without IMAP?

Yes, alternatives include git send-email for direct SMTP, or manual attachment of mbox files, or using webmail interfaces after manual copying.

Why does Git need format-patch integration?

format-patch creates proper email format with headers (From, Date, Subject) that imap-send preserves when uploading to IMAP folders for client consumption.

How do app passwords improve security?

App passwords are scoped to specific applications, can be revoked without changing main password, and provide audit trail of application access.

What happens to patches after IMAP upload?

Patches remain as drafts in IMAP folder. User must open email client, review content, and manually send. Provides opportunity for final editing in email client.

Can imap-send handle patches with attachments?

Yes, preserves attachment information from format-patch —attach. Email clients can properly display and handle attached binary files.

What’s the relationship to git send-email?

Both facilitate patch submission: imap-send for email client workflow, send-email for direct SMTP sending. Choose based on comfort with email client vs. command line.

How do I handle large patchsets?

For large changesets, break into smaller series using shorter revision ranges, upload individually, or use summarization techniques to avoid email size limits.

Can I automate imap-send in CI/CD?

Yes, with proper IMAP credentials and service account setup. Configure CI jobs to generate and upload patches automatically to dedicated folders.

What format fields are required for imap-send?

Patches must have From, Date, and Subject headers in correct order. format-patch generates this automatically, custom mbox files must comply.

How do I troubleshoot folder access issues?

Use —list to verify folder existence, check IMAP user permissions, confirm folder naming conventions (some servers require INBOX.Prefix format).

Can imap-send work with corporate email systems?

Yes, works with Exchange, Office 365, Gmail, and other IMAP-capable systems. Requires IMAP access enabled and app passwords for OAuth-only systems.

What’s the performance impact for large patch uploads?

Upload time depends on network speed and patch size. Large patchsets may require several minutes. Use —quiet to reduce output during automated usage.

How do I integrate imap-send with Gerrit review systems?

Upload patches to IMAP drafts, then send via email client configured with Gerrit address. Gerrit processes patches on receipt.

Applications of the git imap-send command

1. Collaborative Patch Review: Upload patches to shared IMAP folders for team review before submission
2. Open Source Contributions: Standard workflow for submitting patches to project mailing lists
3. Corporate Review Processes: Integrate with organizational email systems for code review workflows
4. Cross-Platform Compatibility: Work with any IMAP-capable email system regardless of Git client availability
5. Backup and Archival: Maintain patch collections in email system for permanent storage and easy searching
6. Integration with Email Workflows: Leverage existing email infrastructure for patch management and distribution