Описание

Errno, не проверяемый, происходит, когда вы вызываете функцию, которая устанавливает errno указать на состояние ошибки, но не проверять errno после вызова. Для этих функций, проверяя errno единственный надежный путь состоит в том, чтобы определить, произошла ли ошибка.

Функции, которые устанавливают errno при ошибках включайте:

Риск

Чтобы видеть если вызов функции, завершенный без ошибок, проверяйте errno для ошибочных значений.

Возвращаемые значения их errno- устанавливающие функции не указывают на ошибки. Возвращаемое значение может быть одним из следующего:

Можно определить, произошла ли ошибка только путем проверки errno.

Например, strtol преобразует строку в длинное целое и возвращает целое число. Если результат переполнения преобразования, функция возвращает LONG_MAX и наборы errno к ERANGE. Однако функция может также возвратить LONG_MAX от успешного преобразования. Только путем проверки errno можно ли различать ошибку и успешное преобразование.

Фиксация

Прежде, чем вызвать функцию, набор errno обнулять.

После вызова функции, чтобы видеть, произошла ли ошибка, сравнивают errno обнулять. В качестве альтернативы сравните errno к известным ошибочным значениям индикатора. Например, strtol наборы errno к ERANGE указать на ошибки.

Сообщение об ошибке в результате Polyspace^® показывает ошибочное значение индикатора, что можно выдержать сравнение с.

Пример - errno Не проверенный после вызова strtol

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

int main(int argc, char *argv[]) {
    char *str, *endptr;
    int base;
    
    str = argv[1];
    base = 10;
    
    long val = strtol(str, &endptr, base);
    printf("Return value of strtol() = %ld\n", val);
}

Вы используете возвращаемое значение strtol не проверяя errno.

Коррекция — проверяет errno После вызова

Прежде, чем вызвать strtol, установите errno обнулять. После вызова strtol, проверяйте возвращаемое значение на LONG_MIN или LONG_MAX и errno для ERANGE.

#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<limits.h>

int main(int argc, char *argv[]) {
    char *str, *endptr;
    int base;
    
    str = argv[1];
    base = 10;
    
    errno = 0;
    long val = strtol(str, &endptr, base);
    if((val == LONG_MIN || val == LONG_MAX) && errno == ERANGE) {
         printf("strtol error");
         exit(EXIT_FAILURE);
    }        
    printf("Return value of strtol() = %ld\n", val);
}

Описание

Возвращенное значение чувствительной функции, не проверяемой, происходит, когда вы вызываете чувствительные стандартные функции, но вас:

Для этого дефекта рассматриваются два типа функций: чувствительный и очень важный чувствительный.

Чувствительная функция является стандартной функцией, которая может столкнуться:

Критическая чувствительная функция является чувствительной функцией, которая выполняет одну из этих критических или уязвимых задач:

Риск

Если вы не проверяете возвращаемое значение функций, которые выполняют чувствительные или критические чувствительные задачи, ваша программа может неожиданно вести себя. Ошибки от этих функций могут распространить в программе, вызывающей неправильный выход, уязвимости системы обеспечения безопасности, и возможно системные отказы.

Фиксация

Прежде, чем продолжить программу, протестируйте возвращаемое значение критических чувствительных функций.

Для чувствительных функций можно явным образом проигнорировать возвращаемое значение путем кастинга функции к void. Polyspace не повышает этот дефект для чувствительного броска функций, чтобы освободить. Это разрешение не принято для критических чувствительных функций, потому что они выполняют более уязвимые задачи.

Пример - чувствительный функциональный проигнорированный возврат

#include <pthread.h>

void initialize() {
    pthread_attr_t attr;

    pthread_attr_init(&attr); 
}

Этот пример показывает вызов чувствительного функционального pthread_attr_init. Возвращаемое значение pthread_attr_init проигнорирован, вызвав дефект.

Коррекция — функция броска к (void)

Одна возможная коррекция должна бросить функцию, чтобы освободить. Эта фиксация сообщает Polyspace и любым рецензентам, что вы явным образом игнорируете возвращаемое значение чувствительной функции.

#include <pthread.h>

void initialize() {
    pthread_attr_t attr;

    (void)pthread_attr_init(&attr); 
}

Коррекция — тестирует возвращаемое значение

Одна возможная коррекция должна протестировать возвращаемое значение pthread_attr_init проверять ошибки.

#include <pthread.h>
#include <stdlib.h>
#define fatal_error() abort()

void initialize() {
    pthread_attr_t attr;
    int result;

    result = pthread_attr_init(&attr);
    if (result != 0) {
        /* Handle error */
        fatal_error();
    }
}

Пример - критический функциональный проигнорированный возврат

#include <pthread.h>
extern void *start_routine(void *);

void returnnotchecked() {
    pthread_t thread_id;
    pthread_attr_t attr;
    void *res;

    (void)pthread_attr_init(&attr);
    (void)pthread_create(&thread_id, &attr, &start_routine, ((void *)0));
    pthread_join(thread_id,  &res); 
}

В этом примере вызваны две критических функции: pthread_create и pthread_join. Возвращаемое значение pthread_create проигнорирован путем кастинга, чтобы освободить, но потому что pthread_create критическая функция (не только чувствительная функция), Polyspace не игнорирует это Возвращаемое значение чувствительной функции не проверяемый дефект. Другая критическая функция, pthread_join, возвращает значение, которое проигнорировано неявно. pthread_join использует возвращаемое значение pthread_create, который не проверялся.

Коррекция — тестирует возвращаемое значение критических функций

Коррекция для этого дефекта должна проверять возвращаемое значение этих критических функций, чтобы проверить функцию, выполняемую как ожидалось.

#include <pthread.h>
#include <stdlib.h>
#define fatal_error() abort()

extern void *start_routine(void *);

void returnnotchecked() {
    pthread_t thread_id;
    pthread_attr_t attr;
    void *res;
    int result;

    (void)pthread_attr_init(&attr);
    result = pthread_create(&thread_id, &attr, &start_routine, NULL);
    if (result != 0) {
        /* Handle error */
        fatal_error();
    }

    result = pthread_join(thread_id,  &res);
    if (result != 0) {
        /* Handle error */
        fatal_error();
    }
}

Описание

Незащищенное динамическое выделение памяти происходит, когда вы не проверяете после динамического выделения памяти ли выделение памяти, за которым следуют.

Риск

Когда память динамически выделяется с помощью malloc, calloc, или realloc, это возвращает значение NULL если требуемая память не доступна. Если код после выделения получает доступ к блоку памяти, не проверяя на этот NULL значение, этот доступ не защищен от отказов.

Фиксация

Проверяйте возвращаемое значение malloc, calloc, или realloc для NULL прежде, чем получить доступ к выделенной ячейке памяти.

int *ptr = malloc(size * sizeof(int));

if(ptr) /* Check for NULL */ 
{
   /* Memory access through ptr */
}

Пример - Незащищенная ошибка динамического выделения памяти

#include <stdlib.h>

void Assign_Value(void) 
{
  int* p = (int*)calloc(5, sizeof(int));

  *p = 2;  
  /* Defect: p is not checked for NULL value */

  free(p);
}

Если выделение памяти перестало работать, функциональный calloc возвращает NULL к p. Прежде, чем получить доступ к памяти через p, код не проверяет ли p isNull

Коррекция — проверяет на нулевое значение

Одна возможная коррекция должна проверять ли p имеет значение NULL прежде разыменовывают.

#include <stdlib.h>

void Assign_Value(void)
 {
   int* p = (int*)calloc(5, sizeof(int));

   /* Fix: Check if p is NULL */
   if(p!=NULL) *p = 2; 

   free(p);
 }