Synchronize contact pictures via CardDAV

OneTwoBarbecue

Hi everybody,

in my setup I'm synchronizing CardDAV contacts with vdirsyncer between Nextcloud and Grommunio. Everything is working fine so far.

But synchronization of contact pictures from Nextcloud to Grommunio fails somehow. When adding a contact picture in Grommunio, the picture is appended as BASE64-encoded JPEG in the vcf-file. Nextcloud relies on the ENCODED=B paramater which is basically the same. Therefore I transform these parameters before syncing via a bash script.
That way adding contact pictures in Grommunio and seeing them in Nextcloud works fine.
The other way round unfortunately doesn't work even though the vcf-format uploaded via vdirsyncer matches exactly the conventions given from Grommunio-CardDAV before. Instead when adding a picture in Nextcloud and syncing it to Grommunio with changing to ENCODE=BASE64 in the vcf-file before, the picture won't show up in Grommunio. When syncing again the picture is completely vanished from the vcf-file given by Grommunio-CardDAV.

Does anybody know why this is happening?

OneTwoBarbecue

Does really nobody have any ideas or similar problems in getting this to work?

Nerdine

OneTwoBarbecue

Could you provide your vdirsyncer config (please censor user and password)?

OneTwoBarbecue

Shure 🙂

Here are all the configurations and the script:

vdirsyncer.conf:

[general]
status_path = "~/Vdirsyncer-status/"

### KONTAKTE-BLOCK ###

# Konfiguration des lokalen Nextcloud-Kontakte-Verzeichnisses
[storage KontakteNextcloudLokal]
type = "filesystem"
path = "~/Kontakte/Nextcloud/"
fileext = ".vcf"

[storage KontakteGrommunioLokal]
type = "filesystem"
path = "~/Kontakte/Grommunio/"
fileext = ".vcf"

# Konfiguration des Grommunio-Kontakte-Verzeichnisses
[storage KontakteGrommunio]
type = "carddav"
url = "https://mail........."
username = ".........."
password = "..........."

# Konfiguration des Nextcloud-Kontakte-Verzeichnisses
[storage KontakteNextcloud]
type = "carddav"
url = "https://nextcloud......."
username = ".........."
password = "........."

# Kontaktesynchronisation von Grommunio mit lokal
[pair GrommunioKontakte]
a = "KontakteGrommunioLokal"
b = "KontakteGrommunio"
collections = [["KontakteSyncGrommunio", "Kontakte", "Kontakte"]]

# Kontaktesynchronisation von Nextcloud mit lokal
[pair NextcloudKontakte]
a = "KontakteNextcloudLokal"
b = "KontakteNextcloud"
collections = [["KontakteSyncNextcloud", "Kontakte", "kontakte"]]


### KALENDER-BLOCK ###

# Konfiguration des lokalen Kalender-Verzeichnisses
[storage KalenderLokalGrommunio]
type = "filesystem"
path = "~/Kalender/Grommunio/"
fileext = ".ics"

[storage KalenderLokalNextcloud]
type = "filesystem"
path = "~/Kalender/Nextcloud/"
fileext = ".ics"


# Konfiguration des Grommunio-Kalenders
[storage KalenderGrommunio]
type = "caldav"
url = "https://mail......."
username = "........"
password = "........."

# Konfiguration des Nextcloud-Kalenders
[storage KalenderNextcloud]
type = "caldav"
url = "https://nextcloud......."
username = "......."
password = ".........."

# Synchronisation GrommunioKalender und lokal
[pair GrommunioKalender]
a = "KalenderLokalGrommunio"
b = "KalenderGrommunio"
collections = [["GrommunioSync", "Kalender", "Kalender"]]

# Synchronisation NextcloudKalender und lokal
[pair NextcloudKalender]
a = "KalenderLokalNextcloud"
b = "KalenderNextcloud"
collections = [["NextcloudSync", "Kalender", "kalender"]]


### AUFGABEN-BLOCK ###

# Aufgaben lokal
[storage AufgabenLokal]
type = "filesystem"
path = "~/Aufgaben/"
fileext = ".ics"

# Aufgaben Nextcloud
[storage AufgabenNextcloud]
type = "caldav"
url = "https://nextcloud........"
username = "..........."
password = ".........."

# Aufgaben Grommunio
[storage AufgabenGrommunio]
type = "caldav"
url = "https://mail........."
username = ".........."
password = "..........."

# Paarung GrommunioMitLokal
[pair AufgabenGrommunioLokal]
a = "AufgabenLokal"
b = "AufgabenGrommunio"
collections = [["AufgabenSyncLokalGrommunio", "Aufgaben", "Aufgaben"]]

# Paarung NextcloudMitLokal
[pair AufgabenNextcloudLokal]
a = "AufgabenLokal"
b = "AufgabenNextcloud"
collections = [["AufgabenSyncLokalNextcloud", "Aufgaben", "aufgaben"]]

The script for swapping the ENCODING=BASE64-encoding to ENCODING=B:

#!/usr/bin/env bash
# =============================================================================
# GrommunioNextcloudCarddavPhotoSync.sh
#
# Synchronisiert zwei CardDAV-Server über lokale Adressbücher,
# wobei ENCODING=BASE64 ↔ ENCODING=B automatisch konvertiert wird.
#
# Architektur:
#
#   [Server A]  ←vdirsyncer→  [DIR_BASE64]  ←dieses Skript→  [DIR_B]  ←vdirsyncer→  [Server B]
#               (ENCODING=BASE64 bleibt)    (Konvertierung)  (ENCODING=B bleibt)
#
# Voraussetzungen: vdirsyncer, md5sum (coreutils)
# =============================================================================

set -euo pipefail

# ─── Konfiguration ────────────────────────────────────────────────────────────

VDIRSYNCER_CONFIG="${HOME}/.config/vdirsyncer/config"

DIR_BASE64="${HOME}/Kontakte/Grommunio/Kontakte"   # Lokales Adressbuch für Server A (ENCODING=BASE64)
DIR_B="${HOME}/Kontakte/Nextcloud/Kontakte"        # Lokales Adressbuch für Server B (ENCODING=B)

PAIR_BASE64="GrommunioKontakte/KontakteSyncGrommunio"               # Name des vdirsyncer-Paars für Server A
PAIR_B="NextcloudKontakte/KontakteSyncNextcloud"    # Name des vdirsyncer-Paars für Server B

STATUS_DIR="${HOME}/Skripte/GrommunioNextcloudCarddavPhotoHashes"  # Gespeicherte Hashes für Änderungserkennung
CONFLICT_DIR="${HOME}/Kontakte/Konflikte"    # Konflikt-Backups
LOG_FILE="${HOME}/Skripte/GrommunioNextcloudCarddavPhoto.log"

# Konfliktlösung bei echten Inhaltskonflikten: "a_wins" | "b_wins" | "newest"
CONFLICT_RESOLUTION="newest"

# ─── Initialisierung ──────────────────────────────────────────────────────────

mkdir -p "$DIR_BASE64" "$DIR_B" "$STATUS_DIR" "$CONFLICT_DIR" "$(dirname "$LOG_FILE")"

log() {
  local level="$1"; shift
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [${level}] $*" | tee -a "$LOG_FILE"
}

# ─── vCard-Hilfsfunktionen ────────────────────────────────────────────────────

# Normalisierter Hash: ENCODING=BASE64 und ENCODING=B werden gleichbehandelt.
# Dadurch erkennt das Skript Encoding-Unterschiede NICHT als inhaltliche Änderung.
normalized_hash() {
  sed 's/\bENCODING=BASE64\b/ENCODING=B/gI' "$1" \
    | sed 's/\r//' \
    | md5sum | cut -d' ' -f1
}

# ENCODING=BASE64 → ENCODING=B
convert_to_b() {
  local src="$1" dst="$2"
  sed 's/\bENCODING=BASE64\b/ENCODING=B/gI' "$src" > "$dst"
}

# ENCODING=B → ENCODING=BASE64  (nur isoliertes =B, nicht z.B. =JPEG)
convert_to_base64() {
  local src="$1" dst="$2"
  sed 's/\(ENCODING=\)B\b/\1BASE64/gI' "$src" > "$dst"
}

# Gespeicherten Hash lesen (leerer String = Datei war noch nie bekannt / gelöscht)
read_hash() {
  local hashfile="${STATUS_DIR}/${1}"
  [[ -f "$hashfile" ]] && cat "$hashfile" || echo "DELETED"
}

write_hash() {
  echo "$2" > "${STATUS_DIR}/${1}"
}

# ─── Schritt 1: Vdirsyncer mit beiden Servern synchronisieren ─────────────────

log "INFO" "════════════════════════════════════════"
log "INFO" "Starte CardDAV-Bridge-Sync"

log "INFO" "Sync: Server A (ENCODING=BASE64) ↔ ${DIR_BASE64}"


if ! vdirsyncer --config "$VDIRSYNCER_CONFIG" sync "$PAIR_BASE64" 2>&1 | tee -a "$LOG_FILE"; then
  log "WARN" "vdirsyncer $PAIR_BASE64 mit Fehlern beendet – fahre fort"
fi

log "INFO" "Sync: Server B (ENCODING=B) ↔ ${DIR_B}"
if ! vdirsyncer --config "$VDIRSYNCER_CONFIG" sync "$PAIR_B" 2>&1 | tee -a "$LOG_FILE"; then
  log "WARN" "vdirsyncer $PAIR_B mit Fehlern beendet – fahre fort"
fi

# ─── Schritt 2: Alle .vcf-Dateinamen aus beiden Verzeichnissen sammeln ────────

declare -A all_files

for f in "$DIR_BASE64"/*.vcf "$DIR_B"/*.vcf; do
  #[[ -f "$f" ]] && all_files["$(basename "$f")"]=1
  if [[ -f "$f" ]]; then
    all_files["$(basename "$f")"]=1
  fi
done

if [[ ${#all_files[@]} -eq 0 ]]; then
  log "INFO" "Keine .vcf-Dateien gefunden – nichts zu tun."
  exit 0
fi

log "INFO" "Verarbeite ${#all_files[@]} Kontakt-Datei(en)..."

count_a_to_b=0
count_b_to_a=0
count_deleted=0
count_conflicts=0
count_unchanged=0


# ─── Schritt 3: Bidirektionaler lokaler Abgleich ──────────────────────────────

for filename in "${!all_files[@]}"; do
  file_a="${DIR_BASE64}/${filename}"
  file_b="${DIR_B}/${filename}"
  key="${filename%.vcf}"   # Schlüssel für Status-Dateien (ohne .vcf)

  # Aktuelle normalisierte Hashes
  hash_curr_a=$([[ -f "$file_a" ]] && normalized_hash "$file_a" || echo "DELETED")
  hash_curr_b=$([[ -f "$file_b" ]] && normalized_hash "$file_b" || echo "DELETED")

  # Zuletzt bekannte Hashes
  hash_prev_a=$(read_hash "a_${key}")
  hash_prev_b=$(read_hash "b_${key}")

  # Änderungsflags
  changed_a=$([[ "$hash_curr_a" != "$hash_prev_a" ]] && echo true || echo false)
  changed_b=$([[ "$hash_curr_b" != "$hash_prev_b" ]] && echo true || echo false)


  # ── Entscheidungsmatrix ────────────────────────────────────────────────────

  if ! $changed_a && ! $changed_b; then
    # Keine Seite geändert
    # ((count_unchanged++))
    count_unchanged=$(( count_unchanged + 1 ))
    continue

  elif [[ "$hash_curr_a" == "$hash_curr_b" ]] && $changed_a && $changed_b; then
    # Beide geändert, aber Inhalt identisch (z.B. erster Lauf mit bereits
    # befüllten Verzeichnissen) → kein Konflikt, nur Hashes speichern
    log "INFO" "  Inhalt identisch (Encoding normalisiert): ${filename}"
    write_hash "a_${key}" "$hash_curr_a"
    write_hash "b_${key}" "$hash_curr_b"
    # ((count_unchanged++))
    count_unchanged=$(( count_unchanged + 1 ))

  elif $changed_a && ! $changed_b; then
    # Nur A geändert → nach B übertragen
    if [[ "$hash_curr_a" == "DELETED" ]]; then
      log "INFO" "  Löschung A → B: ${filename}"
      rm -f "$file_b"
      # ((count_deleted++))
      count_deleted=$((count_deleted + 1))
    else
      log "INFO" "  Neu/Geändert A → B: ${filename}"
      convert_to_b "$file_a" "$file_b"
      # ((count_a_to_b++))
      count_a_to_b=$((count_a_to_b + 1))
    fi
    new_hash_b=$([[ -f "$file_b" ]] && normalized_hash "$file_b" || echo "DELETED")
    write_hash "a_${key}" "$hash_curr_a"
    write_hash "b_${key}" "$new_hash_b"

  elif $changed_b && ! $changed_a; then
    # Nur B geändert → nach A übertragen
    if [[ "$hash_curr_b" == "DELETED" ]]; then
      log "INFO" "  Löschung B → A: ${filename}"
      rm -f "$file_a"
      # ((count_deleted++))
      count_deleted=$((count_deleted + 1))
    else
      log "INFO" "  Neu/Geändert B → A: ${filename}"
      convert_to_base64 "$file_b" "$file_a"
      # ((count_b_to_a++))
      count_b_to_a=$((count_b_to_a + 1))
    fi
    new_hash_a=$([[ -f "$file_a" ]] && normalized_hash "$file_a" || echo "DELETED")
    write_hash "a_${key}" "$new_hash_a"
    write_hash "b_${key}" "$hash_curr_b"

  elif $changed_a && $changed_b; then
    # Echter Inhaltskonflikt – Backups anlegen
    log "WARN" "  KONFLIKT erkannt: ${filename}"
    [[ -f "$file_a" ]] && cp "$file_a" "${CONFLICT_DIR}/${key}.$(date '+%Y%m%d_%H%M%S').a.vcf"
    [[ -f "$file_b" ]] && cp "$file_b" "${CONFLICT_DIR}/${key}.$(date '+%Y%m%d_%H%M%S').b.vcf"
    # ((count_conflicts++))
    count_conflicts=$((count_conflicts + 1))

    # Konfliktlösung anwenden
    case "$CONFLICT_RESOLUTION" in
      a_wins)
        log "WARN" "  Konflikt → A gewinnt: ${filename}"
        if [[ -f "$file_a" ]]; then
          convert_to_b "$file_a" "$file_b"
        else
          rm -f "$file_b"
        fi
        ;;
      b_wins)
        log "WARN" "  Konflikt → B gewinnt: ${filename}"
        if [[ -f "$file_b" ]]; then
          convert_to_base64 "$file_b" "$file_a"
        else
          rm -f "$file_a"
        fi
        ;;
      newest)
        # Neuere Datei (mtime) gewinnt
        if [[ -f "$file_a" && -f "$file_b" ]]; then
          if [[ "$file_a" -nt "$file_b" ]]; then
            log "WARN" "  Konflikt → A (neuer) gewinnt: ${filename}"
            convert_to_b "$file_a" "$file_b"
          else
            log "WARN" "  Konflikt → B (neuer) gewinnt: ${filename}"
            convert_to_base64 "$file_b" "$file_a"
          fi
        fi
        ;;
    esac

    new_hash_a=$([[ -f "$file_a" ]] && normalized_hash "$file_a" || echo "DELETED")
    new_hash_b=$([[ -f "$file_b" ]] && normalized_hash "$file_b" || echo "DELETED")
    write_hash "a_${key}" "$new_hash_a"
    write_hash "b_${key}" "$new_hash_b"
  fi

done

log "INFO" "Lokaler Abgleich:"
log "INFO" "  A → B:     ${count_a_to_b}"
log "INFO" "  B → A:     ${count_b_to_a}"
log "INFO" "  Gelöscht:  ${count_deleted}"
log "INFO" "  Unverändert: ${count_unchanged}"
log "INFO" "  Konflikte: ${count_conflicts}"

# ─── Schritt 4: Lokale Änderungen zurück zu den Servern pushen ────────────────

if (( count_b_to_a > 0 || count_deleted > 0 )); then
  log "INFO" "Push Änderungen → Server A"
  vdirsyncer --config "$VDIRSYNCER_CONFIG" sync "$PAIR_BASE64" 2>&1 | tee -a "$LOG_FILE" || \
    log "WARN" "Push zu Server A mit Fehlern beendet"
fi

if (( count_a_to_b > 0 || count_deleted > 0 )); then
  log "INFO" "Push Änderungen → Server B"
  vdirsyncer --config "$VDIRSYNCER_CONFIG" sync "$PAIR_B" 2>&1 | tee -a "$LOG_FILE" || \
    log "WARN" "Push zu Server B mit Fehlern beendet"
fi

# ─── Abschlussbericht ─────────────────────────────────────────────────────────

if (( count_conflicts > 0 )); then
  log "WARN" "ACHTUNG: ${count_conflicts} Konflikt(e) → bitte prüfen: ${CONFLICT_DIR}"
fi

log "INFO" "Sync abgeschlossen."

Any ideas why uploading contact pictures from Nextcloud to Grommunio won't work?