Code Reviewer

/*
 * sample_c_clean.c — sample_c_smells.c refactored per
 * rules/universal.md + languages/c.md. Same surface area, zero
 * detector hits.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


void safe_input(void) {
    char buf[64];

    /* fgets is bounds-aware */
    if (fgets(buf, sizeof(buf), stdin) == NULL) {
        return;
    }

    char dest[10];
    /* strncpy with explicit bound + manual null-terminate */
    strncpy(dest, buf, sizeof(dest) - 1);
    dest[sizeof(dest) - 1] = '\0';

    /* strncat with remaining-space bound */
    size_t room = sizeof(dest) - strlen(dest) - 1;
    strncat(dest, "world", room);

    char msg[100];
    /* snprintf is bounds-aware */
    snprintf(msg, sizeof(msg), "%s says hello", buf);

    /* Format string is a literal; buf is an argument */
    printf("%s\n", buf);

    char name[32];
    /* %s with explicit width prevents overflow */
    scanf("%31s", name);
}


void checked_alloc(int n) {
    /* malloc result is NULL-checked before any dereference */
    char *buf = malloc(n);
    if (buf == NULL) {
        return;
    }
    buf[0] = 'x';
    buf[1] = 'y';
    strncpy(buf, "ok", n - 1);

    free(buf);
    buf = NULL;
    printf("done\n");
}


void run_safe_cmd(void) {
    /* system() with a string literal — no command-injection surface */
    system("ls -la");
}


int main(int argc, char *argv[]) {
    (void)argc;
    (void)argv;
    safe_input();
    checked_alloc(100);
    run_safe_cmd();
    return 0;
}


/*
 * sample_c_smells.c — labelled instances of every C-specific pattern
 * the code-reviewer skill flags. Every smell is annotated inline with
 * its CWE and the rule from languages/c.md.
 *
 * Refactored counterpart: sample_c_clean.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


void unsafe_input(void) {
    char buf[64];

    /* RULE: banned function gets() — CWE-242, no bounds check */
    gets(buf);

    char dest[10];
    /* RULE: banned function strcpy() — no bounds check */
    strcpy(dest, buf);

    /* RULE: banned function strcat() — no bounds check */
    strcat(dest, "world");

    char msg[100];
    /* RULE: banned function sprintf() — no bounds check */
    sprintf(msg, "%s says hello", buf);

    /* RULE: format-string vulnerability — CWE-134, buf controls format */
    printf(buf);

    char name[32];
    /* RULE: unbounded scanf — %s without width, CWE-120 */
    scanf("%s", name);
}


void leaky_alloc(int n) {
    /* RULE: malloc result not NULL-checked within 5 lines — CWE-690 */
    char *buf = malloc(n);
    buf[0] = 'x';
    buf[1] = 'y';
    strcpy(buf, "leak");

    /* RULE: free without zeroing pointer — CWE-416 dangling */
    free(buf);
    printf("done\n");
}


void run_user_cmd(const char *cmd_from_user) {
    /* RULE: system() with non-literal argument — CWE-78 command injection */
    system(cmd_from_user);
}


int main(int argc, char *argv[]) {
    if (argc > 1) {
        unsafe_input();
        leaky_alloc(100);
        run_user_cmd(argv[1]);
    }
    return 0;
}


// Sample C# file showing the fixed version of sample_csharp_smells.cs.
// Same shape, but every smell has been resolved per the patterns documented
// in rules/universal.md and languages/csharp.md.
//
// Run:
//   python scripts/code_quality_checker.py assets/sample_csharp_clean.cs
//
// Expected: no HIGH C#-specific smells flagged.

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Data.SqlClient;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace Sample
{
    public class DbOptions
    {
        // FIX: connection string from configuration, never inlined.
        public string ConnectionString { get; init; } = "";
    }

    public class UserService
    {
        private readonly string _connectionString;
        private readonly HttpClient _httpClient;
        private readonly ILogger<UserService> _logger;

        // FIX: IHttpClientFactory + IOptions, no hardcoded secrets, no `new