sqc 0.4.13

Software Code Quality - CERT C compliance checker
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! CON41-C: Wrap functions that can fail spuriously in a loop
//!
//! Atomic compare-exchange weak functions can fail spuriously and must be wrapped
//! in a loop to handle these failures correctly.
//!
//! ## Affected Functions:
//! - `atomic_compare_exchange_weak()`
//! - `atomic_compare_exchange_weak_explicit()`
//!
//! ## Rationale:
//! Per C Standard 7.17.7.4 paragraph 5 [ISO/IEC 9899:2024]:
//! - A weak compare-and-exchange operation may fail spuriously
//! - This makes them faster on some platforms (Alpha, ARM, MIPS, PowerPC)
//! - These architectures implement compare-and-exchange using load-linked/store-conditional
//! - To recover from spurious failures, a loop must be used
//!
//! ## Examples:
//!
//! **Non-compliant (no loop):**
//! ```c
//! _Bool flag = 0;
//! if (atomic_compare_exchange_weak(&flag, &expected, 1)) {
//!     // May fail spuriously!
//! }
//! ```
//!
//! **Compliant (in loop):**
//! ```c
//! _Bool flag = 0;
//! while (!atomic_compare_exchange_weak(&flag, &expected, 1)) {
//!     // Retry on spurious failure
//! }
//! ```
//!
//! ## Detection Strategy:
//! - Find calls to atomic_compare_exchange_weak() and atomic_compare_exchange_weak_explicit()
//! - Check if they are within a loop (while, for, do-while)
//! - Flag violations if not in a loop

use super::super::{CertRule, RuleViolation};
use crate::manifest::{RuleCategory, Severity};
use crate::utility::cert_c::ast_utils::get_node_text;
use tree_sitter::Node;

pub struct Con41C;

impl CertRule for Con41C {
    fn rule_id(&self) -> &'static str {
        "CON41-C"
    }

    fn description(&self) -> &'static str {
        "Wrap functions that can fail spuriously in a loop"
    }

    fn severity(&self) -> Severity {
        Severity::Medium
    }

    fn category(&self) -> RuleCategory {
        RuleCategory::Rule
    }

    fn cert_id(&self) -> &'static str {
        "CON41-C"
    }

    fn check(&self, node: &Node, source: &str) -> Vec<RuleViolation> {
        let mut violations = Vec::new();
        self.check_node(node, source, &mut violations);
        violations
    }
}

impl Con41C {
    fn check_node(&self, node: &Node, source: &str, violations: &mut Vec<RuleViolation>) {
        // Look for call expressions
        if node.kind() == "call_expression" {
            if let Some(func) = node.child_by_field_name("function") {
                let func_name = get_node_text(&func, source);

                // Check if this is an atomic compare-exchange weak function
                if matches!(
                    func_name,
                    "atomic_compare_exchange_weak" | "atomic_compare_exchange_weak_explicit"
                ) {
                    // Check if the call is within a loop
                    if !self.is_in_loop(node) {
                        let line = node.start_position().row + 1;
                        violations.push(RuleViolation {
                            rule_id: self.rule_id().to_string(),
                            severity: Severity::Medium,
                            message: format!(
                                "Function '{}' can fail spuriously and must be wrapped in a loop (C11 7.17.7.4)",
                                func_name
                            ),
                            file_path: String::new(),
                            line,
                            column: 0,
                            suggestion: Some(
                                format!("Wrap {} in a while/for/do-while loop to handle spurious failures", func_name)
                            ),
                            ..Default::default()
                        });
                    }
                }
            }
        }

        // Recursively check children
        for i in 0..node.child_count() {
            if let Some(child) = node.child(i) {
                self.check_node(&child, source, violations);
            }
        }
    }

    /// Check if a node is within a loop structure
    fn is_in_loop(&self, node: &Node) -> bool {
        let mut current = node.parent();

        while let Some(parent) = current {
            match parent.kind() {
                "while_statement" | "for_statement" | "do_statement" => {
                    return true;
                }
                "function_definition" => {
                    // Stop at function boundary
                    return false;
                }
                _ => {
                    current = parent.parent();
                }
            }
        }

        false
    }
}