cvrf.h

Go to the documentation of this file.

#ifndef _CVRF_H_
#define _CVRF_H_

#include <stdbool.h>
#include "oscap.h"
#include "oscap_source.h"
#include "cvss_score.h"


/************************************************************************************************
 * @struct cvrf_product_status
 * Structure holding CVRF Status element (within a ProductStatuses container)
 * Contains a list of ProductIDs and their status with respect to the parent Vulnerability
 *
 * PARENT NODE: ProductStatuses container (which is child of Vulnerability)
 * REQUIRED: Type attribute [max. 1], ProductID(s) [min. 1, max. unbounded]
 */
struct cvrf_product_status;

struct cvrf_product_status *cvrf_product_status_new(void);

void cvrf_product_status_free(struct cvrf_product_status *status);

struct cvrf_product_status *cvrf_product_status_clone(const struct cvrf_product_status *stat);

struct oscap_string_iterator *cvrf_product_status_get_ids(struct cvrf_product_status *stat);


/************************************************************************************************
 * @struct cvrf_threat
 * Gives context about the type of Vulnerability and how much threat it poses
 * Contained within a list representing a Threats container in Vulnerability structure
 *
 * PARENT NODE: Threats container (which is child of Vulnerability)
 * REQUIRED: Type attribute [max 1], Description element [max. 1]
 * OPTIONAL: ProductID(s) [min. 0, max. unbounded], GroupID(s) [min. 0, max.unbounded]
 */
struct cvrf_threat;

struct cvrf_threat *cvrf_threat_new(void);

void cvrf_threat_free(struct cvrf_threat *threat);

struct cvrf_threat *cvrf_threat_clone(const struct cvrf_threat *threat);

const char *cvrf_threat_get_date(const struct cvrf_threat *threat);

const char *cvrf_threat_get_description(const struct cvrf_threat *threat);

struct oscap_string_iterator *cvrf_threat_get_product_ids(struct cvrf_threat *threat);

struct oscap_string_iterator *cvrf_threat_get_group_ids(struct cvrf_threat *threat);

bool cvrf_threat_set_date(struct cvrf_threat *threat, const char *date);

bool cvrf_threat_set_description(struct cvrf_threat *threat, const char *description);


/************************************************************************************************
 * @struct cvrf_remediation
 * Structure holding info for handling or fixing a particular Vulnerability
 *
 * PARENT NODE: Remediations container (which is child of Vulnerability)
 * REQUIRED: Type attribute [max: 1], Description element [max: 1]
 * OPTIONAL: ProductID(s) [min: 0, max: unbounded], GroupID(s) [min: 0, max: unbounded],
 *              Entitlement element [min: 0, max: 1], URL element [min: 0, max: 1]
 */
struct cvrf_remediation;

struct cvrf_remediation *cvrf_remediation_new(void);

void cvrf_remediation_free(struct cvrf_remediation *remed);

struct cvrf_remediation *cvrf_remediation_clone(const struct cvrf_remediation *remed);

const char *cvrf_remediation_get_date(const struct cvrf_remediation *remed);

const char *cvrf_remediation_get_description(const struct cvrf_remediation *remed);

const char *cvrf_remediation_get_url(const struct cvrf_remediation *remed);

const char *cvrf_remediation_get_entitlement(const struct cvrf_remediation *remed);

struct oscap_string_iterator *cvrf_remediation_get_product_ids(struct cvrf_remediation *remed);

struct oscap_string_iterator *cvrf_remediation_get_group_ids(struct cvrf_remediation *remed);

bool cvrf_remediation_set_date(struct cvrf_remediation *remed, const char *date);

bool cvrf_remediation_set_description(struct cvrf_remediation *remed, const char *description);

bool cvrf_remediation_set_url(struct cvrf_remediation *remed, const char *url);

bool cvrf_remediation_set_entitlement(struct cvrf_remediation *remed, const char *entitlement);


/************************************************************************************************
 * @struct cvrf_score_set
 * Contains CVSS metrics for a given Vulnerability. No ProductID indicates that it pertains to all
 * Products in a given CVRF file
 *
 * PARENT NODE: CVSSScoreSets container (which is child of Vulnerability)
 * REQUIRED: BaseScore element [max: 1]
 * OPTIONAL: TemporalScore element [min: 0, max:1], EnvironmentalScore element [min: 0, max: 1],
 *               ProductID(s) [min: 0, max: unbounded], Vector element [min: 0, max: 1]
 */
struct cvrf_score_set;

struct cvrf_score_set *cvrf_score_set_new(void);

void cvrf_score_set_free(struct cvrf_score_set *score_set);

struct cvrf_score_set *cvrf_score_set_clone(const struct cvrf_score_set *score_set);

const char *cvrf_score_set_get_vector(const struct cvrf_score_set *score_set);

struct oscap_string_iterator *cvrf_score_set_get_product_ids(struct cvrf_score_set *score_set);

struct cvss_impact *cvrf_score_set_get_impact(const struct cvrf_score_set *score_set);

char *cvrf_score_set_get_base_score(const struct cvrf_score_set *score_set);

char *cvrf_score_set_get_environmental_score(const struct cvrf_score_set *score_set);

char *cvrf_score_set_get_temporal_score(const struct cvrf_score_set *score_set);

bool cvrf_score_set_set_vector(struct cvrf_score_set *score_set, const char *vector);

bool cvrf_score_set_set_impact(struct cvrf_score_set *score_set, struct cvss_impact *impact);

bool cvrf_score_set_add_metric(struct cvrf_score_set *score_set, enum cvss_category category, const char *score);


/************************************************************************************************
 * @struct cvrf_involvement
 * Gives information about the Document Publisher's level of involvement
 * The 'Party' attribute gives the type of publisher (identical to DocumentPublisher Type)
 *
 * PARENT NODE: Involvements container
 * REQUIRED: Status attribute [max: 1], Party attribute [max: 1]
 * OPTIONAL: Description element [min: 0, max: 1]
 */
struct cvrf_involvement;

struct cvrf_involvement *cvrf_involvement_new(void);

void cvrf_involvement_free(struct cvrf_involvement *involve);

struct cvrf_involvement *cvrf_involvement_clone(const struct cvrf_involvement *involve);

const char *cvrf_involvement_get_description(const struct cvrf_involvement *involve);

bool cvrf_involvement_set_description(struct cvrf_involvement *involve, const char *description);

/************************************************************************************************
 * @struct cvrf_vulnerability_cwe
 *
 * PARENT NODE: Vulnerability
 * REQUIRED: ID attribute [max: 1], CWE string content [max: 1]
 */
struct cvrf_vulnerability_cwe;

struct cvrf_vulnerability_cwe *cvrf_vulnerability_cwe_new(void);

void cvrf_vulnerability_cwe_free(struct cvrf_vulnerability_cwe *cwe);

struct cvrf_vulnerability_cwe *cvrf_vulnerability_cwe_clone(const struct cvrf_vulnerability_cwe *cwe);

const char *cvrf_vulnerability_cwe_get_cwe(const struct cvrf_vulnerability_cwe *vuln_cwe);

const char *cvrf_vulnerability_cwe_get_id(const struct cvrf_vulnerability_cwe *vuln_cwe);


bool cvrf_vulnerability_cwe_set_cwe(struct cvrf_vulnerability_cwe *vuln_cwe, const char *cwe);

bool cvrf_vulnerability_cwe_set_id(struct cvrf_vulnerability_cwe *vuln_cwe, const char *id);

/************************************************************************************************
 * @struct cvrf_vulnerability
 * Provides information about Vulnerabilities for products and packages referenced in
 * ProductTree branches and relationships
 *
 * PARENT NODE: cvrfdoc
 * REQUIRED: Ordinal attribute [max: 1]
 * OPTIONAL: Title element [min: 0, max:1], ID element [min: 0, max: 1], DiscoveryDate element [min: 0, max: 1],
 *              ReleaseDate element [min: 0, max: 1], Description element [min: 0, max: 1], CVE element [min: 0, max: 1],
 *              CWE ID(s) [min: 0, max: unbounded]
 *
 * CONTAINERS: Notes, Involvements, ProductStatuses, Threats, CVSSScoreSets, Remediations,
 *              References, Acknowledgments [min: 0, max: 1 for all containers]
 */
struct cvrf_vulnerability;

struct cvrf_vulnerability *cvrf_vulnerability_new(void);

void cvrf_vulnerability_free(struct cvrf_vulnerability *vulnerability);

struct cvrf_vulnerability *cvrf_vulnerability_clone(const struct cvrf_vulnerability *vuln);

int cvrf_vulnerability_filter_by_product(struct cvrf_vulnerability *vuln, const char *prod);

int cvrf_vulnerability_get_ordinal(const struct cvrf_vulnerability *vuln);

const char *cvrf_vulnerability_get_title(const struct cvrf_vulnerability *vuln);

const char *cvrf_vulnerability_get_system_id(const struct cvrf_vulnerability *vuln);

const char *cvrf_vulnerability_get_system_name(const struct cvrf_vulnerability *vuln);

const char *cvrf_vulnerability_get_discovery_date(const struct cvrf_vulnerability *vuln);

const char *cvrf_vulnerability_get_release_date(const struct cvrf_vulnerability *vuln);

const char *cvrf_vulnerability_get_cve_id(const struct cvrf_vulnerability *vuln);

bool cvrf_vulnerability_set_ordinal(struct cvrf_vulnerability *vuln, int ordinal);

bool cvrf_vulnerability_set_title(struct cvrf_vulnerability *vuln, const char *vulnerability_title);

bool cvrf_vulnerability_set_system_id(struct cvrf_vulnerability *vuln, const char *id);

bool cvrf_vulnerability_set_system_name(struct cvrf_vulnerability *vuln, const char *sys_name);

bool cvrf_vulnerability_set_discovery_date(struct cvrf_vulnerability *vuln, const char *discovery_date);

bool cvrf_vulnerability_set_release_date(struct cvrf_vulnerability *vuln, const char *release_date);

bool cvrf_vulnerability_set_cve_id(struct cvrf_vulnerability *vuln, const char *cve_id);


/*-------------------------------------------------------------------------*\
|                               Iterators of child elements of Vulnerability                            |
\*-------------------------------------------------------------------------*/

struct oscap_iterator *cvrf_vulnerability_get_references(struct cvrf_vulnerability *vuln);

struct oscap_iterator *cvrf_vulnerability_get_acknowledgments(struct cvrf_vulnerability *vuln);

struct oscap_iterator *cvrf_vulnerability_get_notes(struct cvrf_vulnerability *vuln);

/*******************************************
 * @struct cvrf_vulnerability_cwe_iterator
 * Iterator representing all CWE elements in the Vulnerability
 * Contained as a list within the CVRF Vulnerability structure
 */
struct cvrf_vulnerability_cwe_iterator;

bool cvrf_vulnerability_add_vulnerability_cwe(struct cvrf_vulnerability *vuln, struct cvrf_vulnerability_cwe *vulnerability_cwe);

struct cvrf_vulnerability_cwe_iterator *cvrf_vulnerability_get_vulnerability_cwes(const struct cvrf_vulnerability *vuln);

struct cvrf_vulnerability_cwe *cvrf_vulnerability_cwe_iterator_next(struct cvrf_vulnerability_cwe_iterator *it);

bool cvrf_vulnerability_cwe_iterator_has_more(struct cvrf_vulnerability_cwe_iterator *it);

void cvrf_vulnerability_cwe_iterator_free(struct cvrf_vulnerability_cwe_iterator *it);

void cvrf_vulnerability_cwe_iterator_reset(struct cvrf_vulnerability_cwe_iterator *it);

void cvrf_vulnerability_cwe_iterator_remove(struct cvrf_vulnerability_cwe_iterator *it);

/*******************************************
 * @struct cvrf_involvement_iterator
 * Iterator representing all Involvement elements in the Involvements container
 * Contained as a list within the CVRF Vulnerability structure
 */
struct cvrf_involvement_iterator;

bool cvrf_vulnerability_add_involvement(struct cvrf_vulnerability *vuln, struct cvrf_involvement *involvement);

struct cvrf_involvement_iterator *cvrf_vulnerability_get_involvements(const struct cvrf_vulnerability *vuln);

struct cvrf_involvement *cvrf_involvement_iterator_next(struct cvrf_involvement_iterator *it);

bool cvrf_involvement_iterator_has_more(struct cvrf_involvement_iterator *it);

void cvrf_involvement_iterator_free(struct cvrf_involvement_iterator *it);

void cvrf_involvement_iterator_reset(struct cvrf_involvement_iterator *it);

void cvrf_involvement_iterator_remove(struct cvrf_involvement_iterator *it);

/*******************************************
 * @struct cvrf_score_set_iterator
 * Iterator representing all ScoreSet elements in the CVSSScoreSets container
 * Contained as a list within the CVRF Vulnerability structure
 */
struct cvrf_score_set_iterator;

bool cvrf_vulnerability_add_score_set(struct cvrf_vulnerability *vuln, struct cvrf_score_set *score_set);

struct cvrf_score_set_iterator *cvrf_vulnerability_get_score_sets(const struct cvrf_vulnerability *vuln);

struct cvrf_score_set *cvrf_score_set_iterator_next(struct cvrf_score_set_iterator *it);

bool cvrf_score_set_iterator_has_more(struct cvrf_score_set_iterator *it);

void cvrf_score_set_iterator_free(struct cvrf_score_set_iterator *it);

void cvrf_score_set_iterator_reset(struct cvrf_score_set_iterator *it);

void cvrf_score_set_iterator_remove(struct cvrf_score_set_iterator *it);

/*******************************************
 * @struct cvrf_product_status_iterator
 * Iterator representing all Status elements in the ProductStatuses container
 * Contained as a list within the CVRF Vulnerability structure
 */
struct cvrf_product_status_iterator;

bool cvrf_vulnerability_add_cvrf_product_status(struct cvrf_vulnerability *vuln, struct cvrf_product_status *stat);

struct cvrf_product_status_iterator *cvrf_vulnerability_get_product_statuses(const struct cvrf_vulnerability *vuln);

struct cvrf_product_status *cvrf_product_status_iterator_next(struct cvrf_product_status_iterator *it);

bool cvrf_product_status_iterator_has_more(struct cvrf_product_status_iterator *it);

void cvrf_product_status_iterator_free(struct cvrf_product_status_iterator *it);

void cvrf_product_status_iterator_reset(struct cvrf_product_status_iterator *it);

void cvrf_product_status_iterator_remove(struct cvrf_product_status_iterator *it);

/*******************************************
 * @struct cvrf_remediation_iterator
 * Iterator representing all Remediation elements in the Remediations container
 * Contained as a list within the CVRF Vulnerability structure
 */
struct cvrf_remediation_iterator;

bool cvrf_vulnerability_add_remediation(struct cvrf_vulnerability *vuln, struct cvrf_remediation *remed);

struct cvrf_remediation_iterator *cvrf_vulnerability_get_remediations(const struct cvrf_vulnerability *vuln);

struct cvrf_remediation *cvrf_remediation_iterator_next(struct cvrf_remediation_iterator *it);

bool cvrf_remediation_iterator_has_more(struct cvrf_remediation_iterator *it);

void cvrf_remediation_iterator_free(struct cvrf_remediation_iterator *it);

void cvrf_remediation_iterator_reset(struct cvrf_remediation_iterator *it);

void cvrf_remediation_iterator_remove(struct cvrf_remediation_iterator *it);

/*******************************************
 * @struct cvrf_threat_iterator
 * Iterator representing all Threat elements in the Threats container
 * Contained as a list within the CVRF Vulnerability structure
 */
struct cvrf_threat_iterator;

bool cvrf_vulnerability_add_threat(struct cvrf_vulnerability *vuln, struct cvrf_threat *threat);

struct cvrf_threat_iterator *cvrf_vulnerability_get_threats(const struct cvrf_vulnerability *vuln);

struct cvrf_threat *cvrf_threat_iterator_next(struct cvrf_threat_iterator *it);

bool cvrf_threat_iterator_has_more(struct cvrf_threat_iterator *it);

void cvrf_threat_iterator_free(struct cvrf_threat_iterator *it);

void cvrf_threat_iterator_reset(struct cvrf_threat_iterator *it);

void cvrf_threat_iterator_remove(struct cvrf_threat_iterator *it);

/************************************************************************************************
 * @struct cvrf_product_name
 * Represents FullProductName element, which is a child of both Branch and Relationship elements
 * Links a CPE to its ProductID or a package ProductID. No two FullProductName elements can
 * have the same ProductID
 *
 * PARENT NODE: ProductTree, Branch, or Relationship
 * REQUIRED: ProductID attribute [max: 1], CPE element [max: 1]
 */
struct cvrf_product_name;

struct cvrf_product_name *cvrf_product_name_new(void);

void cvrf_product_name_free(struct cvrf_product_name *full_name);

struct cvrf_product_name *cvrf_product_name_clone(const struct cvrf_product_name *full_name);

const char *cvrf_product_name_get_product_id(const struct cvrf_product_name *full_name);

const char *cvrf_product_name_get_cpe(const struct cvrf_product_name *full_name);

bool cvrf_product_name_set_product_id(struct cvrf_product_name *full_name, const char *product_id);

bool cvrf_product_name_set_cpe(struct cvrf_product_name *full_name, const char *cpe);

/************************************************************************************************
 * @struct cvrf_group
 * Structure that categorically groups different products referenced in the document.
 * One ProductID is used per group member. The GroupID can be used as a reference for
 * other elements.
 *
 * PARENT NODE: ProductGroups container (which is a child of ProductTree)
 * REQUIRED: GroupID attribute [max: 1], ProductID element [min:2, max: unbounded]
 * OPTIONAL: Description element [min: 0, max: 1]
 */
struct cvrf_group;

struct cvrf_group *cvrf_group_new(void);

void cvrf_group_free(struct cvrf_group *group);

struct cvrf_group *cvrf_group_clone(const struct cvrf_group *group);

const char *cvrf_group_get_group_id(const struct cvrf_group *group);

const char *cvrf_group_get_description(const struct cvrf_group *group);

bool cvrf_group_set_group_id(struct cvrf_group *group, const char *group_id);

bool cvrf_group_set_description(struct cvrf_group *group, const char *description);

struct oscap_string_iterator *cvrf_group_get_product_ids(struct cvrf_group *group);


/************************************************************************************************
 * @struct cvrf_relationship
 * Structure within a parent ProductTree. Establishes a link between two products (FullProductNames)
 * referenced in the document. Thus, at least two FullProductName elements must exist in the document.
 *
 * PARENT NODE: ProductTree
 * REQUIRED: ProductReference attribute [max: 1], RelationType attribute [max: 1],
 *              RelatesToProductReference attribute [max: 1], FullProductName element [max: 1]
 */
struct cvrf_relationship;

struct cvrf_relationship *cvrf_relationship_new(void);

void cvrf_relationship_free(struct cvrf_relationship *relationship);

struct cvrf_relationship *cvrf_relationship_clone(const struct cvrf_relationship *relation);

const char *cvrf_relationship_get_product_reference(const struct cvrf_relationship *relation);

const char *cvrf_relationship_get_relates_to_ref(const struct cvrf_relationship *relation);

struct cvrf_product_name *cvrf_relationship_get_product_name(const struct cvrf_relationship *relation);

bool cvrf_relationship_set_product_reference(struct cvrf_relationship *relation, const char *product_reference);

bool cvrf_relationship_set_relates_to_ref(struct cvrf_relationship *relation, const char *relates_to_ref);

bool cvrf_relationship_set_product_name(struct cvrf_relationship *relation, struct cvrf_product_name *name);

/************************************************************************************************
 * @struct cvrf_branch
 * Establishes hierarchy and relationships between different CPEs, products, and packages
 * Can only have one type of child element: a FullProductName or more Branches
 *
 * PARENT NODE: ProductTree or Branch
 * REQUIRED: Name attribute [max: 1], Type attribute [max: 1], EITHER FullProductName element [max: 1] OR
 *              child Branch elements [min: 1, max: unbounded]
 */
struct cvrf_branch;

struct cvrf_branch *cvrf_branch_new(void);

void cvrf_branch_free(struct cvrf_branch *branch);

struct cvrf_branch *cvrf_branch_clone(const struct cvrf_branch *branch);

const char *cvrf_branch_get_branch_name(const struct cvrf_branch *branch);

struct cvrf_product_name *cvrf_branch_get_product_name(const struct cvrf_branch *branch);

struct oscap_iterator *cvrf_branch_get_subbranches(struct cvrf_branch *branch);

bool cvrf_branch_set_branch_name(struct cvrf_branch *branch, const char *branch_name);

bool cvrf_branch_set_product_name(struct cvrf_branch *branch, struct cvrf_product_name *name);

/************************************************************************************************
 *@struct cvrf_product_tree
 * Relates information about CPEs, their given ProductIDs, packages and their given ProductIDs through
 * Branch and Relationship child elements
 *
 * PARENT NODE: cvrfdoc
 * OPTIONAL: FullProductName element [min: 0, max: unbounded], Branch element [min: 0, max: unbounded],
 *              Relationship element [min: 0, max: unbounded]
 */
struct cvrf_product_tree;

struct cvrf_product_tree *cvrf_product_tree_new(void);

void cvrf_product_tree_free(struct cvrf_product_tree *tree);

struct cvrf_product_tree *cvrf_product_tree_clone(const struct cvrf_product_tree *tree);

const char *get_cvrf_product_id_from_cpe(struct cvrf_product_tree *tree, const char *cpe);

int cvrf_product_tree_filter_by_cpe(struct cvrf_product_tree *tree, const char *cpe);

/*---------------------------------------------------------------------*\
|                               Iterators of child elements of ProductTree                              |
\*---------------------------------------------------------------------*/

struct oscap_iterator *cvrf_product_tree_get_branches(struct cvrf_product_tree *tree);

/*******************************************
 * @struct cvrf_product_name_iterator
 * Iterator representing all FullProductName elements in the ProductTree
 * Contained as a list within the CVRF ProductTree structure
 */
struct cvrf_product_name_iterator;

bool cvrf_product_tree_add_product_name(struct cvrf_product_tree *tree, struct cvrf_product_name *full_name);

struct cvrf_product_name_iterator *cvrf_product_tree_get_product_names(const struct cvrf_product_tree *tree);

struct cvrf_product_name *cvrf_product_name_iterator_next(struct cvrf_product_name_iterator *it);

bool cvrf_product_name_iterator_has_more(struct cvrf_product_name_iterator *it);

void cvrf_product_name_iterator_free(struct cvrf_product_name_iterator *it);

void cvrf_product_name_iterator_reset(struct cvrf_product_name_iterator *it);

void cvrf_product_name_iterator_remove(struct cvrf_product_name_iterator *it);

/*******************************************
 * @struct cvrf_relationship_iterator
 * Iterator representing all Relationship elements in the ProductTree
 * Contained as a list within the CVRF Relationship structure
 */
struct cvrf_relationship_iterator;

bool cvrf_product_tree_add_relationship(struct cvrf_product_tree *tree, struct cvrf_relationship *relation);

struct cvrf_relationship_iterator *cvrf_product_tree_get_relationships(const struct cvrf_product_tree *tree);

struct cvrf_relationship *cvrf_relationship_iterator_next(struct cvrf_relationship_iterator *it);

bool cvrf_relationship_iterator_has_more(struct cvrf_relationship_iterator *it);

void cvrf_relationship_iterator_free(struct cvrf_relationship_iterator *it);

void cvrf_relationship_iterator_reset(struct cvrf_relationship_iterator *it);

void cvrf_relationship_iterator_remove(struct cvrf_relationship_iterator *it);


/*******************************************
 * @struct cvrf_group_iterator
 * Iterator representing all Group elements in the ProductTree
 * Contained as a list within the CVRF ProductTree structure
 */
struct cvrf_group_iterator;

bool cvrf_product_tree_add_group(struct cvrf_product_tree *tree, struct cvrf_group *group);

struct cvrf_group_iterator *cvrf_product_tree_get_product_groups(const struct cvrf_product_tree *tree);

struct cvrf_group *cvrf_group_iterator_next(struct cvrf_group_iterator *it);

bool cvrf_group_iterator_has_more(struct cvrf_group_iterator *it);

void cvrf_group_iterator_free(struct cvrf_group_iterator *it);

void cvrf_group_iterator_reset(struct cvrf_group_iterator *it);

void cvrf_group_iterator_remove(struct cvrf_group_iterator *it);


/************************************************************************************************
 * @struct cvrf_acknowledgment
 * Metadata giving recognition of external parties who provided information, suggestions, or
 * other contributions
 *
 * PARENT NODE: Acknowledgments container (in cvrfdoc or in Vulnerability)
 * OPTIONAL: Name element(s) [min: 0, max: unbounded], Organization(s) element [min: 0, max: unbounded],
 *              Description element [min: 0, max: 1], URL element(s) [min: 0, max: unbounded]
 */
struct cvrf_acknowledgment;

struct cvrf_acknowledgment *cvrf_acknowledgment_new(void);

void cvrf_acknowledgment_free(struct cvrf_acknowledgment *ack);

struct cvrf_acknowledgment *cvrf_acknowledgment_clone(const struct cvrf_acknowledgment *ack);

const char *cvrf_acknowledgment_get_description(const struct cvrf_acknowledgment *ack);

bool cvrf_acknowledgment_set_description(struct cvrf_acknowledgment *ack, const char *description);

struct oscap_string_iterator *cvrf_acknowledgment_get_names(const struct cvrf_acknowledgment *ack);

struct oscap_string_iterator *cvrf_acknowledgment_get_organizations(const struct cvrf_acknowledgment *ack);

struct oscap_string_iterator *cvrf_acknowledgment_get_urls(const struct cvrf_acknowledgment *ack);

/************************************************************************************************
 * @struct cvrf_note
 *
 * PARENT NODE: DocumentNotes container or Notes container
 * REQUIRED: Type attribute [min: 1, max: 1], Ordinal attribute [min: 1, max: 1],
 * OPTIONAL: Audience attribute [min: 0, max: 1], Title attribute [min: 0, max: 1]
 */
struct cvrf_note;

struct cvrf_note *cvrf_note_new(void);

void cvrf_note_free(struct cvrf_note *note);

struct cvrf_note *cvrf_note_clone(const struct cvrf_note *note);

int cvrf_note_get_ordinal(const struct cvrf_note *note);

const char *cvrf_note_get_audience(const struct cvrf_note *note);

const char *cvrf_note_get_title(const struct cvrf_note *note);

const char *cvrf_note_get_contents(const struct cvrf_note *note);

bool cvrf_note_set_ordinal(struct cvrf_note *note, int ordinal);

bool cvrf_note_set_audience(struct cvrf_note *note, const char *audience);

bool cvrf_note_set_title(struct cvrf_note *note, const char *title);

bool cvrf_note_set_contents(struct cvrf_note *note, const char *contents);


/************************************************************************************************
 * @struct cvrf_revision
 * Metadata for tracking the changes made to a CVRF document
 *
 * PARENT NODE: RevisionHistory container (which is a child of DocumentTracking)
 * REQUIRED: Number element [min: 1, max: 1], Date element [min: 1, max: 1],
 *              Description element [min: 1, max: 1]
 */
struct cvrf_revision;

struct cvrf_revision *cvrf_revision_new(void);

void cvrf_revision_free(struct cvrf_revision *revision);

struct cvrf_revision *cvrf_revision_clone(const struct cvrf_revision *revision);

const char *cvrf_revision_get_number(const struct cvrf_revision *revision);

const char *cvrf_revision_get_date(const struct cvrf_revision *revision);

const char *cvrf_revision_get_description(const struct cvrf_revision *revision);

bool cvrf_revision_set_number(struct cvrf_revision *revision, const char *number);

bool cvrf_revision_set_date(struct cvrf_revision *revision, const char *date);

bool cvrf_revision_set_description(struct cvrf_revision *revision, const char *description);

/************************************************************************************************
 * @struct cvrf_doc_tracking
 * Metadata for referencing origin, changes, release dates, IDs, and other information about
 * the document
 *
 * PARENT NODE: cvrfdoc
 * REQUIRED: Identification container [max: 1] { ID element [max: 1], Alias [min: 0, max: unbounded] },
 *              Status element [max: 1], Version element [max: 1], RevisionHistory container [max: 1],
 *              InitialReleaseDate [max: 1], CurrentReleaseDate [max: 1],
 *              Generator container [max: 1] { Engine [min: 0, max: 1], Date [min: 0, max: 1] }
 */
struct cvrf_doc_tracking;

struct cvrf_doc_tracking *cvrf_doc_tracking_new(void);

void cvrf_doc_tracking_free(struct cvrf_doc_tracking *tracking);

struct cvrf_doc_tracking *cvrf_doc_tracking_clone(const struct cvrf_doc_tracking *tracking);

const char *cvrf_doc_tracking_get_tracking_id(const struct cvrf_doc_tracking *tracking);

struct oscap_string_iterator *cvrf_doc_tracking_get_aliases(struct cvrf_doc_tracking *tracking);

const char *cvrf_doc_tracking_get_version(const struct cvrf_doc_tracking *tracking);

const char *cvrf_doc_tracking_get_init_release_date(const struct cvrf_doc_tracking *tracking);

const char *cvrf_doc_tracking_get_cur_release_date(const struct cvrf_doc_tracking *tracking);

const char *cvrf_doc_tracking_get_generator_engine(const struct cvrf_doc_tracking *tracking);

const char *cvrf_doc_tracking_get_generator_date(const struct cvrf_doc_tracking *tracking);

bool cvrf_doc_tracking_set_tracking_id(struct cvrf_doc_tracking *tracking, const char *id);

bool cvrf_doc_tracking_set_version(struct cvrf_doc_tracking *tracking, const char *version);

bool cvrf_doc_tracking_set_init_release_date(struct cvrf_doc_tracking *tracking, const char *init_release_date);

bool cvrf_doc_tracking_set_cur_release_date(struct cvrf_doc_tracking *tracking, const char *cur_release_date);

bool cvrf_doc_tracking_set_generator_engine(struct cvrf_doc_tracking *tracking, const char *generator_engine);

bool cvrf_doc_tracking_set_generator_date(struct cvrf_doc_tracking *tracking, const char *generator_date);


/*******************************************
 * @struct cvrf_revision_iterator
 * Iterator representing all Revision elements in the RevisionHistory container
 * Contained as a list within the CVRF DocumentTracking structure
 */
struct cvrf_revision_iterator;

bool cvrf_doc_tracking_add_revision(struct cvrf_doc_tracking *tracking, struct cvrf_revision *revision);

struct cvrf_revision_iterator *cvrf_doc_tracking_get_revision_history(const struct cvrf_doc_tracking *tracking);

struct cvrf_revision *cvrf_revision_iterator_next(struct cvrf_revision_iterator *it);

bool cvrf_revision_iterator_has_more(struct cvrf_revision_iterator *it);

void cvrf_revision_iterator_free(struct cvrf_revision_iterator *it);

void cvrf_revision_iterator_reset(struct cvrf_revision_iterator *it);

void cvrf_revision_iterator_remove(struct cvrf_revision_iterator *it);


/************************************************************************************************
 * @struct cvrf_doc_publisher
 * Metadata about the publisher of the CVRF document
 *
 * PARENT NODE: cvrfdoc
 * REQUIRED: Type attribute [max: 1]
 * OPTIONAL: VendorID attribute [min: 0, max: 1], ContactDetails element [min: 0, max: 1],
 *              IssuingAuthority element [min: 0, max: 1]
 */
struct cvrf_doc_publisher;

struct cvrf_doc_publisher *cvrf_doc_publisher_new(void);

void cvrf_doc_publisher_free(struct cvrf_doc_publisher *publisher);

struct cvrf_doc_publisher *cvrf_doc_publisher_clone(const struct cvrf_doc_publisher *publisher);

const char *cvrf_doc_publisher_get_vendor_id(const struct cvrf_doc_publisher *publisher);

const char *cvrf_doc_publisher_get_contact_details(const struct cvrf_doc_publisher *publisher);

const char *cvrf_doc_publisher_get_issuing_authority(const struct cvrf_doc_publisher *publisher);

bool cvrf_doc_publisher_set_vendor_id(struct cvrf_doc_publisher *publisher, const char *vendor_id);

bool cvrf_doc_publisher_set_contact_details(struct cvrf_doc_publisher *publisher, const char *contact_details);

bool cvrf_doc_publisher_set_issuing_authority(struct cvrf_doc_publisher *publisher, const char *issuing_authority);

/************************************************************************************************
 * @struct cvrf_reference
 * Refers to resources and information outside of the CVRF document itself
 *
 * PARENT NODE: DocumentReferences container (child of cvrfdoc) or References container (child of Vulnerability)
 * REQUIRED: Type attribute [max: 1], URL element [max: 1], Description element [max: 1]
 */
struct cvrf_reference;

struct cvrf_reference *cvrf_reference_new(void);

void cvrf_reference_free(struct cvrf_reference *reference);

struct cvrf_reference *cvrf_reference_clone(const struct cvrf_reference *ref);

const char *cvrf_reference_get_url(const struct cvrf_reference *reference);

const char *cvrf_reference_get_description(const struct cvrf_reference *reference);

bool cvrf_reference_set_url(struct cvrf_reference *reference, const char *url);

bool cvrf_reference_set_description(struct cvrf_reference *reference, const char *description);

/************************************************************************************************
 * @struct cvrf_document
 *
 */
struct cvrf_document;

struct cvrf_document *cvrf_document_new(void);

void cvrf_document_free(struct cvrf_document *doc);

struct cvrf_document *cvrf_document_clone(const struct cvrf_document *doc);

const char *cvrf_document_get_doc_distribution(const struct cvrf_document *doc);

const char *cvrf_document_get_aggregate_severity(const struct cvrf_document *doc);

const char *cvrf_document_get_namespace(const struct cvrf_document *doc);

struct cvrf_doc_tracking *cvrf_document_get_tracking(const struct cvrf_document *doc);

struct cvrf_doc_publisher *cvrf_document_get_publisher(const struct cvrf_document *doc);

struct oscap_iterator *cvrf_document_get_notes(struct cvrf_document *doc);

struct oscap_iterator *cvrf_document_get_references(struct cvrf_document *doc);

struct oscap_iterator *cvrf_document_get_acknowledgments(struct cvrf_document *doc);

bool cvrf_document_set_doc_distribution(struct cvrf_document *doc, const char *distribution);

bool cvrf_document_set_aggregate_severity(struct cvrf_document *doc, const char *severity);

bool cvrf_document_set_namespace(struct cvrf_document *doc, const char *ns);

bool cvrf_document_set_publisher(struct cvrf_document *doc, struct cvrf_doc_publisher *publisher);

bool cvrf_document_set_tracking(struct cvrf_document *doc, struct cvrf_doc_tracking *track);

/************************************************************************************************
 * @struct cvrf_model
 * Top level structure; organizationally divided into 3 components: Document, ProductTree, and
 * Vulnerability offshoots. This structure contains all information provided by a CVRF file.
 *
 * REQUIRED: DocumentTitle element [max: 1], DocumentType element [max: 1]
 * OPTIONAL: ProductTree element [min: 0, max: 1], Vulnerability [min: 0, max: unbounded]
 */
struct cvrf_model;

struct cvrf_model *cvrf_model_new(void);

void cvrf_model_free(struct cvrf_model *cvrf);

struct cvrf_model *cvrf_model_clone(const struct cvrf_model *model);

int cvrf_model_filter_by_cpe(struct cvrf_model *model, const char *cpe);

const char *cvrf_model_get_doc_title(const struct cvrf_model *model);

const char *cvrf_model_get_doc_type(const struct cvrf_model *model);

bool cvrf_model_set_doc_title(struct cvrf_model *model, const char *doc_title);

bool cvrf_model_set_doc_type(struct cvrf_model *model, const char *doc_type);

struct cvrf_product_tree *cvrf_model_get_product_tree(struct cvrf_model *model);

struct cvrf_document *cvrf_model_get_document(const struct cvrf_model *model);

const char *cvrf_model_get_identification(struct cvrf_model *model);

bool cvrf_model_set_document(struct cvrf_model *model, struct cvrf_document *doc);

/*******************************************
 * @struct cvrf_vulnerability_iterator
 * Iterator representing all Vulnerabilities in the document
 * Contained as a list within the CVRF Model structure
 */
struct cvrf_vulnerability_iterator;

struct cvrf_vulnerability_iterator *cvrf_model_get_vulnerabilities(const struct cvrf_model *model);

bool cvrf_model_add_vulnerability(struct cvrf_model *model, struct cvrf_vulnerability *vuln);

struct cvrf_vulnerability *cvrf_vulnerability_iterator_next(struct cvrf_vulnerability_iterator *it);

bool cvrf_vulnerability_iterator_has_more(struct cvrf_vulnerability_iterator *it);

void cvrf_vulnerability_iterator_free(struct cvrf_vulnerability_iterator *it);

void cvrf_vulnerability_iterator_reset(struct cvrf_vulnerability_iterator *it);

void cvrf_vulnerability_iterator_remove(struct cvrf_vulnerability_iterator *it);


/************************************************************************************************
 * @struct cvrf_index
 * Represents an index of a CVRF feed or directory
 * Maintains a list of all CVRF files in the form of cvrf_model structures
 */
struct cvrf_index;

struct cvrf_index *cvrf_index_new(void);

void cvrf_index_free(struct cvrf_index *index);

struct cvrf_index *cvrf_index_clone(const struct cvrf_index *index);

const char *cvrf_index_get_source_url(const struct cvrf_index *index);

const char *cvrf_index_get_index_file(const struct cvrf_index *index);

bool cvrf_index_set_source_url(struct cvrf_index *index, const char *url);

bool cvrf_index_set_index_file(struct cvrf_index *index, const char *index_file);

/*******************************************
 * @struct cvrf_model_iterator
 * Iterator representing all CVRF files from an index, feed, or stream
 * Contained as a list within the CVRF Index structure
 */
struct cvrf_model_iterator;

bool cvrf_index_add_model(struct cvrf_index *index, struct cvrf_model *model);

struct cvrf_model_iterator *cvrf_index_get_models(const struct cvrf_index *index);

struct cvrf_model *cvrf_model_iterator_next(struct cvrf_model_iterator *it);

bool cvrf_model_iterator_has_more(struct cvrf_model_iterator *it);

void cvrf_model_iterator_free(struct cvrf_model_iterator *it);

void cvrf_model_iterator_reset(struct cvrf_model_iterator *it);

void cvrf_model_iterator_remove(struct cvrf_model_iterator *it);


/************************************************************************************************
 * @struct cvrf_session
 * Structure that holds and processes import source and import for CVRF models or indices
 * for later use during evaluation. Has OVAL definition structure that is used for
 * evaluation
 */
struct cvrf_session;

struct cvrf_session *cvrf_session_new_from_source_model(struct oscap_source *source);

struct cvrf_session *cvrf_session_new_from_source_index(struct oscap_source *source);

void cvrf_session_free(struct cvrf_session *session);

struct cvrf_model *cvrf_session_get_model(struct cvrf_session *session);

struct cvrf_index *cvrf_session_get_index(const struct cvrf_session *session);

struct oscap_string_iterator *cvrf_session_get_product_ids(struct cvrf_session *session);

const char *cvrf_session_get_os_name(const struct cvrf_session *session);

void cvrf_session_set_model(struct cvrf_session *session, struct cvrf_model *model);

bool cvrf_session_set_index(struct cvrf_session *session, struct cvrf_index *index);

bool cvrf_session_set_os_name(struct cvrf_session *session, const char *os_name);

/************************************************************************************************
 * @struct cvrf_rpm_attributes
 * Stores dissected information about RPM package names from CVRF files- the EVR format and
 * package name. These are used to check the vulnerability of the system by comparing the
 * EVR in the CVRF file to the EVR on the system
 */
struct cvrf_rpm_attributes;

struct cvrf_rpm_attributes *cvrf_rpm_attributes_new(void);

void cvrf_rpm_attributes_free(struct cvrf_rpm_attributes *attributes);

const char *cvrf_rpm_attributes_get_full_package_name(const struct cvrf_rpm_attributes *attributes);

const char *cvrf_rpm_attributes_get_rpm_name(const struct cvrf_rpm_attributes *attributes);

const char *cvrf_rpm_attributes_get_evr_format(const struct cvrf_rpm_attributes *attributes);

bool cvrf_rpm_attributes_set_full_package_name(struct cvrf_rpm_attributes *attributes, const char *full_package);

bool cvrf_rpm_attributes_set_rpm_name(struct cvrf_rpm_attributes *attributes, const char *rpm_name);

bool cvrf_rpm_attributes_set_evr_format(struct cvrf_rpm_attributes *attributes, const char *evr_format);


/************************************************************************************************/
/************************************************************************************************/


const char * cvrf_model_supported(void);

struct cvrf_index *cvrf_index_import(struct oscap_source *index_source);

struct cvrf_model *cvrf_model_import(struct oscap_source *source);

struct oscap_source *cvrf_index_get_export_source(struct cvrf_index *index);

struct oscap_source *cvrf_model_get_export_source(struct cvrf_model *model);

struct oscap_source *cvrf_model_get_results_source(struct oscap_source *import_source, const char *os_name);

struct oscap_source *cvrf_index_get_results_source(struct oscap_source *import_source, const char *os_name);


#endif                          /* _CVRF_H_ */