sqc 0.4.84

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
140

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

pub struct Fio44C;

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

    fn description(&self) -> &'static str {
        "Only use values for fsetpos() that are returned from fgetpos()"
    }

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

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

    fn cert_id(&self) -> &'static str {
        self.rule_id()
    }

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

        // Track fpos_t variables and whether they were initialized by fgetpos
        let mut fpos_vars = std::collections::HashMap::new();
        self.track_fpos_vars(root, source, &mut fpos_vars);

        // Check fsetpos calls
        self.check_fsetpos_calls(root, source, &fpos_vars, &mut violations);

        violations
    }
}

impl Fio44C {
    fn track_fpos_vars(
        &self,
        node: &Node,
        source: &str,
        fpos_vars: &mut std::collections::HashMap<String, bool>,
    ) {
        for n in query::find_descendants(*node, |_| true) {
            // Look for fpos_t declarations
            if n.kind() == "declaration" {
                let decl_text = get_node_text(&n, source);
                if decl_text.contains("fpos_t") {
                    // Extract variable name (simple heuristic)
                    if let Some(declarator) = n.child_by_field_name("declarator") {
                        if let Some(ident) = self.get_identifier(&declarator, source) {
                            fpos_vars.insert(ident.to_string(), false);
                        }
                    }
                }
            }

            // Look for fgetpos calls
            if n.kind() == "call_expression" {
                if let Some(func_node) = n.child_by_field_name("function") {
                    if get_node_text(&func_node, source) == "fgetpos" {
                        // Mark the fpos_t variable as initialized by fgetpos
                        if let Some(args) = n.child_by_field_name("arguments") {
                            if let Some(second_arg) = args.named_child(1) {
                                let arg_text = get_node_text(&second_arg, source);
                                let var_name = arg_text.trim_start_matches('&').trim();
                                if let Some(initialized) = fpos_vars.get_mut(var_name) {
                                    *initialized = true;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    fn check_fsetpos_calls(
        &self,
        node: &Node,
        source: &str,
        fpos_vars: &std::collections::HashMap<String, bool>,
        violations: &mut Vec<RuleViolation>,
    ) {
        for n in query::find_descendants_of_kind(*node, "call_expression") {
            if let Some(func_node) = n.child_by_field_name("function") {
                if get_node_text(&func_node, source) == "fsetpos" {
                    if let Some(args) = n.child_by_field_name("arguments") {
                        if let Some(second_arg) = args.named_child(1) {
                            let arg_text = get_node_text(&second_arg, source);
                            let var_name = arg_text.trim_start_matches('&').trim();

                            // Check if this fpos_t was initialized by fgetpos
                            if let Some(&initialized) = fpos_vars.get(var_name) {
                                if !initialized {
                                    violations.push(RuleViolation {
                                        rule_id: self.rule_id().to_string(),
                                        severity: self.severity(),
                                        message: "fsetpos() called with value not obtained from fgetpos()".to_string(),
                                        file_path: String::new(),
                                        line: n.start_position().row + 1,
                                        column: n.start_position().column + 1,
                                        suggestion: None,
                                        requires_manual_review: None,
                                    });
                                }
                            } else {
                                // Variable not tracked, might be manually initialized
                                if arg_text.contains("__pos") || arg_text.contains('.') {
                                    violations.push(RuleViolation {
                                        rule_id: self.rule_id().to_string(),
                                        severity: self.severity(),
                                        message: "fsetpos() called with manually initialized fpos_t value".to_string(),
                                        file_path: String::new(),
                                        line: n.start_position().row + 1,
                                        column: n.start_position().column + 1,
                                        suggestion: None,
                                        requires_manual_review: None,
                                    });
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    fn get_identifier<'a>(&self, node: &Node<'a>, source: &'a str) -> Option<&'a str> {
        query::find_first_descendant(*node, |n| n.kind() == "identifier")
            .map(|n| get_node_text(&n, source))
    }
}