Coverity overview

Coverity Documentation

Version: 2026.6

Acknowledgements
Coverity overview
Preface
The static analysis solution
Checkers
Deployment architecture
Central analysis
Local and central analysis
Advantages of multiple testing models
Deployment options
Combining results from Coverity and other analysis tools
Working with static analysis
Roles and responsibilities
Basic workflow
Setup
Configure
Analysis
Organize, Triage, and Resolve
Report
Customizing and extending static analysis
Use cases
Securing web applications
Addressing coding standards violations
Using Coverity to differentiate your product in the marketplace
Assessing security of unfamiliar source code
Documentation for installation
Documentation set
Online resources
Installation and deployment
Coverity product overview
Supported platforms
Installation and deployment overview
Deployment planning overview
Implementation overview
Operation overview
Deployment planning
Deployment checklist
How Coverity products integrate into a build system
Coverity integrations and APIs
Command line clients
Plug-ins and other integrations
API reference
Coverity Analysis deployment models
Central build deployment model
Desktop deployment model (local analysis)
Coverity Connect deployment options
Coverity Connect stand-alone deployments
Coverity Connect clustered deployment model
Recommended maximum limits in Coverity Connect
Other deployment models and features
Clean before check-in
Integration with Jenkins automated builds
Export issues
Upgrading Coverity
Upgrade overview
Understand product names and installer contents
Download installers and documentation
Understand the impact of changed features for your upgrade
Adjust performance settings
Upgrade Coverity Connect
Upgrade Coverity Analysis
Upgrade Coverity Desktop plug-ins
Upgrading Coverity
Upgrade overview
Understand product names and installer contents
Download installers and documentation
Understand the impact of changed features for your upgrade
Adjust performance settings
Upgrade Coverity Connect
Upgrade Coverity Analysis
Upgrade Coverity Desktop plug-ins
Coverity Connect
Coverity Connect user guide
Coverity Connect usage
Getting started with Coverity Connect
Coverity Connect interface
Understanding the primary Coverity Connect workflows
Development workflow
Management workflow
Finding issues
Searching for issues by CID
Using views to find issues
Managing issues
Show Source Gutter Menu
File tree
Triaging issues
Event-driven triage notifications
Modern UI (beta)
Switching to the modern UI
Triaging issues
AI-Assisted Triage Plug-in (beta)
Deploying and configuring the AI-Assisted Triage Plug-in
Generating a key pair
Configuring authentication secrets
Configuring LLM API keys
Uninstalling AI-Assisted Triage Plug-in
Changing LLM provider
Navigation and features
Monitoring issues
Dashboards
View-level charts
Coverity Connect user reference
Views
Issues: By Snapshot
Issues: Project Scope
Files
Functions
Components
Checkers
Owners
Snapshots
Trends
Tests
View management
Edit Settings
Save as a copy
Filters
Group By
Columns
Snapshot scope
Sharing
Relative user
Notification
Delete
Export CSV
Export XML
Get Link
Snapshot comparison
Snapshot comparison scope grammar
Snapshot selection grammar usage notes
Grammar for time filter usage
Examples
View-specific Email notifications
Email notifications use cases
Scenario: Weekly team Email to reflect all outstanding issues for the release
Scenario: User specific Email to catch each new software issue
Scenario: Email to single user illustrating newly triaged issues
Scenario: Notification upon completed commit
Scheduling a view-specific Email notification
Manually triggering a notification Email
Triage attributes
Classification
Severity
Action
Legacy
Fix target
Owner
Ext. reference
Comment
Preferences
Coverity Platform overview
Installation, product licenses, and supported platforms
Login
Shared navigation and Main Menu tools
Help menu
Keyboard shortcuts
Product downloads
Customer feedback for Coverity
Coverity Connect platform details
Coverity Connect documentation set
Coverity Policy Manager usage
Coverity Policy Manager overview
Hierarchies
Metrics
Filters
Reports
Dashboards
Heatmaps
Policies
Summary metrics
Views
Using Coverity Policy Manager hierarchies
Navigating through charts
Performing common Coverity Policy Manager actions
Setting up Coverity Policy Manager dashboards
Setting up Coverity Policy Manager heatmaps
Setting up Coverity Policy Manager status reports
Setting up Coverity Policy Manager trend reports
Coverity Policy Manager metrics
Metrics: user activity
Metrics: analysis
Metrics: code
Summary metrics: technical debt
Coverity Policy Manager filter and segmentation properties
Coverity Connect administration
Configuring and managing the Coverity Connect server
Configuring Coverity Analysis updates
Storage capacity and management
Developer workflow
External network access
Configuring global owner assignment rules
Integrating with Jira
Requirements
Configuring Jira export
JIRA server configuration
Project mapping
Adding a project mapping
Assigning a Reporter when using Jira Cloud
Using templates for the Constant static field
Integrating with other (non-JIRA) bug tracking systems
Requirements
Bugzilla server configuration
Configuring the project mapping from Coverity Connect to Bugzilla
Maintaining or replacing project mappings
Variable substitution
Example: Map Coverity fields to Bugzilla fields
Connecting to a Bugzilla instance using SSL
Configuring custom checker descriptions
Configuring custom issue categories
Issue categorization map JSON format
Configuring sign-in settings
Configuring a local password policy
Configuring the soft lockout policy
Configuring Coverity Connect for TLS/SSL
Updating an expired TLS/SSL certificate for Coverity Connect
Before you begin to update the TLS/SSL certificate: Preparation and essential concepts
Scenarios for updating TLS/SSL certification
Scenario 1. Certificate renewal: Reusing the existing keystore and private key
Scenario 2. Replacing the keystore
Scenario 3. No existing keystore
Restarting Coverity Connect and verifying the new certificate
Updating TLS/SSL: Additional tips, warnings, and information
Commit encryption use cases
Update encryption handling for Coverity Connect
Sign-on methods for Coverity Connect
Integrating with LDAP servers
LDAP server requirements
Read-only access to LDAP data
LDAP server types
LDAP server configuration overview
Configuring LDAP server settings
LDAP security
Upgrading LDAP server configuration settings
Stopping and starting Coverity Connect
LDAP debugging tools
Configuring Coverity Connect to use Kerberos
Kerberos overview
Key concepts
Setup
Configuring the browser
Troubleshooting Kerberos authentication
Configuring Coverity Connect to use SAML
Logging in with SAML SSO
Logging out of SAML SSO
Adding a SAML SSO Configuration
SAML SSO configuration parameters
Creating a SAML SSO configuration
Associating an SAML SSO configuration with an individual Coverity Connect user
Removing an SAML SSO configuration
Support for auto-filled user information with SAML SSO
Adding and configuring a reverse proxy server
Setup using Apache HTTP server
Adding reverse proxy authentication
Coverity Connect license information
Analysis license files
Configuring Email notification and delivery
Setting up component subscription notification
Setting the maximum included defects in notification Emails
Changing the URL for Email notifications
Configuring Coverity Connect with an SSL-enabled Email server
Configuring your default Email to send view-specific notification Emails
Configuring logging
Coverity Connect log files
Enhanced usage logging
Collecting and delivering use and compliance data (UDC)
Administering use and compliance data
Disabling collection of use and compliance data
Enabling issue export by URL or export defect handler
Increasing the timeout duration for a custom defect handler
Disabling project dashboards in the Coverity Connect interface
Specifying commit options
System diagnostics
System diagnostics overview
Custom database queries
Securing Coverity Connect
Health check
Enabling Secure Code Warrior
Configuring a custom banner
Enabling collection of scan transparency data
Configuring and managing the database
Important notes
Maintaining the size of a database
Database optimization
Database cross-reference deduplication
Purge snapshot details
Configuring purge snapshot details
Important upgrade notes
Backing up an embedded database
Important notes about backing up an embedded database
Backing up an embedded database using the Coverity Connect UI
Using the command line to back up an embedded database
Restoring an embedded database
Client-side TLS/SSL certificate management
SSL Overview
TLS/SSL key concepts
Server certificate use cases
Improvements in certificate management
Self-signed certificates and trust-first-time TLS/SSL
Types of Coverity truststores
Procedures for propagating CA certificates
Obtaining the CA's certificate
Testing WebSocket connectivity
Set up Coverity Connect to use a context path
Managing users, groups, and roles
Managing users
Setting up a local or LDAP user
Editing a local or LDAP user
Assigning a user to a group
Managing roles for a user
Locking and unlocking a user account
Unlocking all temporarily locked user accounts
Disabling a user account
Deleting a user
Importing users
Limiting the scope of data collection
Working with authentication keys
Creating keys
Using keys
Viewing and revoking keys
Authentication keys use cases
Managing groups
Built-in groups
Setting up a group
Assigning one or more users to a group
Managing roles for a group
Editing a group
Importing LDAP groups
Deleting a group
Roles and role-based access control
Key concepts
Coverity Connect permissions
Coverity Connect roles
Understanding how Coverity Connect applies roles
Assigning RBAC roles on a synchronized Coverity Connect cluster
Primary projects and stream links
RBAC use cases
Scenario: Granting triage permissions on a synchronized Coverity Connect enterprise cluster
Scenario: Delegating project management
Scenario: Limiting access for project and stream administration
Scenario: Managing roles through primary projects
Scenario: Granting access to create streams
Scenario: Restricting project access for Coverity Desktop users
Scenario: Elevating the permissions of a role
Guidelines for restricting access
Enabling role-based access control over component maps
Managing data on software issues
Working with projects and streams
Planning your project and stream configuration
Creating, copying, and deleting projects and streams
Setting up projects
Setting up streams
Associating a stream with multiple projects
Copying and deleting projects and streams
Exporting and importing streams
Assigning roles per project or stream
Selecting an issue categorization map for a stream
Associating an analysis license with a project
Using search filters to find projects and streams
Editing projects and streams
Associating a stream with a project
Managing daily trend records at the project level
Designating a stream for auto-deletion of expired streams
Managing snapshots of streams
Viewing snapshot data
Deleting snapshots
Setting automatic issue ownership in streams
Setting desktop analysis options for streams
Configuring triage attributes
Creating a custom triage attribute
Custom attribute limits
Copying a triage attribute
Editing triage attributes
Using components
Configuring components
Importing and exporting component maps
Exported component map JSON elements
User Scenarios: Components
System overview
Scenario: Component configuration
Scenario: User work-flow
Assigning roles to a component map
Managing triage stores
Scenario: Sharing triage data across code branches (recommended)
Scenario: Separating triage data by code branch
Scenario: Separating triage data in product-based projects
Configuring triage stores after upgrading from version 6.0 or 6.0.1
Exported triage store JSON elements
Configuring legacy issues
Setting all new issues to legacy status
Creating legacy issues after upgrading Coverity Analysis
Working with legacy issues in Coverity Connect
Configuring automatic owner assignment
Overview of the automatic owner assignment process
Setting global SCM rules and the SCM user map
SCM derivation rules
Configuring the SCM to Coverity Connect user map
Setting stream-level rules
Custom coding standards
Adding a custom coding standard
Uploading a new custom coding standard
Downloading a coding standard file
Downloading the template file
Updating a custom coding standard
Renaming a custom coding standard
Hiding or restoring a standard
Deleting a custom coding standard
Configuring Coverity Connect enterprise clusters
Synchronizing multiple Coverity Connect instances
Synchronizing data across the cluster
Configuring data synchronization across the cluster
Identifying the coordinator and subscribers
Setting up SSL certificates and TrustStores
Synchronizing Coverity Policy Manager data across the cluster
Managing multiple database instances
Workflow for backing up databases in a cluster
Workflow for restoring databases in a cluster
Configuring a server to support Code Sight
Server administration for the Black Duck Code Sight plug-in
Configuring a Coverity Connect server to support Code Sight clients
Server administration for Desktop Analysis
Setting up streams
Creating analysis summaries
Summary expiration
Desktop Analysis usage tracking
Analysis license service
Coverity Connect URL construction
Exported defect output
Exported defect URL variables
Exported defect XML elements
Exported defect XML file
Suppressing built-in views for new users
Changing the date format display in Coverity Connect
Configuring Coverity Desktop through Coverity Connect
Configuring Coverity Desktop and shared files through the Downloads page
Configuring the Coverity Connect Downloads page
Adding Coverity Analysis to the Downloads page
Adding Coverity Desktop updates
Adding and removing custom files
Coverity Policy Manager administration
Managing a Coverity Policy Manager hierarchy
Planning a hierarchy
Configuring a hierarchy
Creating a hierarchy
Editing a hierarchy
Importing/exporting a Coverity Policy Manager hierarchy
Scheduling the Extract Transform Load (ETL) process
Truncating ETL data
Creating summary metrics
Coverity Policy Manager roles and permissions
Coverity Connect commands
cov-admin-db
Synopsis
Log file
Description
General options
Backing up and restoring an embedded database
Checking database integrity
Optimizing an embedded database
Preparing the Connect database to send to Black Duck
Tuning Coverity Connect for your environment
Upgrading the database
Exit codes
cov-archive
Description
Options
Limitations and considerations
Examples
Exit codes
cov-get-certs
Synopsis
Description
Options
Example
Exit codes
cov-im-ctl
Synopsis
Description
Options
Examples
Exit codes
cov-import-cert
Synopsys
Description
Options
Exit codes
cov-manage-im
Synopsis
Description
Defects mode
Projects mode
Streams mode
Triage mode
MOTD mode
Commit mode
Notification mode
Authentication key mode
Common OUTPUT options
CONNECTION options
Shared options
Exit codes
cov-start-im
Synopsis
Description
Exit codes
cov-stop-im
Synopsis
Description
Exit codes
cov-support
Synopsis
Description
Options
Example
Exit codes
Coverity Connect exit codes
Installation and upgrade
Coverity Connect network connectivity requirements
Coverity Connect hardware
Database size guidelines
Installing Coverity Platform components
Downloading the Coverity Platform installer from the Black Duck repository
Installing Coverity Connect
Coverity Platform installer modes
Selecting an installer mode
Coverity Platform graphical installer
Coverity Platform silent installer
Advanced installation options
Using an external PostgreSQL database with Coverity Connect
Understanding database information in the cim.properties file
Changing the limit on active connections to the database pool
Optimizing JVM utilization of additional RAM in config/system.properties
Changing the number of concurrent commits
Concurrent commit requirements
Post-installation notes
Important recommendations
Getting Coverity Connect licensing information
Installing multiple Coverity Connect licenses
Stopping and starting Coverity Connect
Changing the Coverity Connect owner
Installing Coverity Reports
Coverity Reports installer modes
Selecting an installer mode
Coverity Reports silent installer
Coverity Connect system tuning, maintenance, and monitoring
Post-installation: What's next?
cov-analysis configuration and set-up
cov-platform system configuration and set-up
The Coverity deployment maturity model
Coverity Connect system and database tuning
PostgreSQL database tuning: embedded database
Modifying the database configuration file
Windows limitations
Maintaining and backing up the database
JVM settings
Required JVM settings
Optional JVM settings
Monitoring and diagnosing Coverity Connect performance
Linux monitoring and diagnosis tools
Diagnosing performance problems
Diagnosing I/O problems
Windows monitoring and diagnosis tools
Using the Performance Monitor to diagnose Coverity Connect issues
System performance reference
Build
Analysis
Commit
Presenting Coverity Connect application metrics in open-source data acquisition and monitoring software
Making metrics available
Enabling logging for metrics
Setting up metrics presentation
Coverity Connect application metrics
Connect UI System Totals list
Upgrading Coverity Connect
Upgrading instances that use an embedded database
Choosing the type of upgrade
Performing the upgrade: standalone deployments
Upgrade Prerequisites for standalone deployments
Performing an in-place upgrade (standalone instances)
Performing a backup-and-restore upgrade (standalone instances)
Performing an intermachine upgrade (standalone instances)
Performing the upgrade: clustered deployments
Important information for clustered deployments
Upgrade prerequisites for clustered deployments
Performing an in-place upgrade (clustered instances)
Performing a backup-and-restore upgrade (clustered instances)
Performing an intermachine upgrade (clustered instances)
Upgrading instances that use an external database
Upgrading in place on an instance that uses an external database
Upgrading with backup-and-restore on an instance that uses an external database
Coverity Connect upgrade environment variable parameters
Upgrading Coverity Desktop
Upgrading Coverity Desktop for Eclipse and Wind River
Upgrading Coverity Desktop for Visual Studio
Upgrading Coverity Desktop for IntelliJ and Android Studio
Rolling back from backup-and-restore or intermachine upgrades to the previous Coverity Connect version
Coverity product components: supported versions and compatibility
Supported platforms for Coverity Connect and Coverity Reports
Coverity Analysis
Coverity Analysis overview
Getting started with Coverity Analysis
Roles and responsibilities
Use cases
Capture models you can use
Security considerations for running Coverity scans
Performing an analysis in a Coverity cloud deployment
Introduction to analyses within a Kubernetes cluster in the Cloud
Thin Client language support
Installing client software
Installing Coverity Thin Client on a client system
Installing the full Coverity Analysis client on a client system
Using the Black Duck Bridge CLI to integrate Thin Client analysis into pipelines
Creating a project and stream
Performing an analysis: in-cloud vs on-prem
Creating a Coverity configuration file
Setting up TLS and certificates for analysis in the cloud
Configuring client authentication with the cluster
Analysis location
Specifying an asynchronous or synchronous analysis
Scan workflows
Initiating a scan in the cloud
About Scan Service cache in Kubernetes
Cache key
Preparing to initiate Scan Service analyses from the full client
Managing and viewing the status of analyses performed in the cloud
Opening the Scan List view
The Scan List view
Cancelling a scan
Downloading logs and reports
Annunciations
Analysis with Coverity Checkers
Using the Black Duck Bridge CLI to integrate Coverity full Analysis into pipelines
Steps to generate an analysis
Prerequisites
The configuration
The capture
Build capture (for compiled languages)
.NET build capture
The analysis
The commit
Viewing issues
Analyzing source code interactively
Coverity Analysis steps: Further information
The configuration: Invoking 'cov-configure'
The capture: Build options by language
The capture: Examples
The capture: Further notes on build capture
The analysis: Special cases
The analysis: Analysis Summary Report
Tasks that support Coverity analyses
Enabling or disabling checkers
Using custom models to improve analysis results
Using models to mimic functions or methods that lack source code
Using models to tune the interprocedural analysis
Using Coverity Analysis configuration files in the analysis
Using alternative configuration file names and directories
Specifying command-line options in the configuration file
Using the <cim> tag to specify commit options
Using the <prevent> tag to specify directories and emit options
Changing a configuration for a compiler
Running web application security analyses
Running a security analysis on a Java web application
Emit web application archives or directories (build capture only)
Running a security analysis on an ASP.NET web application
Capturing an ASP.NET Core (2.0 or later) web application
Capturing an ASP.NET (4.0 or earlier) web application
Running mobile application security analyses
Running a security analysis on an Android mobile application
Java Android applications
Kotlin Android applications
Hybrid (Java and Kotlin) Android applications
Running a security analysis on an iOS mobile application (Swift)
Running a security analysis on an Android or iOS mobile application (Dart)
Running coding-standard analyses
Coding-standard analysis guidelines
Running Fortran Syntax Analysis
Using advanced analysis techniques
Incremental, parallel, and desktop analysis
Incremental analysis
Parallel analysis
Desktop analysis
Running analysis as part of a CI/CD pipeline
Environment variables for analysis configuration
Using 'cov-analyze' options to tune the analysis
Running an analysis without 'cov-build'
Using the 'cov-make-library' command
Determining which functions are analyzed and called
Suppressing macro expansion to improve modeling
Adding a prototype for a function
Running analyses that use derived models for C and C++ source code
Configuring compilers for Coverity Analysis
Generating a template configuration
Generating a full configuration
Using 'ccache' or 'distcc'
Compiler-specific configurations
Clang compiler
Supported Language Extensions
Supported Compliance Standards for Clang Compilers
Clang Limitations
CEVA compiler
Embarcadero C++ compiler
Freescale Codewarrior compiler
GNU compilers
Green Hills compiler
HighTec compiler
Intel oneAPI compiler
Keil compiler
Microchip compiler
Microsoft Visual C and C++ compiler
PICC compiler
QNX compiler
Qualcomm Kalimba C compiler
Renesas compiler
STMicroelectronics compiler
Sun (Oracle) compiler
Synopsys MetaWare compiler
Tensilica Xtensa C and C++ compiler
Texas Instruments C and C++ compilers
Trimedia C and C++ compilers
Using predefined macros for Coverity Analysis-specific compilations
Modifying preprocessor behavior to improve compatibility
Coverity language support
Setting up Coverity Analysis for a production environment
The central deployment model
Coverity Analysis deployment considerations
Sensitive data might persist on a local machine
Integrating Coverity Analysis into a build system
The intermediate directory
Integrating Coverity Analysis into the build environment—'cov-build'
The output of 'cov-build': The 'build-log.txt' log file
Building non-ASCII source code
Detecting parse warnings, parse errors, and build failures
Viewing parse errors
Preprocessing source files
Building with preprocessing first
Testing hypotheses
Re-running failed compiles without re-running the build
Getting linkage information
Record/Replay: Deferred builds and parallelizing single-process builds
Running 'cov-build' with '--record-only'
Running 'cov-build' with '--record-with-source'
Error handling with commands
Troubleshooting build problems
Platform-specific 'cov-build' issues
Linux
Solaris
Windows
FreeBSD
AIX
Alternative build command: 'cov-translate'
The 'cov-translate' command in place of the native compiler
Running parallel builds
Single build on a single machine
Multiple builds on a single machine
Multiple builds on multiple machines
Sharing a common intermediate directory on an NFS partition
Copying intermediate directories from local disks
Using TLS/SSL with Coverity Analysis
TrustStore overview
Security considerations for TLS/SSL certificates
Configuring Coverity Analysis to use TLS/SSL
Working with the TrustStore
Viewing trust-first-time Certificates
Viewing Certificate Authority certificates
Interpreting a certificate file
Adding a certificate to ca-certs.pem
Removing a trust-first-time certificate from the TrustStore
Removing certificates from ca-certs.pem
Using remote worker jobs to manage resource constraints
Fields for remote worker SSH configuration
Using a network file system (NFS) with Coverity Analysis
Coverity Analysis updates
Capturing specific build systems
Building with Xcode
Building Xcode projects that use pre-compiled headers
Building projects that use the Apple modern build system for Xcode 11
Building Projects that use Xcode 10
Building with Visual Studio or .NET SDK (‘dotnet’)
Building with Cygwin
Incorporating SCM data
Using coverage data import and extract utilities
Adding files under a directory hierarchy
Basic workflow
Caching files to leverage previous SCM processes
SCM revision format
Files without SCM data
Building with Bazel
Requirements and limitations
Enabling build capture
Install Coverity Analysis
Configure compilers
Performing the build
Customization: Compilation mnemonics
Analysis with Sigma checkers
Importing analysis results from Rapid Scan Static (Sigma)
Upgrading Sigma
Using the Compiler Integration Toolkit (CIT)
Compiler integration overview
Before you begin
Basic requirements
The Coverity Analysis build system
The 'cov-configure' command
The 'cov-translate' command
The 'cov-preprocess' command
The 'cov-test-configuration' command
Understanding the compiler configuration
<compiler> tags in 'coverity_config.xml'
<options> tags in 'coverity_config.xml'
Tags for native preprocessing
Tags for skipping compilations
Tags that influence translation
Tags for transforming the native command line to the Coverity compiler
Tags for phases of command-line transformations
Tags for internally passing information from 'cov-build'
Tags for handling response files
Tags for processing commented lines in response files
Tags for directing which groups the options are applied to
Editing the Coverity configuration file—'coverity_config.xml'
Using the Compiler Integration Toolkit (CIT)
The Compiler Integration Toolkit (CIT) compiler configuration file
<cit_version> tag
<compiler> and <variant> tags
<options> tags specific to the Compiler Integration Toolkit (CIT)
Tags for invoking the native compiler and probing
<config_generic_info> tags
Test tags
Additional configuration tags
The compiler switch file
Compiler compatibility header files
Custom translation code
Creating a Compiler Integration Toolkit (CIT) configuration for a new compiler
Creating a compiler from an existing Compiler Integration Toolkit (CIT) implementation
Configuration format for derived compilers
Derived switch files and compat header files
Troubleshooting the build integration
Why is no build log generated?
I see a header file error: expected an identifier
I see a header file error: expected a ';'
Why is the standard header file not found?
I see the message: #error No Architecture defined
Using the Third Party Integration Toolkit
Third Party Integration Toolkit overview
Running the Third Party Integration Toolkit
Import file format and reference
Import file format examples
Import format reference
Capacity and performance
Troubleshooting Coverity Analysis
Windows systems
All operating systems
Using Cygwin to invoke 'cov-build'
Finding third-party licenses
Incompatible #import attributes
Safety Manual
Introduction to developing safety-related software
Third-party software
Failure modes
Coverity Security Dynamic Analysis
Coverity Template Dynamic Analysis
Coverity Analysis engine
Coverity Connect and Coverity Desktop
Inclusion of Cybersecurity
Applicable standards and scope
Tool error detection
Standards compliance
Documentation and support
Coverity Fortran Syntax Analysis User Guide
Introduction to Coverity Fortran Syntax Analysis
What does Coverity Fortran Syntax Analysis do?
Why Use Coverity Fortran Syntax Analysis?
Application Areas
This manual
Tutorial
Basic Operation
Analyzing a single source file
Enabling Warning and Information Messages
Producing a source listing with cross-references
Analyzing more than one source file
Analyzing all source files in one or more directories
The program analysis
The reference structure or call tree
The module dependency tree
Using library files
Using modules
Using third-party libraries
Portability and conformance to standards
Standard conformance
Compiler emulation
Setting your own, or company standard
Cross-platform development
Using include files
Multi-platform development
Operation
Using Coverity Fortran Syntax Analysis
Specifying a list file
Specifying a library file
Options
Configuration selection options
Other control options
Program-unit analysis
Global program analysis
Output
Library
Miscellaneous
Defaults
The usage of analysis options
Exit status
The usage of include files
Coverity Fortran Syntax Analysis library files
The usage of modules
Maintaining library files
Maintaining library files in command mode
Examples
The usage of language extensions
Compiler emulation and include files
Generating Fortran 90 interfaces
Operation of interf from the commandline
Storing the Reference structure and dependency of modules
Messages
Operational messages
Analysis messages
System messages
Redefinition and suppression of messages
Temporary suppression of messages
Reporting messages
Tuning the output
Line or statement numbering
Date and time format
Analysis
Program unit analysis
Interpretation of source code records
Lay-out of source code listing
Syntax analysis
Type verification
Local verification of argument lists
Verification of procedure entries
Intrinsic procedures
Function procedure
Program-unit cross references
Reference structure (Call tree)
Analysis of the reference structure
Display of the reference structure
Display of sub trees of the reference structure
Reference structure in XML format
Display of module dependencies
Display of dependencies for specific modules
Display of module dependencies in XML format
Global program analysis
Verification of procedure references
Verification of argument lists
Verification of common blocks
Verification of modules
Global program cross references
Cross references of common-block objects
Cross references of public module derived types
Cross references of public module data
Specification of procedure interfaces
Using FORTRAN 77 syntax
Using Fortran 90 syntax
Using Coverity Fortran Syntax Analysis attributes
Metrics
Final report
Supported Fortran syntax
Compilers supported
General language extensions supported
Absoft Fortran 77 extensions
Apollo/Domain Fortran extensions
Compaq Fortran extensions
Convex Fortran extensions
Cray Fortran 77 extensions
Cyber NOS/VE Fortran extensions
DEC PDP-11 Fortran-77 extensions
DEC FORTRAN and VAX Fortran extensions
Digital Research Fortran-77 extensions
F2c Fortran 77 extensions
GNU Fortran 77 extensions
HP-UX FORTRAN/9000 and HP Fortran 77 extensions
IBM AIX XL FORTRAN extensions
IBM VS Fortran V2 extensions
Intel Fortran extensions
Lahey F77L Fortran-77 extensions
Microsoft Fortran extensions
NDP Fortran extensions
Oracle Fortran extensions
Prime Fortran-77 extensions
Salford Fortran extensions
Silicon Graphics MIPSpro Fortran 77 extensions
Sun Fortran 77 extensions
Unisys 1100 Fortran-77 extensions
Watcom Fortran 77 extensions
The configuration file
EXTENSIONS
INTRINSICS
OCI (OPEN/CLOSE/INQUIRE) specifiers
MESSAGES
OUTPUT
VARIOUS
Fortran 77 language extensions table
Fortran 90/95/2003/2008/2015 language extensions table
Limitations
Configuration determined limits
History of changes
Message summary
References
Fortran Glossary
Coverity Compliance Guide
About this guide
Coverity Compliance Filtering Overview
Introduction to Findings
Workflows
Compliance filtering requirements
Supported coding standards
Regulating issue creation
The priority filter/findings report spreadsheet
Run a code analysis
Generate a findings report
Analyze a findings report
Create filtering policies
Generate a test findings report
Upload a priority filter
Update or remove a priority filter
Using scores to prioritize development tasks
Adding the Score column
Filtering by score
Configuring and Generating Coverity Reports
Coding standards and compliance reports
Understanding deviations
Deviations in reports
Configuring report generators
Configuration overview
Supported versions of report types
General considerations
Standard schema elements
Connection schema elements
Issue cutoff schema element
Locale schema element
Project schema elements
Snapshot schema elements
Report-filtering elements
Title page schema elements
Schema version element
Schema elements for specific reports
CERT Report
Coverity Integrity Report
Security Report
Black Duck Software Integrity Report
DISA ASD STIG Report
Unified configuration file
Coverity CERT report
Overview
Working with the report generator
Installing the report generator
Connecting to Coverity Connect
Generating the CERT report
CERT report configuration file
Using system environment variables
Generating a previously configured report
Interpreting the CERT report
Coverity CVSS report
Introduction to CVSS
Scorecard elements
Triage attributes
CVSS report profile
Installing the report generator
Working with the Coverity CVSS report generator
Generating a CVSS report
CVSS report configuration file
Using system environment variables
CVSS report input files
Localizing reports
Coverity DISA ASD STIG report
Overview
Working with the report generator
Installing the report generator
DISA ASD STIG report configuration file
Generating a DISA ASD STIG report
Intepreting the DISA ASD STIG report
Coverity Hyundai report
Overview
Working with the report generator
Installing the report generator
Hyundai report configuration file
Generating a Hyundai report
Using system environment variables
Interpreting the Hyundai report
Coverity Integrity report
Overview
Defect ratings
Recommended analysis configuration
Requirements
Working with the report generator
Installing the report generator
Coverity Integrity Report configuration file
Generating a Integrity report
Localizing reports
Coverity MISRA report
MISRA report overview
MISRA compliance
Working with the report generator
Installing the report generator
Connecting to Coverity Connect
Generating the BDSIR report
Creating a report that uses a custom standard based on a MISRA category
MISRA report configuration file
Using system environment variables
Generating a previously configured report
Localizing reports
Coverity OWASP Web Top 10 report
Overview
Working with the report generator
Installing the report generator
OWASP Web Top 10 report configuration file
Generating a OWASP Top 10 report
Interpreting the OWASP Web Top 10 report
Coverity Mobile OWASP Top 10 report
Overview
Working with the report generator
Installing the report generator
Mobile OWASP Top 10 report configuration file
Generating a Mobile OWASP Top 10 report
Interpreting the Mobile OWASP Top 10 report
Coverity PCI DSS report
Overview
Working with the report generator
Installing the report generator
PCI DSS report configuration file
Generating a PCI DSS report
Interpreting the PCI DSS report
Coverity Security report
Security report overview
Working with the report generator
Installing the report generator
Connecting to Coverity Connect
Generating the Security report
GUI configuration
Security Report configuration file
Generating a previously configured report
Interpreting the Security Report
Severity mapping: Mapping technical defects to severity levels
Creating a custom severity mapping
Security scores, severity mappings, and assurance levels
Understanding scorecards
Customizing Security reports
Localizing reports
Using system environment variables
Black Duck Software Integrity report
Overview
Installing the report generator
Setup and configuration
Setting up the Black Duck Software Integrity Report generator
Configuring the Black Duck Software Integrity Report
Black Duck Software Integrity Report configuration file
Using system environment variables
Generating a report through the GUI
Generating a report via command line
PDF report outline
Detailed results
Analysis commands
Coverity Analysis commands
cov-analyze
Synopsis
Description
Options: Aggressiveness level
Options: Analysis
Options: Apex checkers
Options: Audit
Options: Brakeman checkers
Options: C, C++, Objective-C, Objective-C++
Options: C#
Options: Checkers
Options: Compliance checkers
Options: Custom checkers and CodeXM
Options: Extend SDK
Options: Java
Options: Java analysis
Options: JavaScript, TypeScript
Options: Metrics
Options: Models
Options: Shared
Options: Sigma
Options: Web and mobile application security
Exit codes
Examples
See also
cov-blame
Synopsis
Description
Options
Exit codes
See also
cov-build
Synopsis
Description
C, C++, C#, and Visual Basic build capture
Go build capture
Java and Kotlin build capture
Rust build capture (beta)
Build capture example
Security Dynamic Analysis for Java and .NET source
Options
Exit codes
See also
cov-collect-models
Synopsis
Description
Options
Exit codes
See also
cov-commit-defects
Synopsis
Description
Using a forward proxy
Options
Exit codes
Examples
cov-configure
Synopsis
Description
Language-specific configurations
Options
Exit codes
See also
cov-count-lines
Synopsis
Description
Options
Exit codes
Examples
cov-emit
Synopsis
Description
Options
Exit codes
See also
cov-emit-cs
Synopsis
Description
Options
Exit codes
cov-emit-go
Synopsis
Description
Options
Exit codes
cov-emit-java
Synopsis
Description
Options
Exit codes
Examples
See also
cov-emit-vb
Synopsis
Description
Options
Exit codes
cov-extract-scm
Synopsis
Description
Options
Exit codes
See also
cov-find-function
Synopsis
Description
Options
Exit codes
Example
cov-format-errors
Synopsis
Description
Regular expressions
Options
Exit codes
cov-format-sarif-for-github.js
Synopsis
Description
Options
Example
cov-generate-hostid
Synopsis
Description
Options
Exit codes
Example
cov-help
Synopsis
Description
Environment variables
Exit codes
cov-import-msvsca
Synopsis
Description
Options
Exit codes
See also
cov-import-results
Synopsis
Description
Options
Exit codes
cov-import-scm
Synopsis
Description
Options
Exit codes
See also
cov-import-sigma
Synopsis
Description
Options
cov-install-updates
Synopsis
Description
Sub-commands
Sub-command options
Connection options
Shared options
Exit codes
Examples
See also
cov-link
Synopsis
Description
Options
Exit codes
Examples
See also
cov-make-library
Synopsis
Description
Options
Exit codes
See also
cov-manage-emit
Synopsis
Description
Options
Basic options
Non-filtered sub-commands
Translation unit sub-commands with optional filtering
Translation unit sub-commands with required filtering
Listing emit database information
Recompiling
Decompiling
Translation unit pattern matching
Shared options
Exit codes
Examples
See also
cov-manage-findings
Synopsis
Description
Options
Exit codes
Examples
cov-preprocess
Synopsis
Description
Options
Exit codes
See also
cov-record-source
Synopsis
Description
Options
Exit codes
See also
cov-run-desktop
Synopsis
Description
Translation unit selection
A note on Git superprojects
Regular expressions
Options categories
Options
Exit codes
See also
cov-run-fortran
Synopsis
Description
Fortran inputs
Fortran outputs
Options usage
Options categories
Options
Exit codes
See also
cov-run-sigma
Synopsis
Description
Options
cov-security-da
Synopsis
Description
Options
See also
cov-setup-bazel-registry
Synopsis
Description
Options
cov-support
cov-test-configuration
Synopsis
Description
Examples
Options
Exit codes
See also
cov-translate
Synopsis
Description
Example
Options
Exit codes
See also
cov-upgrade-static-analysis
Synopsis
Description
Options
Exit codes
Coverity Analysis Ant tasks
covanalyzeandcommit
covbuild
Coverity CLI commands
coverity analyze
coverity capture
coverity commit
coverity help
Configuration syntax help
coverity list
coverity scan
coverity setup
Report-generation commands
Coverity CERT report
cov-cert-report
cov-generate-cert-report
CVSS report
cov-generate-cvss-report
Coverity DISA ASD STIG report
cov-generate-disa-stig-report
Hyundai report
cov-generate-hyundai-report
Coverity Integrity report
cov-generate-integrity-report
MISRA report
cov-misra-report
cov-generate-misra-report
OWASP Web Top 10
cov-generate-owasp-report
Mobile OWASP Top 10
cov-generate-mobile-owasp-report
PCI DSS
cov-generate-pci-dss-report
Security report
cov-security-report
cov-generate-security-report
Black Duck Software Integrity Report
bd-integrity-report
bd-generate-integrity-report
Coverity Security Directives Reference
Security configuration file
Uses of directives
Security threats
Defining custom checkers
Checker-specific directives
Supported languages
How to invoke a custom configuration
Configuration file syntax
Extensions to JSON supported by the configuration file
JSON terminology
Schema
Top-level value
Currently supported versions
Objects in the configuration file
Configuration file usage
User directives
android_protected_intent_actions
android_safe_categories
async_method
class_like_print_writer_for_servlet_output
csrf_check_needed
csrf_validator
data_has_tag
dataflow_checker_name
dataflow_through_callsite
dc_checker_name
define_lookup_method_call_map
ignore_all_argument_dataflow_to_method
ignore_method_dataflow
ignore_method_output
local_callback
map_read
map_write
method_returns_constant
method_returns_param
method_returns_servlet_output_stream
method_returns_tainted_data
method_set_for_dc_checker
method_with_servlet_sinks_on_input
method_with_servlet_sinks_on_output
move_xss_outside_method
sanitizer_for_checker
sensitive_action
sensitive_operation
simple_entry_point
sink_for_checker
tainted_data
text_checker_name
xss_sanitizer_method
Migrating the format from Version 8 to Version 12
Other object types used by user directives
AccessPathElement
AnnotationSet
named
matching
CallsiteSet
callsite_with_static_target
call_on
new_on
CallsiteCondition
ClassName
ClassSet
named
matching
with_super
with_annotation
HtmlOutputContext
html_attribute_value_where_name_is_from_param
html_prefix
Examples
InputAndAccessPathSpecifier
InputTaint
InputTag
InputValue
IssueTypeDefinition
MethodCallSpecifier
method_call
lookup_by_constant_param
MethodName
MethodSet
named
matching
overrides
implemented_in_class
and
with_annotation
OutputAndAccessPathSpecifier
ParamIn
ParamOut
ReadableProgramData
from_callsite
read_from_object_with_tag
read_path_off_global
read_off_any
read_from_js_require
read_from_HANA_library_import
RegularExpression
ReturnConstant
SinkKind
TaintKind
TaintKindGroup
TextPattern
regex
xpath
WritableProgramData
to_callsite
write_to_object_with_tag
write_path_off_global
write_off_any
Customization guides
Customizing Coverity
Coverity Analysis Overview
Global customization choices
Global analysis options
Global trust model for data sources
Choices that depend on the checker, the language, or other contexts
Checker options
Custom API models
In-code annotations
Security analysis directives (JSON)
Creating new checkers
Custom dataflow and text checkers (JSON directives)
CodeXM checkers
Legacy ways of creating checkers
Enabling and disabling checkers
Enabling and disabling checkers with 'cov-analyze'
Changing the set of enabled checkers
Enabling compilation warning checkers (PW.*, RW.*, SW.*)
Changing which parse warnings are enabled
Identifying vulnerable data
Tainted data overview
Examples of tainted data
Taint kind trust options
Categories of tainted data
Taint sources in the code base
Sensitive data overview
Sensitive data source types
Models and primitives
Use cases
Models for source code that is unavailable
Models derived by Coverity Analysis are ineffective
Adding a custom model
Modeling primitives
Taint enumerations
Model search order
Models in C/C++
C/C++ examples
Example: Override a default C model
Adding a C model to emulate memory allocation
Replace a built-in model in order to reduce the number of defect reports
Models for function pointers
Model for adding a killpath to a function
Adding a killpath to the 'special_abort()' model
Concurrency models
Adding a C++ model
General considerations for C++ models
Adding a C++ model to refine analysis of memory allocation
Models for virtual functions (C++)
Models for templates (C++)
C/C++ primitives
C/C++ resource-management primitives
C/C++ security primitives
Deprecated C/C++ security primitives
C/C++ primitive to manage false positives
C/C++ concurrency primitives
Models in C# and Visual Basic
C# and Visual Basic examples
Primitives for modeling sources of untrusted (tainted) data
Primitives for modeling sources of sensitive data
C# and Visual Basic primitives
C# and Visual Basic reference-object primitives
C# and Visual Basic security primitives
C# and Visual Basic side-effect and utility primitives
C# and Visual Basic concurrency primitives
Models in Go
Go examples
Primitives for modeling sources of untrusted (tainted) data
Primitives for modeling sources of sensitive data
Go primitives
Go security primitives
Go side-effect and utility primitives
Go concurrency primitives
Models in Java
Java examples
Model for a Java interface method
Model for resource leaks
Model for sources of untrusted (tainted) data
Model for methods to which tainted data must not flow (sinks)
Adding assertions that fields are tainted or not tainted
Suppressing defect reports on a method
Generating Java Web application security models
Java primitives
Java resource-leak primitives
Java security primitives
Java sensitive-data primitives
Java side-effect primitives
Java use-after-free primitives
Java Coverity primitives
Java Android primitives
Java iterator primitives
Java concurrency primitives
Cryptographic primitives
C/C++ cryptographic primitives
Value-map strings
C# and Visual Basic cryptographic primitives
Java and Kotlin cryptographic primitives
Enumerations used by the cryptographic primitives
Algorithm
BlockMode
Padding
Implementation
Operation
SSL_Protocol
Analysis annotations
Annotations in C/C++
C/C++ code-line annotations
Special Coverity Connect classifications
The FALSE classification
The SUPPRESS classification
Annotation logging
C/C++ function annotations
C/C++ '#pragma' directives and '_Pragma()'operators
Annotating compliance deviations
The '#pragma coverity compliance' directive
'#pragma coverity compliance' directive: further examples
The '_Pragma()_' compliance operator
Annotations in C# and Visual Basic
Adding annotations to C# or Visual Basic source
The 'Tainted' and 'NotTainted' attributes for .NET code
The 'SensitiveData' attribute for .NET code
Annotations in Java
Adding annotations to Java source
The '@Tainted' and '@NotTainted' attributes for Java code
The '@SensitiveData' attribute for Java code
Parse warnings configuration file
Coverity CodeXM Checkers Development Guide
Introduction to CodeXM
Nullable types
Interactive checker development
Learning to write CodeXM checkers
QuickStart tutorial
Writing your first CodeXM checker
Running your CodeXM checker
Further reading
How to write a CodeXM checker
Reviewing basic CodeXM concepts and exercises
Basic pattern matches and conditions
Decomposing a pattern to match specific properties
Using the filtering operator
Creating custom patterns
Returning objects from patterns
Finding a literal argument value
Handling null values
Using the 'exists' expression
Defining CodeXM variables
CodeXM types
Using switch statements
Using conditional expressions
Using the 'debug()' function
Defining CodeXM functions
Including other CodeXM files
Finding built-in code patterns
Function properties
Path-sensitive analysis
Writing an A_THEN_B checker
Writing your own Don't Call checker
A CodeXM style guide
Alternatives in patterns
Anonymous functions
Braces
Comments
Conditional Expressions
Constants
Enum, list, record, and set literals
'for' loops
Functions
Identifiers
'let' bindings
Multiline logical expressions
Pattern decompositions
Spacing and line length
'switch' expressions
Syntax reference
Describing syntax
Syntax diagrams
Extended Backus-Naur form
CodeXM character set
White space and comments
How does Coverity Analysis work?
CodeXM file-level elements
Specifying the target language
The identifier
The CodeXM-File
The checker-definition
Example of a checker
The 'defineIssueType()' function
The const-definition
The forward-declaration
The function-definition
Generic parameters
The function-property-definition
The include-directive
The pattern-definition
The type-definition
Expressions
The expression
Operator precedence
The 'default' operator
The addition-expression
Null coalescing
The binary-expression
The call-expression
The comparison-expression
The conditional-expression
The decomposing-pattern-expression
The comparand-expression
The element-access-expression
The exists-expression
The for-accumulate-expression
Initializing the accumulator
The logic of for-accumulate
The for-loop-expression
The result of a for-loop
The result of a checker
Visualizing a for-loop
The happens-before-expression
The 'sequence()' function
The if-exists-expression
The result of if-exists
The if-expression
if-expression behavior
The lambda-expression
The let-binding-expression
Using let-binding
The list-expression
list-expression behavior
The literal-expression
The enum-literal-expression
The int-literal-expression
The string-literal-expression
string-literal details
'null' and 'NonNull'
'true' and 'false'
The logical-expression
The matches-expression
The multiplication-expression
The pattern-expression
The match-list
The property-access-expression
The record-expression
The record-update-expression
The set-expression
The set-filter-expression
The switch-expression
The unary-expression
The variable-expression
The CodeXM type system
The type
The builtin-type
The eventstring
The collection-type
The type_of_empty_list
The enum-type
The function-type
The globalset-type
The named-type
The node-type
The nullable-type
The type_of_null
The pattern-type
The record-type
CodeXM keywords
Common library reference
Filtering target code
allCodeIn( theCode )
allMatchingCodeIn( desiredPattern, theCode )
anyMatchingCodeIn( desiredPattern, theCode )
contains( predicate, theCode )
containsMatch( desiredPattern, theCode )
filter( predicate, s )
innermostOwner( ownerPattern, theCode )
outermostOwner( ownerPattern, theCode )
outermostOwnerExpression( theExpression )
ownerStatement( theCode )
Handling sets and lists
reverse( l )
unique( equal, s )
Managing strings
Regex( string )
RegexExtended( string, options )
strcat( string0, string1 )
strToInt( string )
strToLower( string )
Debugging Support
debug( eventstring )
C/C++ library reference
Specifying the target language
The CUDA extension
Class definitions
astnode
classDefinition
The base class properties
Examples of using base class properties
classParent
enumDefinition
functionDefinition
functionOrStaticVariableDefinition
globalVariableDefinition
tokenizedSourceFile
'enum' kinds
assignKind
castKind
deducedTypeKind
floatKind
floatSuffix
forLoopKind
intKind
nullKind
qualifierEnum
sizeofKind
stringLiteralEncoding
variableDeclarationKind
variableScopeEnum
'globalset' sets
allClasses
allEnums
allFunctionAndGlobalVariableCode
allFunctionAndGlobalVariableDefinitions
allFunctionCode
allFunctionDefinitions
allGlobalVariableDefinitions
allTokenizedSourceFiles
Code patterns
Statements
asmStatement
blockStatement
breakStatement
caseStatement
continueStatement
defaultStatement
doWhileLoop
emptyStatement
forLoop
forLoopRange
forLoopSimple
Matching a loop whose condition is always true
gotoStatement
ifStatement
labelStatement
returnStatement
simpleStatement
switchStatement
tryStatement
whileLoop
Declarations
localFunctionDeclaration
variableDeclaration
Types
arrayType
boolType
charType
classType
deducedType
enumType
floatType
functionType
intType
memberType
nullPointerType
pointerType
referencedTypesType
referenceType
sizeofOperatorType
typedefType
typeQualifier
typeQualifierAtomic
typeQualifierConst
typeQualifierRestrict
typeQualifierVolatile
voidType
Expressions
Example: Expressions used as if-statement conditions
Common properties of expressions
functionCall
kernelCall
memberReference
pointerDereference
sizeofOperatorExpression
subscriptReference
variableReference
Literals
booleanLiteral
characterLiteral
enumeratorLiteral
floatLiteral
intLiteral
nullPointerLiteral
stringLiteral
Operators
addressOf
assignmentOperator
assignmentOperatorCompound
assignmentOperatorSimple
binaryOperator
castOperator
castOperatorConstCast
castOperatorDynamicCast
castOperatorExplicit
castOperatorImplicit
castOperatorReinterpretCast
castOperatorStaticCast
conditionalOperator
decrementOperator
deleteOperator
incrementOperator
newOperator
sizeofOperator
throwOperator
unaryOperator
Initializers
aggregateInitializer
constructorInitializer
expressionInitializer
unionFieldInitializer
zeroInitializer
Symbols
Common properties of symbols
enumeratorSymbol
fieldSymbol
functionSymbol
globalVariableSymbol
localVariableSymbol
parameterSymbol
variableSymbol
Tokens
charLiteralToken
commentToken
identifierToken
numberToken
operatorToken
stringLiteralToken
token
unrecognizedToken
whitespaceOrCommentToken
whitespaceToken
Functions
Definition functions
getClassDefinition( classTypeResult )
getEnumDefinition( enumTypeResult )
Pattern functions
aliasTypeOf( typePattern )
anyQualifiedTypeOf( typePattern )
arrayOf( typePattern )
constOf( typePattern )
pointerTo( typePattern )
volatileOf( typePattern )
Type functions
hasBaseType( typeName )
Decomposing functions
getQualifiers( typeName )
qualifiersOf( typeName )
stripCasts( expressionString )
stripQualifiers( typeName )
C# library reference
Specifying the target language
Class definitions
astnode
classDefinition
The base class properties
Examples of using base class properties
classParent
functionDefinition
functionOrStaticVariableDefinition
globalVariableDefinition
staticVariableDefinition
Attribute classes
attributeArgument
attributeNamedArgument
attributePositionalArguments
'enum' kinds
assignKind
castKind
cvModifierKind
floatKind
ForLoopKind
intKind
variableDeclarationKind
variableScopeKind
'globalset' sets
allClasses
allFunctionAndStaticVariableCode
allFunctionAndStaticVariableDefinitions
allFunctionCode
allFunctionDefinitions
allFunctionsAndGlobalVariableCode
allStaticVariableCode
allStaticVariableDefinitions
allTextFiles
Code patterns
Statements
allLoops
blockStatement
breakStatement
caseStatement
continueStatement
defaultStatement
doWhileLoop
emptyStatement
fixedStatement
forLoop
forLoopEnhanced
forLoopSimple
gotoStatement
ifStatement
labeledBreakStatement
labeledContinueStatement
labelStatement
returnStatement
simpleStatement
switchStatement
synchronizedStatement
throwStatement
tryStatement
unsafeStatement
whileLoop
Declarations
variableDeclaration
Types
arrayType
booleanType
charType
classType
cvModifiedType
enumType
floatType
functionType
genericType
integralType
nullableType
outParamReferenceType
pointerType
referenceParamType
referenceType
tupleClassType
typeParameterType
usingType
valueTupleType
voidType
Expressions
Example: Expressions used as if-statement conditions
Common properties of expressions
argList
arrayLength
boxExpression
checkedBlock
checkedExpression
deconstructionExpression
dynamicCastExpression
dynamicFunctionCall
enumReference
expressionPattern
expressionTree
fieldAccess
fieldReference
functionCall
functionReference
instanceOf
isPattern
makeRefExpression
multiSubscriptReference
namedPattern
nullableGetValue
patternMatchExpression
propertyReference
propertyUpdate
referenceDereference
refTypeExpression
refValueExpression
stackAllocation
subscriptReference
temporaryConstruction
temporaryExpression
temporaryVariableReference
uncheckedBlock
uncheckedExpression
variableReference
yieldExpression
Literals
booleanLiteral
characterLiteral
classLiteral
enumLiteral
floatLiteral
integralLiteral
nullLiteral
stringLiteral
Operators
addressOf
assignmentOperator
assignmentOperatorCompound
assignmentOperatorSimple
awaitOperator
binaryOperator
castOperator
castOperatorExplicit
castOperatorImplicit
conditionalOperator
decrementOperator
incrementOperator
newOperator
nullableBinaryOperator
nullCoalescingOperator
sizeofOperator
throwOperator
unaryOperator
Initializers
addMemberInitializer
arrayDimensionsInitializer
arrayInitializer
assignmentMemberInitializer
baseClassInitializer
constructorInitializer
expressionInitializer
memberInitializer
nestedMemberInitializer
objectInitializer
peerConstructorInitializer
zeroInitializer
Symbols
Common properties of symbols
enumeratorSymbol
enumVariableSymbol
fieldSymbol
functionSymbol
localVariableSymbol
parameterSymbol
staticVariableSymbol
variableSymbol
Records
codeAttribute
declaration
handler
Functions
Definition functions
getClassDefinition( classTypeResult )
Type functions
hasBaseType( t )
stripReferenceTypes( t )
Decomposing functions
aliasTypeOf( baseType )
arrayOf( typePattern )
constOf( typePattern )
getQualifiers( t )
stripBoxes( e )
stripCasts( e )
stripCastsAndBoxes( e )
Overridee functions
getFunctionOverridees( f )
Go library reference
Specifying the target language
Class definitions
astnode
classDefinition
functionDefinition
functionOrStaticVariableDefinition
globalVariableDefinition
staticVariableDefinition
'enum' kinds
assignKind
castKind
floatKind
ForLoopKind
intKind
labelScopeKind
variableDeclarationKind
variableScopeEnum
'globalset' sets
allClasses
allFunctionAndStaticVariableCode
allFunctionAndStaticVariableDefinitions
allFunctionCode
allFunctionDefinitions
allStaticVariableCode
allStaticVariableDefinitions
allTextFiles
Code patterns
Statements
allLoops
blockStatement
breakStatement
caseStatement
continueStatement
defaultStatement
deferStatement
emptyStatement
fallThroughStatement
forLoop
forLoopSimple
gotoStatement
ifStatement
incDecStatement
labeledBreakStatement
labeledContinueStatement
labelStatement
locallyDeclaredTypeStatement
returnStatement
selectStatement
sendStatement
simpleStatement
switchStatement
Declarations
variableDeclaration
Types
anyType
arrayType
boolType
classType
floatType
functionType
integerType
referenceType
stringType
Expressions
Example: Expressions used as if-statement conditions
Common properties of expressions
anyTypeVariableReference
attributeReference
boxExpression
builtinFunctionExpression
deconstructionExpression
dynamicFunctionCall
enumReference
fieldAccess
fieldReference
functionCall
functionReference
functionVariableReference
referenceDereference
variableReference
Literals
boolLiteral
compositeLiteral
floatLiteral
imaginaryLiteral
integerLiteral
mapLiteral
nilLiteral
stringLiteral
Operators
addressOf
assignmentOperator
assignmentOperatorCompound
assignmentOperatorSimple
binaryOperator
castOperator
decrementOperator
incrementOperator
newOperator
unaryOperator
Initializers
arrayInitializer
expressionInitializer
zeroInitializer
Symbols
Common properties of symbols
fieldSymbol
functionSymbol
localVariableSymbol
parameterSymbol
staticVariableSymbol
variableSymbol
Records
declaration
Functions
Definition functions
getClassDefinition( classType )
Pattern functions
arrayOf( typePattern )
Java library reference
Specifying the target language
Class definitions
astnode
classDefinition
The base class properties
Examples of using base class properties
classParent
functionDefinition
functionOrStaticVariableDefinition
globalVariableDefinition
staticVariableDefinition
Annotation classes
annnotationAnnotationElement
annotationArrayElement
annotationElement
annotationExpressionElement
'enum' kinds
assignKind
castKind
floatKind
ForLoopKind
intKind
variableDeclarationKind
variableScopeEnum
'globalset' sets
allClasses
allFunctionAndStaticVariableCode
allFunctionAndStaticVariableDefinitions
allFunctionCode
allFunctionDefinitions
allFunctionsAndGlobalVariableCode
allStaticVariableCode
allStaticVariableDefinitions
allTextFiles
Code patterns
Statements
allLoops
assertStatement
blockStatement
breakStatement
caseStatement
continueStatement
defaultStatement
doWhileLoop
emptyStatement
forLoop
forLoopEnhanced
forLoopSimple
ifStatement
labeledBreakStatement
labeledContinueStatement
labelStatement
returnStatement
simpleStatement
switchStatement
synchronizedStatement
throwStatement
tryStatement
whileLoop
Declarations
variableDeclaration
Types
anyType
arrayType
booleanType
charType
classType
floatType
functionType
integerType
referenceType
voidType
Expressions
Example: Expressions used as if-statement conditions
Common properties of expressions
arrayLength
boxExpression
enumReference
fieldAccess
fieldReference
functionCall
functionReference
instanceOf
referenceDereference
subscriptReference
variableReference
Literals
booleanLiteral
characterLiteral
classLiteral
floatLiteral
integerLiteral
nullLiteral
stringLiteral
Operators
assignmentOperator
assignmentOperatorCompound
assignmentOperatorSimple
binaryOperator
castOperator
castOperatorChecked
castOperatorExplicit
castOperatorImplicit
conditionalOperator
decrementOperator
incrementOperator
newOperator
throwOperator
unaryOperator
Initializers
arrayDimensionsInitializer
arrayInitializer
baseClassInitializer
constructorInitializer
expressionInitializer
memberInitializer
peerConstructorInitializer
zeroInitializer
Symbols
Common properties of symbols
enumVariableSymbol
fieldSymbol
functionSymbol
localVariableSymbol
parameterSymbol
staticVariableSymbol
variableSymbol
Records
annotationElementValuePair
codeAnnotation
declaration
handler
Functions
Definition functions
getClassDefinition( classTypeResult )
Type functions
hasBaseType( t )
stripReferenceTypes( t )
Decomposing functions
arrayOf( typePattern )
stripBoxes( e )
stripCasts( e )
stripCastsAndBoxes( e )
stripImplicitCasts( e )
Overridee functions
getFunctionOverridees( f )
JavaScript library reference
Specifying the target language
Class definitions
astnode
functionDefinition
globalVariableDefinition
'globalset' sets
allFunctionCode
allFunctionDefinitions
allFunctionsAndGlobalVariableCode
allTextFiles
Code patterns
Statements
anyLoop
blockStatement
breakStatement
caseStatement
continueStatement
debuggerStatement
defaultStatement
doWhileLoop
emptyStatement
forLoop
forLoopIn
forLoopOf
forLoopSimple
generatorReturnStatement
ifStatement
labelStatement
returnStatement
simpleStatement
switchStatement
throwStatement
tryStatement
whileLoop
withStatement
Declarations
classDeclaration
destructuringDeclaration
functionDeclaration
variableDeclaration
Types
functionType
scalarType
Expressions
Example: Expressions used as if-statement conditions
Common properties of expressions
argumentAfterExpansion
argumentsReference
arrayElision
classExpression
closedVariableReference
constructorDefinition
destructuringAssignment
destructuringParameter
functionCall
functionExpression
functionReference
generatorReturnValue
globalAccess
listExpansionArgument
localVariableReference
newTargetReference
nodejsRequire
parameterReference
parameterWithDefault
propertyAccess
propertyAccessBracket
restParameter
superReference
thisReference
variableReference
variableReferenceUnderWith
Literals
arrayLiteral
booleanLiteral
floatLiteral
integerLiteral
nullLiteral
objectLiteral
regularExpressionLiteral
stringLiteral
undefinedConstant
Operators
assignmentOperator
assignmentOperatorCompound
assignmentOperatorSimple
binaryOperator
castOperator
conditionalOperator
decrementOperator
deleteOperator
incrementOperator
instanceofOperator
newOperator
spreadOperator
typeofOperator
unaryOperator
voidOperator
yieldOperator
Initializers
expressionInitializer
Symbols
Common properties of symbols
closedVariableSymbol
functionSymbol
localVariableSymbol
parameterSymbol
theGlobalObjectSymbol
variableSymbol
Functions
Decomposing functions
stripImplicitCasts( e )
Python 3 library reference
Specifying the target language
Class definitions
astnode
functionDefinition
globalVariableDefinition
'enum' kinds
assignmentKind
numberKind
variableScopeKind
Code patterns
Statements
assertStatement
assignmentStatement
blockStatement
breakStatement
continueStatement
delStatement
expressionStatement
forEachLoop
ifStatement
importStatement
passStatement
raiseStatement
returnStatement
tryStatement
whileLoop
yieldBreakStatement
yieldStatement
Declarations
classDeclaration
functionDeclaration
localVariableDeclaration
Types
booleanType
compositeType
functionType
integralType
realType
stringType
Expressions
Example: Expressions used as if-statement conditions
Common properties of expressions
attributeReference
duplicatedValue
dynamicMapping
functionCall
functionReference
lambdaExpression
listComprehension
mapComprehension
setComprehension
sliceExpression
subscriptExpression
tupleComprehension
variableReference
yieldExpression
Literals
booleanLiteral
ellipsisLiteral
floatLiteral
imaginaryLiteral
integerLiteral
listLiteral
mapLiteral
noneLiteral
setLiteral
stringLiteral
tupleLiteral
undefinedLiteral
Operators
assignmentOperator
binaryOperator
castOperator
conditionalOperator
unaryOperator
Initializers
aggregateInitializer
expressionInitializer
mapInitializer
Symbols
Common properties of symbols
functionSymbol
globalVariableSymbol
localVariableSymbol
parameterSymbol
Functions
Python 3 Patterns
Statements
annotatedAssignmentStatement
caseStatement
globalOrNonlocalDeclarationStatement
matchStatement
Operators
unpackOperator
Expressions
awaitExpression
expressionPattern
isPattern
namedPattern
Coverity Extend SDK Checker Development Guide
Coverity Extend SDK usage
Overview
Introduction to Coverity Extend SDK
Coverity Extend SDK directory structure
Compiling Coverity Extend SDK checkers
Creating your first checker: hello
The hello checker source code
Compiling the hello checker
Running the hello checker
Running the hello checker from another directory
Committing the issues to Coverity Connect
Dissecting the hello checker
Creating a Makefile for convenience
The Abstract Syntax Tree
What is the AST?
Examining nodes in the AST with print_tree
Patterns
Expression patterns
Variable kind patterns
Pattern combinators
Accessors
State machine paradigm
Simple checker vs. checker with store
Abstract interpretation
Visit order
Manipulating the store
Example: tracking the sign of expressions
Output
OUTPUT_ERROR
ADD_EVENT
COMMIT_ERROR
ADD_INPUTFILE_ONLY_EVENT
COMMIT_INPUTFILE_ONLY_ERROR
ADD_INPUTFILE_EVENT
COMMIT_INPUTFILE_ERROR
Example: sign2
Conditionals
ANALYZE_CONDITION
MATCH_COND
force_backtrack
Example: sign3
Abstract comparison
Comparison evaluation
Paths
Many paths per function
False Path Pruning (FPP)
Two-pass checking
Termination
Examining the class hierarchy
Mapping from variables to their class/type
Tree structure of types
Classes
Inheritance
Virtual function overriding relationships
type_t iterators
type_visitor_t
subtype_visitor_t
type_recursive_visitor_t
When are type_t objects resident in memory?
Example: print type information
Example: switch default
Reporting events and defects on input files
Additional steps for building Coverity Extend SDK checkers for Android applications
Input file class extend_inputfile_t
Input file macros
Input file checker examples
Troubleshooting a Coverity Extend SDK checker
A Coverity Extend SDK checker aborts execution with a Tree used with no match error.
Coverity Extend SDK reference
Introduction to the Coverity Extend SDK API
Handler functions
Coverity Extend SDK checker file structure
START_EXTEND_CHECKER
END_EXTEND_CHECKER
MAKE_MAIN
INIT_OPTIONS
HANDLE_OPTION
CHECKER_INIT
CHECKER_FINAL
FUNCTION_INIT
FUNCTION_FINAL
ANALYZE_TREE
ANALYZE_CONDITION
ANALYZE_END_OF_PATH
PREFER_TO_ANALYZE_CSHARP
PREFER_TO_ANALYZE_JAVA
PREFER_TO_ANALYZE_JAVASCRIPT
ANALYZE_CLASS
Patterns
Patterns for C# and Java checkers
Functions common to all patterns
ASTNodePattern Superclass
ExpressionPattern Superclass
TypePattern Superclass
SymbolPattern Superclass
Predefined pattern objects
Expression patterns
Basic expression patterns
Function call site expression patterns
Variable reference expression patterns
Type-filtered expression patterns
Complex expression patterns
Evaluation patterns
Statement patterns
Other patterns
Binding patterns
Syntactic context filters
STL construct patterns
Miscellaneous patterns
Combinators (And, Or, etc.)
Accessors
Additional AST query functions
Queries on the current function
Queries on the current file
Queries on trees
The store
Store overview
void SET_STATE(tree t, int v)
void CLEAR_STATE(tree t)
bool GET_STATE(tree t, int &v)
bool MATCH_STATE(tree t, int v)
bool COPY_STATE(tree dst, tree src)
FOREACH_IN_STORE(tree &t, int &v) { body }
bool ADD_EVENT(tree t, char const *tag, desc)
bool COMMIT_ERROR(tree t, char const *tag, desc)
ADD_INPUTFILE_EVENT
COMMIT_INPUTFILE_ERROR
Adding events
Types
type_t
any_type_t
scalar_type_t
pointer_type_t
array_type_t
cv_wrapper_type_t
function_type_t
scoped_type_t
scope_t
defined_type_t
typedef_type_t
forward_declarable_type_t
enum_type_t
tag_t
union_type_t
field_t
class_type_t
parent_t
function_t
member_type_t
extend_inputfile_t
Reference information
Header files
Name mangling
Mangled naming scheme: C++
Mangled naming scheme: C#
Mangled naming scheme: Java
Checker examples
Checker source files
sign checker
sign2 checker
sign3 checker
print_types.cpp
switch_default.cpp
javascript_match_local.cpp
Coverity Analysis: installation and upgrade
Coverity Analysis hardware
Minimum requirements
Disks
Operating system considerations
Shared machines
Virtual machines
Installing Coverity Analysis components
Downloading the Coverity Analysis installer from the Black Duck repository
Installing Coverity Analysis
Coverity Analysis installer modes
Selecting an installer mode
Coverity Analysis silent installer
Coverity Analysis license options
Setting up a license.dat file
Installing multiple Coverity Analysis licenses
Installing FlexNet licenses
Troubleshooting for FlexNet licensing
Using an archive file to install Coverity Analysis
Coverity product components: supported versions and compatibility
Coverity SCM support
Supported platforms for Coverity Analysis
Supported platforms for Extend SDK and FlexNet licensing
Supported languages, compilers, and frameworks for Coverity Analysis
C/C++ compilers
C++23 (ISO/IEC DIS 14882:2023) language support
C# compilers
CUDA compilers
Go compilers
Java compilers
Kotlin compilers
Rust compilers
Visual Basic compilers
Third-party compilers
Frameworks
Upgrading Coverity Analysis
Standard upgrade procedure
Understanding churn
Checkers disabled by default
New behavior when emitting web application archives
Updating Coverity Analysis with incremental releases
Installation
How updates work
Running cov-install-updates
Rolling back an update session
Other utilities
Upgrading Coverity Analysis using updates
Clients, plug-ins, integrations, and APIs
Coverity integrations and APIs
Command line clients
Plug-ins and other integrations
API reference
Coverity MCP Server
Guide to the Coverity Point and Scan UI and the Coverity CLI
Introducing Coverity Point and Scan and the Coverity command-line interface (CLI)
Point and Scan, the Coverity CLI, and file usage
Default analysis
Prerequisites for using Point and Scan or the Coverity CLI with Coverity Connect
Using the Coverity Point and Scan UI
Looking at individual issues
Rescanning and reconfiguring
Using the Coverity CLI
Configuring the Coverity CLI
Use cases
Specify 'clean' and 'build' commands
Specify where to commit scan results
Specify how to analyze a project
Specify which files to capture for analysis
The 'languages' option
The 'files' option
Default exclusions
Capturing a specific set of files
Extended example: Using the 'languages' and 'files' options together
Enable Web application security
Enable mobile Java Android security
Example: Finding MISRA standard deviations and customizing a checker
Command reference
Shared command options
Options reference
Capture configuration
Build configuration
Compiler configuration
Coverity translate configuration
Files configuration
Import SCM configuration
Language configuration
Parallel translate configuration
Web archive configuration
Analysis configuration
Checker configuration
Specific checker configuration
Coding standard configuration
Pre-canned coding standard configurations
Specific coding standard configuration
Resolved coding standard configuration
Coding standard deviation
Analyze Connect configuration
Directives configuration
Resolved security directive configuration
Analyze files configuration
Jobs configuration
Parse warnings configuration
Sigma configuration
Web app security configuration
Commit configuration
Connect configuration
Snapshot configuration
Triage configuration
Local configuration
Caching configuration
Troubleshooting issues
coverity list
Diagnostics document
Log file
Point and Scan and the CLI Support matrix
Bazel support
Go support
Using the Coverity CLI to override configuration defaults
Editing configuration settings
Compiler configuration
Disabling command inference
Capturing or excluding code for a specific language
Including or excluding files specified by regular expressions
Including or excluding files specified by glob patterns
Including libraries or library directories
Coverity CLI commands
coverity analyze
coverity capture
coverity commit
coverity help
Configuration syntax help
coverity list
coverity scan
coverity setup
Getting started with Coverity Desktop
Coverity Desktop Analysis: User Guide
Desktop Analysis overview
Choosing a user interface
Requirements
Getting help
Desktop Analysis quick start guide
What you will need
Installing Coverity Analysis tools
Desktop Analysis on the command line
Creating coverity.conf
Adding the bin directory to your PATH
Run cov-run-desktop --setup
Analyzing a source file
Reviewing defects
Running Desktop Analysis from an editor or IDE
Using Desktop Analysis with Emacs
Using Desktop Analysis with Vim
Desktop Analysis in an IDE
Coverity Connect integration
Using an authentication key
Disconnected mode
Administering Desktop Analysis
Creating coverity.conf for a code base
Using Visual Studio Code to edit the coverity.conf configuration file
Using Visual Studio to edit the coverity.conf configuration file
Add data-coverity to the Source-Code Management (SCM) exclusion list
Desktop Analysis reference
Concepts
The cov-run-desktop command
Defining the analysis scope
Source code management system integration
Analyzing non-primary source files (C/C++)
Compiling files on demand
Running security checkers with cov-run-desktop
Analyzing your whole program with cov-run-desktop
Local defect owner assignment
Desktop Analysis usage tracking
Reasons for results differences
Effect of component permissions
Desktop Analysis JSON output syntax
CoverityIssues
IssueOccurrence
Event
StateOnServer
CheckerProperties
Triage
CustomTriage
LocalTriage
DesktopAnalysisSettings
ReferenceSnapshotDetails
PortableAnalysisSettings
FileCheckerOption
Error
coverity.conf file format
coverity.conf
UserDefinedVariables
ConditionalSettings
Condition
Settings
Server
CovRunDesktopSettings
SCMSettings
CompilerConfiguration
KnownInstallation
ExtendDirectories
Checkers
CheckerSettings
CheckerOptions
string
Regular expression (regex)
path
CodeXMFiles
Example coverity.conf file
IDESettings
PathMapping
Backwards compatibility
Troubleshooting Desktop Analysis
Coverity Desktop User Guide (Eclipse)
Coverity Desktop overview
About this guide
Coverity Desktop for Eclipse requirements
Getting help
Coverity Desktop concepts and use cases
Concepts
Use cases
Use case - using Coverity Desktop with central analysis
Use case - using Coverity Desktop with local analysis
Use case - using Coverity Desktop with central and local analysis
Getting started
Retrieving remote issues
Running a local analysis
Analysis options and views
Toolbar shortcuts
Coverity menu
View Issues from Coverity Server
Capture Build of Entire Scope
Analysis scope options
Offline mode
Show View sub-menu
Analysis Configurations...
Coverity Desktop Plugin User Guide
Coverity Desktop Help Center
Issues view
Configuring the Issues view display
Sorting issues
Issue filters
Pre-defined filters
Customized filters
Context menu
Details view
Issue information
Triaging an issue
Occurrences tab
History tab
Issue attributes
Classification
Severity
Action
Ext. Reference
Owner
Comment
Collect Diagnostics
Analysis Configurations... dialog
General configuration
Compiler Configuration dialog
Coverity Connect
Streams
SCM
Advanced configuration
Advanced: Build
Advanced: Analysis
Advanced: Scope
Advanced: Reference Snapshot
Advanced: File Exclusions
Advanced: File Path Mapping
Advanced: Workflow
Dynamic variables
Troubleshooting Coverity Desktop for Eclipse
Finding more information about issues
Coverity Desktop User Guide (IntelliJ IDEA and Android Studio)
Coverity Desktop overview
Requirements
Getting help
Coverity Desktop concepts and use cases
Concepts
Use cases
Use case - using Coverity Desktop with central analysis
Use case - using Coverity Desktop with local analysis
Use case - using Coverity Desktop with central and local analysis
Getting started
Retrieving remote issues
Running a local analysis
Analysis options and views
Toolbar shortcuts
Coverity menu
View and Triage Issues from Coverity Server...
Analysis scope options
Analysis Configurations...
Coverity Desktop Plugin User Guide
Coverity Desktop Help Center
Issues view
Sorting issues
Issue filters
Pre-defined filters
Customized filters
Context menu
Details view
Issue information
Triaging an issue
Occurrences tab
History tab
Issue attributes
Classification
Severity
Action
Ext. Reference
Owner
Comment
Collect Diagnostics
Analysis Configurations... dialog
General configuration
Compiler Configuration dialog
Coverity Connect
Streams
SCM
Advanced configuration
Advanced: Build
Advanced: Analysis
Advanced: Scope
Advanced: Reference Snapshot
Advanced: File Exclusions
Advanced: File Path Mapping
Local analysis with Gradle
Coverity Desktop User Guide (Microsoft Visual Studio)
Coverity Desktop overview
About this guide
Requirements
Getting help
Coverity Desktop concepts and use cases
Concepts
Use cases
Use case - using Coverity Desktop with central analysis
Use case - using Coverity Desktop with local analysis
Use case - using Coverity Desktop with central and local analysis
Getting started
Retrieving remote issues
Running a local analysis
Analysis options and views
Toolbar shortcuts
Coverity menu
View Issues from Coverity Server
Capture Build of Solution
Analysis scope options
Offline mode
Windows
Analysis Configurations...
Coverity Desktop Plugin User Guide
Coverity Desktop Help Center
Issues view
Configuring the Issues View Display
Sorting issues
Issue filters
Pre-defined filters
Customized filters
Context menu
Details view
Issue information
Triaging an issue
Occurrences tab
History tab
Issue attributes
Classification
Severity
Action
Ext. Reference
Owner
Comment
Intermediate Directory Details view
Collect Diagnostics
Analysis Configurations... dialog
General configuration
Coverity Connect
Streams
SCM
Advanced configuration
Advanced: Build
Advanced: Analysis
Advanced: Scope
Advanced: Reference Snapshot
Advanced: File Exclusions
Advanced: File Path Mapping
Advanced: Workflow
Dynamic variables
Troubleshooting Coverity Desktop for use with Visual Studio
Installing Coverity Desktop components
Installing Coverity Desktop for Eclipse, Wind River Workbench, QNX Momentics, and IBM RTC
Installing Coverity Desktop with the update site
Installing Coverity Desktop from your local desktop
Auto-configuring compilers for the QNX and WindRiver toolchains
Uninstalling Coverity Desktop
Installing Coverity Desktop for Microsoft Visual Studio
Installing and updating Coverity Desktop for Visual Studio using a gallery
Installing Coverity Desktop for IntelliJ IDEA and Android Studio
Installing Coverity Desktop from your local desktop
Installing Coverity Analysis for local analysis
Coverity product components: supported versions and compatibility
Coverity Desktop
Version compatibility with Coverity Connect and Coverity Analysis
IDE and Java version support
Coverity Desktop for Eclipse on supported platforms
Coverity Desktop for IBM Rational Team Concert (RTC) on supported platforms
Coverity Desktop for ARM Development Studio 5 (DS-5) on supported platforms
Coverity Desktop for Wind River Workbench on supported platforms
Coverity Desktop for QNX Momentics IDE on supported platforms
Coverity Desktop for Microsoft Visual Studio IDE on supported platforms
Coverity Desktop for IntelliJ IDEA on supported platforms
Coverity Desktop for Android Studio on supported platforms
Coverity Desktop for other IntelliJ-based IDEs on supported platforms
Coverity Connect APIs
Coverity Platform SOAP Web Services API Reference
API guides
Coverity Platform SOAP Web Services API Reference (v9)
Description
Sources
Overview
Audience
Getting started
Configuration Service web service
Operations: Configuration Service
Operation: copyStream
Operation: createAttribute
Operation: createComponentMap
Operation: createGroup
Operation: createLdapConfiguration
Operation: createProject
Operation: createRole
Operation: createStream
Operation: createStreamInProject
Operation: createTriageStore
Operation: createUser
Operation: deleteAttribute
Operation: deleteComponentMap
Operation: deleteGroup
Operation: deleteLdapConfiguration
Operation: deleteProject
Operation: deleteRole
Operation: deleteSnapshot
Operation: deleteStream
Operation: deleteTriageStore
Operation: deleteUser
Operation: executeNotification
Operation: getAllLdapConfigurations
Operation: getAllPermissions
Operation: getAllRoles
Operation: getAttribute
Operation: getAttributes
Operation: getBackupConfiguration
Operation: getCategoryNames
Operation: getCheckerNames
Operation: getCommitState
Operation: getComponent
Operation: getComponentMaps
Operation: getDefectStatuses
Operation: getDeleteSnapshotJobInfo
Operation: getDeveloperStreamsProjects
Operation: getGroup
Operation: getGroups
Operation: getLdapServerDomains
Operation: getLicenseConfiguration
Operation: getLicenseState
Operation: getLoggingConfiguration
Operation: getMessageOfTheDay
Operation: getOutputFileForSnapshot
Operation: getProjects
Operation: getRole
Operation: getServerTime
Operation: getSignInConfiguration
Operation: getSkeletonizationConfiguration
Operation: getSnapshotInformation
Operation: getSnapshotPurgeDetails
Operation: getSnapshotsForStream
Operation: getStandardAttribute
Operation: getStandardAttributes
Operation: getStreams
Operation: getSystemConfig
Operation: getTriageStores
Operation: getTypeNames
Operation: getUser
Operation: getUsers
Operation: getVersion
Operation: importLicense
Operation: notify
Operation: refreshLdapGroup
Operation: setAcceptingNewCommits
Operation: setBackupConfiguration
Operation: setLoggingConfiguration
Operation: setMessageOfTheDay
Operation: setSkeletonizationConfiguration
Operation: setSnapshotPurgeDetails
Operation: updateAttribute
Operation: updateComponentMap
Operation: updateGroup
Operation: updateLdapConfiguration
Operation: updateProject
Operation: updateRole
Operation: updateSignInConfiguration
Operation: updateSnapshotInfo
Operation: updateStream
Operation: updateTriageStore
Operation: updateUser
Complex types: Configuration Service
Complex type: attributeDefinitionDataObj
Complex type: attributeDefinitionIdDataObj
Complex type: attributeDefinitionSpecDataObj
Complex type: attributeValueChangeSpecDataObj
Complex type: attributeValueDataObj
Complex type: attributeValueIdDataObj
Complex type: attributeValueSpecDataObj
Complex type: backupConfigurationDataObj
Complex type: commitStateDataObj
Complex type: componentDataObj
Complex type: componentDefectRuleDataObj
Complex type: componentIdDataObj
Complex type: componentMapDataObj
Complex type: componentMapFilterSpecDataObj
Complex type: componentMapIdDataObj
Complex type: componentMapSpecDataObj
Complex type: componentPathRuleDataObj
Complex type: configurationDataObj
Complex type: CovRemoteServiceException
Complex type: deleteSnapshotJobInfoDataObj
Complex type: featureUpdateTimeDataObj
Complex type: getOutputFileForSnapshot
Complex type: getOutputFileForSnapshotResponse
Complex type: groupDataObj
Complex type: groupFilterSpecDataObj
Complex type: groupIdDataObj
Complex type: groupsPageDataObj
Complex type: groupSpecDataObj
Complex type: ldapConfigurationDataObj
Complex type: ldapConfigurationSpecDataObj
Complex type: licenseDataObj
Complex type: licenseSpecDataObj
Complex type: licenseStateDataObj
Complex type: localizedValueDataObj
Complex type: loggingConfigurationDataObj
Complex type: outputFileDataObj
Complex type: pageSpecDataObj
Complex type: permissionDataObj
Complex type: projectDataObj
Complex type: projectFilterSpecDataObj
Complex type: projectIdDataObj
Complex type: projectSpecDataObj
Complex type: roleAssignmentDataObj
Complex type: roleDataObj
Complex type: roleIdDataObj
Complex type: roleSpecDataObj
Complex type: serverDomainIdDataObj
Complex type: signInSettingsDataObj
Complex type: skeletonizationConfigurationDataObj
Complex type: snapshotFilterSpecDataObj
Complex type: snapshotIdDataObj
Complex type: snapshotInfoDataObj
Complex type: snapshotPurgeDetailsObj
Complex type: standardAttributeDataObj
Complex type: standardAttributeIdDataObj
Complex type: standardAttributeValueDataObj
Complex type: standardAttributeValueIdDataObj
Complex type: streamDataObj
Complex type: streamFilterSpecDataObj
Complex type: streamIdDataObj
Complex type: streamSpecDataObj
Complex type: triageStoreDataObj
Complex type: triageStoreFilterSpecDataObj
Complex type: triageStoreIdDataObj
Complex type: triageStoreSpecDataObj
Complex type: userDataObj
Complex type: userFilterSpecDataObj
Complex type: usersPageDataObj
Complex type: userSpecDataObj
Complex type: versionDataObj
Simple types: Configuration Service
Simple type: deleteSnapshotJobStatus
Defect Service web service
Operations: Defect Service
Operation: getComponentMetricsForProject
Operation: getFileContents
Operation: getMergedDefectDetectionHistory
Operation: getMergedDefectHistory
Operation: getMergedDefectsForProjectScope
Operation: getMergedDefectsForSnapshotScope
Operation: getMergedDefectsForStreams
Operation: getStreamDefects
Operation: getTrendRecordsForProject
Operation: getTriageHistory
Operation: updateDefectInstanceProperties
Operation: updateStreamDefects
Operation: updateTriageForCIDsInTriageStore
Complex types: Defect Service
Complex type: attributeDefinitionIdDataObj
Complex type: attributeDefinitionValueFilterMapDataObj
Complex type: attributeValueIdDataObj
Complex type: componentIdDataObj
Complex type: componentMetricsDataObj
Complex type: CovRemoteServiceException
Complex type: defectChangeDataObj
Complex type: defectDetectionHistoryDataObj
Complex type: defectInstanceDataObj
Complex type: defectInstanceIdDataObj
Complex type: defectStateAttributeValueDataObj
Complex type: defectStateDataObj
Complex type: defectStateSpecDataObj
Complex type: eventDataObj
Complex type: fieldChangeDataObj
Complex type: fileContentsDataObj
Complex type: fileIdDataObj
Complex type: functionInfoDataObj
Complex type: localizedValueDataObj
Complex type: mergedDefectDataObj
Complex type: mergedDefectFilterSpecDataObj
Complex type: mergedDefectIdDataObj
Complex type: mergedDefectsPageDataObj
Complex type: pageSpecDataObj
Complex type: projectIdDataObj
Complex type: projectMetricsDataObj
Complex type: projectScopeDefectFilterSpecDataObj
Complex type: projectTrendRecordFilterSpecDataObj
Complex type: propertyDataObj
Complex type: propertySpecDataObj
Complex type: snapshotScopeDefectFilterSpecDataObj
Complex type: snapshotScopeSpecDataObj
Complex type: standardAttributeIdDataObj
Complex type: standardAttributeValueFilterMapDataObj
Complex type: standardAttributeValueIdDataObj
Complex type: streamDefectDataObj
Complex type: streamDefectFilterSpecDataObj
Complex type: streamDefectIdDataObj
Complex type: streamIdDataObj
Complex type: triageHistoryDataObj
Complex type: triageStoreIdDataObj
Types and constants
Action
Attribute name
Attribute type (attributeType)
Date time (dateTime)
Domain
Event kind (eventKind)
Issue kind (issueKind)
Language
Locale
Permission
Role assignment type (roleAssignmentType)
Role type (roleAssignmentDataObj.type)
Role ID (Built-in Roles: roleAssignmentDataObj.roleId)
Severity
Status
Error codes
1000-1099: General
1100-1199: User
1200-1299: Attribute
1300-1399: Project, stream, snapshot
1400-1499: Defect
1501-1599: Internal errors
1600-1699: Component
1700-1799: Role
1800-1899: File and function
1900-1999: License
2000-2099: Triage store
2100-2199: LDAP
2200-2299: View notification
SOAP Web Services API Glossary
Attribute
Checker
CID
component
defect
external (ext.) reference
fix target
permission
project
role
snapshot
source version
stream
subcategory
target
triage
triage store
version
API history
Change log: Configuration Service
Operations: Configuration Service
Data objects: Configuration Service
Change log: Defect Service
Operations: Defect Service
Data objects: Defect Service
Coverity Platform REST Web Services API Guide
Audience
Migrating from the SOAP API to the REST Web Services API
Coverity Platform REST Web Services API overview
Introduction to Coverity Platform REST Web Services API
Terminology
Accessing the API
Example workflow
Checker attributes
Retrieve all checker-related attributes
Retrieve available values for a checker-related attribute
Commit gate
Find out whether the database is accepting new commits of analysis results
Control whether the database accepts new commits of analysis results
Component maps
Create new component map and associated components
Retrieve the specified component map
Retrieve all component maps
Update component map and associated components
Delete component map
Components
Retrieve the specified component
Email notifications
Send email notification for the specified view
Files
Search for files by path
Search for files by content hash
Health check
Retrieve JSON health check report
Generate health check report
Retrieve generation status on health check report
Stop health check report generation
Issue attributes
Retrieve available values for the issue status attribute
Issue categorization maps
Download issue categorization map
Issue occurrences
Retrieve all column keys for issue occurrences
Retrieve all issue occurrences from a project
Retrieve issue occurrence counts by category
Issues
Retrieve all column keys for issues
Retrieve issue detection history
Retrieve all high impact issues from a project
Retrieve all issues from a project
Retrieve issue counts by category
Retrieve source code information
Update triage attribute values
Retrieve triage history
Retrieve triage history for multiple issues
LDAP configurations
Create LDAP configuration
Retrieve all LDAP configurations
Update LDAP configuration
Delete LDAP configuration
Retrieve all LDAP domains
Refresh LDAP group
Licenses
Import Coverity Connect license file
Retrieve Coverity Connect license information
Locales
Retrieve all supported locales
Logging configuration
Retrieve logging configuration
Configure logging options
Maintenance
Retrieve database backup schedule
Set database backup schedule
Back up the database now
Retrieve configuration for purge analysis summaries process
Update configuration for purge analysis summaries process
Retrieve configuration for purge snapshot details process
Update configuration for purge snapshot details process
Metrics
Retrieve HIS-metrics measurements, code-metrics measurements, and metadata for the specified source code file
Retrieve HIS-metrics measurements, other measurements, and metadata for the specified function
Permissions
Retrieve all permissions
Policy Manager
Trigger ETL process
Projects
Create a project
Retrieve the specified project
Retrieve all projects
Update project
Delete project
Retrieve code-analysis measurements segmented by component
Retreive code-analysis trends for specified project
Retrieve the Developer Streams project
Roles
Create a role
Retrieve the specified role
Retrieve all roles
Update a role
Delete a role
SAML configurations
Create SAML configuration
Retrieve SAML configuration
Update SAML configuration
Delete SAML configuration
Retrieve identity provider (IdP) metadata
Retrieve service provider (SP) metadata
Scan Proxy Services
Server info
Retrieve configuration
Retrieve message of the day
Update message of the day
Retrieve date and time
Retrieve version number
Sign-in configurations
Retrieve current sign-in configuration
Update current sign-in configuration
Snapshots
Retrieve information about a snapshot
Update snapshot attributes
Delete a snapshot
Retrieve snapshot deletion status
Retrieve snapshot output file
Purge and skeletonize snapshots
Standard attributes
Retrieve the specified standard attribute
Retrieve all standard attributes
Streams
Create a stream
Retrieve a stream
Retrieve all streams
Update a stream
Copy the specified stream
Delete a stream
Retrieve stream UUID
Retrieve stream snapshot IDs
Retrieve scan transparency data
Clear role assignments for streams
Retrieve the latest snapshot ID for a stream
Triage attributes
Create a triage attribute ("list of values" type)
Create a triage attribute ("free-form text" type)
Retrieve the specified triage attribute
Retrieve all triage attributes
Update triage attribute ("list of values" type)
Update triage attribute ("free-form text" type)
Delete triage attribute
Triage stores
Create a triage store
Retrieve the specified triage store
Update a triage store
Delete a triage store
User groups
Create a user group
Retrieve user groups
Update a user group
Delete a user group
Retrieve all user groups
Users
Create a user
Retrieve all users
Update a user
Delete a user
Retrieve the specified user
Views
Create a new view
Delete a view
Retrieve all views accessible to the current user
Retrieve contents of specified view
Retrieve metadata for all views
Reassign ownership of all views
Reassign ownership of specified view
Update view settings
Retrieve view settings
View types
Retrieve column keys for the specified view type
Retrieve data for the specified view type
View management operations (v1)
PATCH api/view/v1/username/{source_user}/ldap/{source_ldap}
Description
Parameters
Path Parameters
Payload Parameters
Response
Examples
PATCH api/view/v1/view/{view_id}
Description
Parameters
Path Parameters
Payload Parameters
Response
Examples
GET api/view/v1/views
Description
Parameters
Response
Examples
GET api/views/v1
Description
Parameters
Response
Examples
GET api/viewContents/{type}/v1/{view_id}
Description
Parameters
Path Parameters
Query Parameters
Response
Examples
Coverity Platform REST Web Services API (v2)
CIM API Guide
Coverity Platform REST Scan Proxy Services API (v2)
Scan Proxy API Guide
Cloud Native Coverity deployment
Coverity Cloud Deployment Administrator and User Guide
About this document
Using this document
Conventions
Using this document with other Coverity documents
About Coverity cloud deployment
Coverity cloud deployments
Coverity Connect-only deployment
Coverity Connect with Scan Service deployment
Connect Web application high availability
Benefits of using Connect Web application HA
Scan Services
Thin Client
Scan List view
Customer responsibility and deployment workflow
Customer responsibilities
Black Duck responsibilities
Coverity deployment scenarios
Coverity cloud quick-start chart and scripts - simplified version
Connect-only quick start process - full version
Deploy Connect and Scan Service
Deploy Connect and Scan Service with onPrem OCI Redis and MinIO
Coverity re-deployed from data center to cloud
Coverity re-deployed from public cloud to Kubernetes
Obtaining Black Duck Community access, Coverity licenses, registry credentials, Helm chart, and client software
Request access to Black Duck Community
Obtain your Coverity licenses
Request Black Duck Docker registry credentials
Access the Black Duck private Docker registry credentials
About Black Duck repositories
Downloading the Helm chart from the Black Duck public Docker registry
Coverity client installer and documentation files
Downloading a Coverity toolkit artifact from the Black Duck repository
Set NGINX proxy-body-size for Coverity toolkit tar file upload to Connect
Downloading a full analysis client file from the Black Duck repository
Downloading platform, host ID, and documentation files from the Black Duck registry using curl
Managing container images
About Kubernetes container image management
Coverity container images
Open source container images
Create a container image pull secret
Preparing container image and registry keys
Preconfigured container image keys
imageRegistry keys
imagePullSecret keys
imagePullPolicy Helm keys
Preparing to deploy containers from container images located in your own private registry
Create your own private Docker registry
Pull container images from the Black Duck private Docker registry
Tag images
Push images to your private Docker registry
Preparing to deploy containers from container images located in the Black Duck registry
Infrastructure and configuration
Install required software
Access privileges
Administrator credentials
Kubernetes client user privileges
Coverity permissions to manage Scan Services resources
Create a VPC
Create a Kubernetes cluster
Expose the Kubernetes cluster
Install an ingress controller
Create a Kubernetes namespace
Configure Kubernetes logging
Size, create, and manage PostgreSQL databases and pod
Size Connect (cim) pod resources
Create a storage bucket for Scan Service
Scan Service storage bucket sizing
Create and configure a cache storage bucket
Install and configure Redis
Configuring Helm keys to support onPrem or non-platform-specific deployments using Redis and Minio
Setting up ARM64 support
ARM64 Thin Client support
Specifying ARM64 node pools
AWS ARM64
Azure ARM64
GCP ingress controller taints and tolerations
GCP ARM64 node pool
GCP taints and tolerations for ARM64
Amazon AWS infrastructure and configuration
Amazon AWS account privileges
AWS: Set the cloud administrator role
AWS: Install AWS CLI, eksctl, and kubectl
AWS: Install Helm
AWS: Install Docker
Create an AWS EKS cluster
AWS: Install an ingress controller
Create a PostgreSQL database
Create the PostgreSQL Certificate and add it to the Connect truststore
AWS: Create EKS cluster IAM policy and role
AWS: Create scan job node pool(s)
AWS: Create an S3 Express bucket
AWS: Create S3 Express bucket IAM policies
AWS: Create an S3 storage bucket
AWS: Create a cache storage bucket
Specifying AWS S3 storage bucket and cache bucket IAM policy
Using a role-based AWS service account for Storage Service and Cache Service
Configuring AWS ElastiCache and Redis
Get the Redis TLS CA certificate and add it to the truststore ConfigMap
AWS: Create Coverity cloud deployment secrets and ConfigMap
Configuring Helm keys to support AWS using S3 or S3 Express
Configure AWS S3 Helm keys
Configure AWS S3 Express Helm keys
Google GCP infrastructure and configuration
Google GCP administrator privileges/roles
GCP: Install and set up the gcloud CLI
GCP: Install kubectl
GCP: Install Docker
GCP: Install Helm
Create a GKE cluster
Grant cluster-admin permissions to user
Add credentials to kubeconfig
GCP: Install an ingress controller
Create a Google Cloud SQL database
Create the Cloud SQL server CA certificate and add it to the truststore ConfigMap
Add SQL users
GCP: Create Coverity cloud deployment secrets and ConfigMap
GCP: Create scan job node pool(s)
Create a storage bucket
Create a cache bucket
Create and set a lifecycle rule for the cache bucket
Create a service account (SA)
Create SA access to the GCS storage bucket and cache bucket
Grant SA access to Google Cloud SQL
Create an IAM service account key
Create a Redis instance
Configure Helm keys to support GCP using GCS
Microsoft Azure infrastructure and configuration
Microsoft Azure administrator privileges/roles
Azure: Install the Microsoft Azure CLI
Azure: Install Helm
Azure: Install Docker
Create an AKS cluster
Install kubectl on Azure
Azure: Install an ingress controller
Create an Azure PostgreSQL database
Azure considerations when creating or migrating a PostgreSQL database
Kubernetes container privileges and roles
Azure AKS: Create scan job node pool(s)
Create a storage account (SA)
Show storage account properties
Create an Azure blob storage container
Configure Storage Service access to the storage blob
Using an Azure shared key client secret for RBAC
Using an Azure Entra ID client secret for RBAC
Create a cache container
Create a lifecycle rule for the cache container
Configure Azure cache for Redis
Azure: Create Storage Service secrets and ConfigMap
Configure Helm keys to support Azure using Azure blob
Red Hat OpenShift infrastructure and configuration
OpenShift routing - exposing the Coverity cloud instance outside an OpenShift cluster
Manage automatic route creation using existing ingress settings
Manage route creation using the cnc Helm chart
Create routes using the OpenShift UI
Configure an ingress route to MinIO in OpenShift
Advanced OpenShift route considerations
OpenShift route troubleshooting
PostgreSQL databases and PostgreSQL pod
Create PostgreSQL databases
AWS: Create PostgreSQL databases
Azure: Create PostgreSQL databases
GCP: Create CloudSQL PostgreSQL databases
OpenShift: Create PostgreSQL databases
Migrating a PostgreSQL database instance to the cloud
Migration prerequisites
AWS: migrating a database
Azure: migrating a database
GCP: migrating a database
Red Hat OpenShift: migrating a database
Verifying external integrations
Sizing PostgreSQL pod resources
PostgreSQL pod minimum resource requirements
Sizing PostgreSQL pod RAM
Using PostgreSQL read replicas and Pgpool to balance database loads
PostgreSQL database read replica architecture
Determining when to deploy PostgreSQL database read replicas
PostgreSQL database read replica setup
Create a dbreadreplica-values.yaml file
Configure SSL for Pgpool PostgreSQL connections
Configure the trust-stores ConfigMap for PostgreSQL SSL
Configure the cim.pgpool Helm keys
Deploy database read replicas
Managing Connect PostgreSQL database size and integrity
Statically tuning an external Connect PostgreSQL database
Creating a tuning job yaml file
static-tuning-write.yaml - Tuning-write template
static-tuning-suggest.yaml - Acquiring database static tuning suggestions
Image properties
AWS RDS properties for tuning-write
Azure Flexible Server properties for tuning-write
GCP Cloud SQL properties for tuning-write
Other platform properties for tuning-write
Hardware resource properties
AWS RDS IsSSD property
Azure flexible server IsSSD property
GCP Cloud SQL IsSSD property
Instance identifier for tuning-write
CIM properties secret
SSL setting and volume mount
Run a database tuning job
Monitor the logs
Restart the database
Gateway API
Configuring and deploying the gateway API
Deploying the gateway: one gateway per namespace
Deploying the gateway: shared gateway
NGINX ingress controller
NGINX gateway fabric
TLS certificates — how they work
TLS flow
About TLS sidecar
TLS secret and certificate rules
About NGF and GKE
Deployment scenario — production with scan-services (recommended)
Deployment scenario — production without scan-services (HTTPS only)
Deployment scenario — development / internal (HTTP only, no TLS)
Deployment scenario — external gateway (chart creates routes only)
IP allowlisting
Client settings policy
About the GKE gateway (Google cloud load balancer)
Google Kubernetes Engine (GKE)
Amazon Elastic Kubernetes Service (EKS)
Option A: NGINX gateway fabric on EKS
IP allowlisting on EKS with NGF
Option B: AWS Load Balancer Controller
IP allowlisting on EKS with AWS LBC
Azure Kubernetes Service (AKS)
Option B: Azure Application Load Balancer controller
IP allowlisting on Azure ALB
Migrating from NGINX ingress to gateway API
Verification
Troubleshooting
Sizing a Coverity Connect (cim) pod for optimum performance
Coverity Connect (cim) pod minimum resource requirements
Scaling cim pod CPU and memory using commits
Medium IDIRs (2.6 GB)
Large IDIRs (12 GB)
Extra Large IDIRs (36 GB)
Commit considerations
How was Commit data gathered?
Scaling cim pod CPU and memory using view loading
Medium project (10K issues)
Large project (up to 25K issues)
Extra-large project (50K issues)
View loading considerations
View loading - How was the data gathered?
Create TLS certificate, keystore, and secrets
Generating a Connect TLS certificate
Generating a Coverity Connect TLS certificate signed by a Certificate Authority
Create a Cache Service CA certificate secret for Redis
Create a Connect UI server keystore
Create a Kubernetes ingress TLS secret
Create a Connect license secret
Create a container image pull secret
Create a scan tool synchronization secret
Creating secret(s) for PostgreSQL access
Creating a Connect Web application administator password secret
Create a Scan Service license secret
Creating a secret for MinIO storage type
Create an AWS storage service secret
Create an Azure service account secret
Create an Azure Cache Service secret
Create a GCS service account secret
Create a truststore ConfigMap for Connect communication over TLS
Creating a truststore ConfigMap for a Connect instance
AWS: Downloading certificates and creating a truststore ConfigMap
Add an SMTP certificate to the Coverity Connect truststore
Working with cnc chart and scan-services subchart
About the cnc chart and scan-services subchart
cnc Helm chart and the Chart.yaml file
scan-services Helm subchart
Setting global Helm key values
Example: global values
Example: Connect-only deployment
Example: Connect and Scan Services deployment
Viewing Helm chart values
Preparing Helm keys to deploy Coverity
Configuring pod and container security context
Preparing Helm overrides for a Connect instance
Enable Kubernetes deployment
Enable Connect
Specify the name of the Connect license secret
Configure NGINX ingress-class controllers or the gateway API
Working with nginxConfig Helm keys
Open and expose the commit port
Enable truststores
Configure the Connect web application TLS keystore
Configuring Connect web app high availability
Disabling the scan-services Helm subchart for a Connect-only deployment
Preparing cim.cimweb Helm keys
Specify the Coverity Connect Web URL
Set the cim.cimweb.adminPasswordSecret Helm key
Specify a context path
Environment variables
Coverity Connect properties
Java options
Create PostgreSQL database access credentials
Specify PostgreSQL credentials using secrets
Specify PostgreSQL credentials in the Helm chart
Select the PostgreSQL sslmode and find the PostgreSQL root certificate for TLS
Create OpenShift Helm overrides
Specify the image version and type for OpenShift
Create a project
Enabling Coverity metrics through Helm overrides
Specifying logging levels
Creating Helm overrides to install Scan Service
Enabling the scan-services Helm subchart
Enable license jobs
Specify the name of the Scan Service license secret
Set Helm keys to enable scan tool synchronization
Set the Scan Service storage retention period
Managing artifact upload to storage
Storage Service Helm keys
Setting MinIO storage type Helm keys
Storage service custom domains
Configure Dell ECS storage support
Configure Red Hat OpenShift storage
Configuring postgres Helm keys for Scan Service and Storage Service databases
Attaching a Cloud SQL proxy native sidecar container in GCP
Adding init containers within pods
Mounting additional volumes to pods
Attaching a GCP Cloud SQL proxy as a native sidecar to a pod
Scan Service caching
Cache Service keys
Readiness probe keys
Liveness probe keys
Cache annotation key
AWS keys for Cache Service
Azure key
GCP keys
MinIO cache Helm keys
Redis keys
Configuring TLS forward proxy
TLS proxy
mTLS proxy
TLS insecure proxy
Configuring pod and container security
Pod and container security context Helm keys
Security context constraints
containerSecurityContext and scan jobs
automountServiceAccountToken Helm keys
Generate a Connect SA admin user token
Creating scan job node pools and scheduling scan jobs
Overview: Scheduling each scan job on its own node
Overview: Scheduling multiple scan jobs concurrently on a single node
Scan Service and Storage Service requirements
Scan job node pool sizing
Creating a scan job node pool
Using node autoscaler to scale nodes and meet demand
Enabling single vs multiple scan jobs per node
Configuring one scan job per node, multiple node pools
Configuring multiple scan jobs per node, single node pool
Taints and tolerations
Switching between single vs multiple scan jobs per node
Setting up onPrem OCI Redis, MinIO, and PostgreSQL for Scan Service
OCI-based registry
Optionally create and use a global container image registry
Redis and MinIO dependencies in cnc/Chart.yaml
Enabling OCI Redis, MinIO, and PostgreSQL
MinIO PersistentVolumeClaim (PVC) size
AWS: Using EBS persistent storage as MinIO PVC
AWS: Load Balancer Controller
AWS: Create IAM policy for AWS Load Balancer Controller Service Account
AWS: Install the aws-load-balancer-controller chart and tag subnets
AWS: Helm overrides and annotations
AWS: Generating a CNAME ingress certificate
GCP: Configuring GCE container native load balancer
Building a full analysis kit and automatically uploading the kit to Connect during deployment
Connect Web application high availability
Connect Web application HA performance
Setting up and managing high availability
Managing cimweb pod replicas
Optimizing commit performance vs throughput using commit-server pods
Using affinities to distribute pods on nodes
Re-deploying Coverity Connect Web applications
Web application pod failure scenario
Known issues with Coverity Connect Web application HA
Deploying the AI-Assisted Triage Plug-in
Generating a key pair
Configuring authentication secrets
Configuring LLM API keys
Uninstalling AI-Assisted Triage Plug-in
Changing LLM provider
Installing chart releases for your deployment
Using the helm install command
Helm chart validation and error logging
Installing the chart release for a single Coverity instance
Post installation or upgrade tasks
Accessing the Connect UI
Uploading the Coverity Connect license
Configuring SAML
Configure LDAP
Configuring Jira
Adding a Bugzilla certificate
Configuring Kerberos
Verifying the Coverity cloud deployment
Managing supported Coverity Tools and Thin Client versions in the Connect UI
Uploading Coverity Tools artifacts to the Connect UI
The Available Coverity Tools window
Default Coverity Tools version and CI/CD pipelines
Setting the default Coverity Tools version for CI/CD pipelines
Unsetting the default Coverity Tools version for CI/CD pipelines
Changing the default Coverity Tools version for CI/CD pipelines
Archiving a Coverity Tools version
Deleting a Coverity Tools version
Installing client software
Installing Coverity Thin Client on a client system
Installing the full Coverity Analysis client on a client system
Using the Black Duck Bridge CLI to integrate Thin Client analysis into pipelines
What is next? preparing and performing analyses
Managing the Connect Web application administator password
Connect Web application administator password requirements
Create a Connect Web application administator password secret
Set the cim.cimweb.adminPasswordSecret Helm key
Manually changing a Connect Web application administator password
Metrics
Setting up Helm keys to make metrics available
Expose metrics to data acquisition and monitoring software
Setting up Helm keys to add annotations for scraping
Setting up metrics presentation
Coverity Connect metrics example
Enabling event logs for some metrics
Connect application metrics in Coverity cloud deployment
Managing and interpreting metrics
Performance metrics
Commit metrics
View loading metrics
API metrics
Database metrics
Scan Service metrics
Storage Service metrics
Backup and skeletonization metrics
Stream lock metrics
Redis cache metrics
Software analysis metrics
Kubernetes metrics
Preserving and analyzing logs to discover root problems
Connect UI System Totals list
Managing a Coverity cloud deployment
Connect management procedures
Coverity Connect: get the Connect configuration
Connectivity - verify kubectl connectivity
Helm - get the detailed status of a single Helm release
Helm - look for failed Helm releases
Kubernetes - check node health
Kubernetes - list events
Logs - inspect terminal logs
Pods - describe pod
Pods - list all pods
Pods - Pull logs from pods
Upgrading a Coverity cloud deployment
Prepare to upgrade Coverity
Performing an upgrade
Tasks to complete after an upgrade
Upgrade considerations
Upgrading to 2026.6
Upgrading to 2026.3
Upgrading to 2025.12.2
Upgrading to 2025.12
Upgrading to 2025.9.2
Working with the migrated Bitnami registry
Upgrading to 2025.9
Upgrading to 2025.6.2
Upgrading to 2025.6
Upgrading to 2025.3.1
Upgrading to 2025.3
Upgrading to 2024.12
Uninstalling a Coverity cloud deployment
Troubleshooting guidance
Scan service failure due to expired internal CA certificate
Chart failure upgrading to 2026.3 or newer Helm chart with AI-Assisted Triage Plug-in enabled
Downloading scan artifacts using the Coverity CLI
Downloading a scan log using the Connect API
Inspecting pod logs for errors
Expired or node-locked license
Debugging database connectivity
Problem with volumes
Microsoft Azure PostgreSQL database extensions fail
Missing secret or configmap
Ingress: the SAML URL uses http instead of https
Ingress headers: creating an Ingress annotation for Google GCP
Ingress headers: setting X-Forwarded-proto for NGINX
List and verify ingress
NGINX HTTP error 413: Request Entity Too Large
NGINX HTTP error 504: Gateway Timeout
Disable TLS sidecar on the cim-web pod
Change the NGINX ingress proxy timeout Helm key values
Create NGINX ingress proxy timeout annotations
NGINX redeploy Coverity cloud
Alternate method: Set proxy timeouts in the NGINX configMap
Restart the cim-web pod
Managing database size and integrity
Image pull issues
Pods fail to schedule
Missing the cim-tools pod
Read-only file system error
Coverity cloud support
Third-party software and platform support matrix
Coverity client support matrix
Supported Coverity Tools (Thin Client) and full analysis client versions
Historical Coverity support of Coverity Tools (Thin Client) and full analysis client
Docker base images
Ports
Scan Service storage support
Pod and container security context support
Helm keys for a Coverity cloud deployment
Global Helm keys
Root Helm keys
cnc Helm chart: Helm keys
scan-services Helm subchart: Helm keys
triage-suggestion-service Helm subchart
Coverity tools in a Coverity cloud deployment
Coverity cov-admin-db tools not supported in a Coverity cloud deployment
Create and mount a /data persistent volume
Checking database integrity: check-integrity.sh
Resetting the Coverity Connect password: reset-admin-password.sh
Managing archives: cov-archive.sh
Managing Coverity Connect: cov-manage-im
All checkers
SpotBugs™ Checker Reference
Introduction to the SpotBugs library
SpotBugs checkers
Security checkers
Coverity release notes and upgrade considerations
Coverity current release notes
Coverity 2026.6.x
Coverity 2026.6.0 Release Notes
PostgreSQL supported versions
Release notes archive
Coverity 2026.3.x
Coverity 2026.3.1 Release Notes
Coverity 2025.12.x
Coverity 2025.12.2 Release Notes
Coverity 2025.12.1 Release Notes
Coverity 2025.12.0 Release Notes
PostgreSQL supported versions
Coverity 2025.9.x
Coverity 2025.9.2 Release Notes
Coverity 2025.9.1 Release Notes
Coverity 2025.9.0 Release Notes
PostgreSQL supported versions
Coverity 2025.6.x
Coverity 2025.6.2 Release Notes
Coverity 2025.6.0 Release Notes
PostgreSQL supported versions
Coverity 2025.3.x
Coverity 2025.3.1 Release Notes
Coverity 2025.3.0 Release Notes
PostgreSQL supported versions
Coverity 2024.12.x
Coverity 2024.12.1 Release Notes
Coverity 2024.12.0 Release Notes
PostgreSQL supported versions
Coverity 2024.9.x
Coverity 2024.9.1 Release Notes
Coverity 2024.9.0 Release Notes
PostgreSQL supported versions
Coverity 2024.6.x
Coverity 2024.6.1 Release Notes
Coverity 2024.6.0 Release Notes
PostgreSQL supported versions
Coverity 2024.3.x
Coverity 2024.3.2 Release Notes
Coverity 2024.3.1 Release Notes
Coverity 2024.3.0 Release Notes
PostgreSQL supported versions
Coverity 2023.12.x
Coverity 2023.12.3 Release Notes
Coverity 2023.12.2 Release Notes
Coverity 2023.12.1 Release Notes
Coverity 2023.12.0 Release Notes
PostgreSQL supported versions
Coverity 2023.9.x
Coverity 2023.9.3 Release Notes
Coverity 2023.9.2 Release Notes
Coverity 2023.9.1 Release Notes
Coverity 2023.9.0 Release Notes
PostgreSQL supported versions
Coverity upgrade considerations
Important upgrade considerations
Upgrade considerations for 2026.6
Upgrade considerations for 2026.3
Upgrade considerations for 2025.12
Upgrade considerations for 2025.9
Upgrade considerations for 2025.6
Upgrade considerations for 2025.3
Checkers disabled in Sigma when running Coverity Analysis 2025.3
Upgrade considerations for 2024.12
Coverity Analysis
Coverity Analysis checkers replaced by Sigma checks in 2024.12.0
Coverity Connect
Coverity Point and Scan
Upgrade considerations for 2024.9
Coverity Analysis checkers replaced by Sigma checks in 2024.9.1
Coverity Analysis checkers replaced by Sigma checks in 2024.9.0
Upgrade considerations for 2024.6
Changes to Bazel integration method
Possible loss of triage information
Coverity Analysis checkers replaced by Sigma checks
Upgrade considerations for 2024.3
Changed path for emitted files in Bazel-built projects
Upgrade considerations for 2023.12
Upgrade considerations for 2023.9
Sigma checks re-enabled when running Coverity Analysis
Buildless capture
Coverity Analysis checkers replaced by Sigma checks
Removed Coverity Analysis checkers
Upgrade Considerations for 2023.6
Convert C++ style comments
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2023.3
Updated soft lockout policy
Coverity Analysis checkers replaced by Sigma checkers
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2022.12
Coverity Analysis checkers replaced by Sigma checkers
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2022.9
Coverity Analysis checkers replaced by Sigma checkers
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2022.6
Coverity Analysis checkers replaced by Sigma checkers
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2022.3
Coverity Analysis
Coverity Analysis checkers replaced by Sigma checkers
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2021.12
Coverity Analysis
Coverity Analysis checkers replaced by Sigma checkers
Checkers disabled in Sigma when running Coverity Analysis
Upgrade considerations for 2021.9
Coverity Analysis
Buildless capture
Sigma checkers introduced; legacy checkers retired
Sigma analysis engine platform requirements
Consequences and mitigation
Replaced Swift checkers
Removed Swift checkers
Replaced Java, JavaScript, and TypeScript checkers
Changes to Swift code analysis
Upgrade considerations for 2021.06
Coverity Analysis
Buildless capture
Upgrade considerations for 2021.03
Upgrade considerations for 2020.12
Upgrade considerations for 2020.09
Upgrade considerations for 2020.06
Upgrade considerations for 2020.03
Coverity Connect
Upgrade considerations for 2019.12
Coverity Analysis
Analyzing translation units in node_modules
Buildless capture
Crossworks MSP430 support change
Coverity Desktop
Updating the IBM RTC plugin
Upgrade considerations for 2019.09
Upgrade considerations for 2019.06
Upgrade considerations for 2019.03
Upgrade considerations for 2018.12
Coverity Analysis
Upgrade considerations for 2018.09
Deprecated notices
End-of-life (EOL) notices
Coverity Platform
Coverity Analysis
Coverity Desktop
Upgrade considerations for 2018.06
Deprecated notices
End-of-life (EOL) notices
Coverity Platform
Coverity Analysis
115851 FlexNet libraries and lgmrd v11.15.0+
Coverity Desktop
Coverity Connect Web Services API release and deprecation schedule
Coverity glossary
Legal notice
Black Duck statement on inclusivity and diversity

Preface
The static analysis solution
Working with static analysis
Customizing and extending static analysis
Use cases
Documentation for installation
Documentation set
Online resources

Back to home page