C安全编码之声明与初始化part1

1.声明对象的存储时间
一个对象的存储时间决定了他的生存周期。有三种存储时间：static， automatic，allocated。

错误代码：

char const *p;
void dont_do_this() {
    char const str[] = "This will change";
    p = str; /* dangerous */
    /* ... */
}
void innocuous() {
    char const str[] = "Surprise, surprise";
    printf("%s\n", p);
}

/* ... */
dont_do_this();
innocuous();
/* now, it is likely that p is pointing to "Surprise, surprise" */

p是指向字符常量的指针，全文可见。第4行，str是automatic，它生存周期从dont_do_this()函数执行到其结束。当调用dont_do_this函数结束后，调用innocuous()函数，p指向"Surprise, Surprise"，不是我们想要的结果。

正确：

char const *p;
void is_this_OK() {
    char const str[] = "Everything OK?";
    p = str;
    /* ... */
    p = NULL;
}

使用local stack变量作为返回值：

char *init_array() {
    char array[10];
    /* Initialize array */
    return array;
}

正确示范：

int main(int argc, char *argv[]) {
    char array[10];
    init_array(array);
    /* ... */
    return 0;
}
void init_array(char array[]) {
    /* Initialize array */
    return;
}

2.如果使用restrict符号， 确保函数的源指针和目的指针指向的数据没有重叠.若发生重叠，其行为未定义。

restrict是c99标准引入的，它只可以用于限定和约束指针，并表明指针是访问一个数据对象的唯一且初始的方式.即它告诉编译器，所有修改该指针所指向内存中内容的操作都必须通过该指针来修改,而不能通过其它途径(其它变量或指针)来修改;这样做的好处是,能帮助编译器进行更好的优化代码,生成更有效率的汇编代码.

3.使用volatile来修饰的数据不能缓存
定义为volatile以后，编译器每次取变量的值的时候都会从内存中载入，这样即使这个变量已经被别的程序修改了当前函数用的时候也能得到修改后的值.

#include <signal.h>
sig_atomic_t i;
void handler() {
    i = 0;
}
int main(void) {
    signal(SIGINT, handler);
    i = 1;
    while (i) {
        /* do something */
    }
}

假设i被缓存，则while将一直循环下去，即使受到SIGINT信号。

使用volatile，则每次while循环都会检测i的值：

#include <signal.h>
volatile sig_atomic_t i;
void handler() {
    i = 0;
}
int main(void) {
    signal(SIGINT, handler);
    i = 1;
    while (i) {
        /* do something */
    }
}

4.函数指针指向其他函数时，确保指向的新函数的类型与原始函数类型相同，否则其行为未定义。

/* type 1 function has return type int */
static int function_type_1(int a) {
    /* ... */
    return a;
}
/* type 2 function has return type void */
static void function_type_2(int a) {
    /* ... */
    return;
}
int main(void) {
    int x;
    int (*new_function)(int a) = function_type_1; /* new_function points to a type 1 function */
    x = (*new_function)(10); /* x is 10 */
    new_function = function_type_2; /* new_function now points to a type 2 function */
    x = (*new_function)(10); /* the resulting value is undefined */
    return 0;
}