Lors de la configuration d'un projet WebRTC avec CMake, il est fréquent de rencontrer l'avertissement suivant : cmake warning at cmakelists.txt: srtp non trouvé, fonctionnalités WebRTC limitées. Bien que cela n'interrompe pas systématiquement la génération du projet, ce message indique que les mécanismes de chiffrement et de sécurité indispensables au protocole WebRTC ne seront pas activés correctement. Ce guide détaille comment automatiser la gestion de cette dépendance pour garantir une compilation robuste et sécurisée.

L'importance du protocole SRTP dans WebRTC

Le protocole SRTP (Secure Real-time Transport Protocol) est une extension du protocole RTP qui apporte des fonctionnalités de sécurité essentielles : chiffrement des données, authentification des messages et proteciton contre le rejeu. Dans l'écosystème WebRTC, l'intégrité et la confidentialité des flux audio et vidéo reposent entièrement sur SRTP. Si CMake ne parvient pas à localiser cette bibliothèque, les fonctionnalités de sécurité seront soit désactivées, soit dégradées, rendant l'application vulnérable ou incompatible avec les standards de communication modernes.

Les causes courantes de cette erreur incluent :

• L'absence de la bibliothèque de développement sur le système hôte.
• Une version incompatible (par exemple, SRTP 1.x alors que le projet requiert la version 2.x).
• Un chemin de recherche (CMAKE_PREFIX_PATH) mal configuré.

Comparaison des stratégies de gestion des dépendances

Pour résoudre ce problème, deux approches principales s'affrontent : l'utilisation des paquets système ou l'intégration directe des sources au build.

Pour les projets professionnels nécessitant une cohérence stricte entre les machines des développeurs et les serveurs d'intégration continue, l'utilisation du module FetchContent de CMake est fortement recommandée.

Implémentation technique avec FetchContent

L'objectif est de modifier le fichier CMakeLists.txt pour qu'il tente d'abord de trouver la bibliothèque sur le système, et qu'il la télécharge et la compile automatiquement en cas d'échec.

Voici comment structurer cette logique de manière moderne et efficace :

include(FetchContent)

# Option pour forcer la compilation locale si nécessaire
option(FORCE_LOCAL_SRTP "Compiler SRTP à partir des sources même si présent sur le système" OFF)

set(SRTP_REQUIRED_VERSION "2.4.2")

if(NOT FORCE_LOCAL_SRTP)
    find_package(SRTP QUIET)
endif()

if(NOT SRTP_FOUND)
    message(STATUS "SRTP local introuvable ou forcé. Téléchargement de la version ${SRTP_REQUIRED_VERSION}...")

    FetchContent_Declare(
        libsrtp_external
        GIT_REPOSITORY https://github.com/cisco/libsrtp.git
        GIT_TAG        v${SRTP_REQUIRED_VERSION}
        GIT_SHALLOW    TRUE
    )

    # Désactiver les tests de libsrtp pour accélérer le build
    set(ENABLE_OPENSSL ON CACHE BOOL "" FORCE)
    set(BUILD_WITH_UNIT_TESTS OFF CACHE BOOL "" FORCE)

    FetchContent_GetProperties(libsrtp_external)
    if(NOT libsrtp_external_POPULATED)
        FetchContent_Populate(libsrtp_external)
        add_subdirectory(${libsrtp_external_SOURCE_DIR} ${libsrtp_external_BINARY_DIR} EXCLUDE_FROM_ALL)
    endif()

    # Définition des variables de sortie pour le reste du projet
    set(SRTP_LIBRARIES srtp2)
    set(SRTP_INCLUDE_DIRS "${libsrtp_external_SOURCE_DIR}/include")
    message(STATUS "SRTP sera compilé depuis : ${libsrtp_external_SOURCE_DIR}")
endif()

Une fois la dépendance configurée, il convient de lier correctement les cibles de votre projet :

add_executable(mon_application_webrtc main.cpp)

target_include_directories(mon_application_webrtc PRIVATE ${SRTP_INCLUDE_DIRS})
target_link_libraries(mon_application_webrtc PRIVATE ${SRTP_LIBRARIES})

Optimisation pour l'intégration continue (CI)

L'intégration de la source directement dans le processus CMake apporte des bénéfices significatifs en environnement DevOps :

• Indépendance vis-à-vis de l'hôte : Plus besoin d'exécuter sudo apt-get install dans vos scripts Docker ou GitHub Actions. Le CMakeLists.txt devient auto-suffisant.
• Mise en cache : Les outils de CI peuvent mettre en cache le répertoire _deps généré par CMake, permettant des builds incrémentaux ultra-rapides après la première exécution.
• Stabilité : En verrouillant le GIT_TAG, vous vous assurez qu'une mise à jour de la distribution Linux du serveur ne cassera pas votre compilation suite à un changement de version d'une bibliothèque système.

Résolution des problèmes fréquents

Lors de la mise en place de cette configuration, certains obstacles peuvent survenir :

1. Conflits avec OpenSSL : SRTP utilise souvent OpenSSL pour les primitives cryptographiques. Assurez-vous que la version d'OpenSSL trouvée par CMake est compatible avec celle attendue par libsrtp. L'utilisation de set(ENABLE_OPENSSL ON) est généralement nécessaire si vous souhaitze bénéficier des performances matérielles.

2. Erreurs de symboles dupliqués : Si plusieurs dépendances de votre projet incluent leur propre version de SRTP, des conflits de symboles peuvent apparaître au moment de l'édition des liens. Dans ce cas, privilégiez une approche centralisée où SRTP est défini une seule fois au niveau du projet racine.

3. Échec de clonage Git : Dans certains réseaux restreints, le protocole Git peut être bloqué. Vous pouvez remplacer GIT_REPOSITORY par URL dans FetchContent_Declare pour télécharger une archive .tar.gz via HTTP, ce qui est souvent plus stable.

FetchContent_Declare(
    libsrtp_external
    URL      https://github.com/cisco/libsrtp/archive/refs/tags/v2.4.2.tar.gz
    URL_HASH SHA256=3142270967520e5d0a6c6d2c499c750b271f251c6e1fc08c4e0958f273062837
)

En adoptant cette méthode de gestion des dépendances, vous éliminez non seulement l'avertissement CMake, mais vous renforcez également la portabilité et la pérennité de votre projet WebRTC.