C安全编码之表达式part0

1.使用括号确保表达式执行顺序：

表达式：x与1相与后判断是否等于0.
错误表达式：

x & 1 == 0

因为==操作符的优先级高于&，表达式会先进行（1==0）操作，最后进行（x&0)操作。

正确表示：

(x & 1) == 0

C语言操作符优先级列表：Primary Expression Operators优先级最高，Unary Operators其次，依次类推。


2.错误使用sizeof(指向某类型的指针)来判断某类型大小：

double *d_array;
size_t num_elems;
/* ... */
if (num_elems > SIZE_MAX/sizeof(d_array)){
    /* handle error condition */
}
else {
    d_array = malloc(sizeof(d_array) * num_elems);
}

在32bit的系统中，sizeof(double)等于8,而sizeof(指向double类型的指针）等于4.

正确：

double *d_array;
size_t num_elems;
/* ... */
if (num_elems > SIZE_MAX/sizeof(*d_array)){
       /* handle error condition */
}
else {
    d_array = malloc(sizeof(*d_array) * num_elems);
}

在32bit系统中，sizeof(*d_array)等于8。

3.在逻辑AND和逻辑OR运算符（&&，| |）中，第二个表达式不应有副作用。

错误代码：

int i;
int max;
if ( (i >= 0 && (i++) <= max) ) {
    /* code */
}

(i++) <= max)可能是(i <= max)也可能是((i+1)<=max)，由编译器决定。

正确：

int i;
int max;
if ( (i >= 0 && (i + 1) <= max) ) {
    i++;
   /* code */
}

4.结构体各个成员的sizeof()大小之和，不一定等于结构体sizeof()大小。为保证结构体内存对齐（32bit系统为4字节对齐，需要结构体填充(structure padding)。

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

struct buffer {
    size_t size;
    char buffer[50];
};

int main(void)
{
    struct buffer a;
    printf("sizeof() : %d, sum of sizeof() : %d\n", sizeof(a), sizeof(a.size)+sizeof(a.buffer));
    return 0;
}

5.结构体之间的比较不要进行逐字节比较，采用逐结构体成员比较。因为存在结构体填充，其填充的字节数和内容是在执行时定义。若尝试逐字节比较会导致错误结果。

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

struct buffer {
    size_t size;
    char buffer[50];
};

unsigned int buf_compare(struct buffer *s1, struct buffer *s2) {
    if (!memcmp(s1, s2, sizeof(struct buffer))) {
        return 1;
    }
    return 0;
}


unsigned int member_compare(struct buffer *s1, struct buffer *s2) {
    if ((s1->size == s2->size) && (!memcmp(s1->buffer, s2->buffer, sizeof(s1->buffer)))){
        return 1;
    }
    return 0;
}

int main(void)
{
    struct buffer a, b;
    a.size = 0x01;
    memset(a.buffer, 0x00, sizeof(a.buffer));
    b.size = 0x01;
    memset(b.buffer, 0x00, sizeof(b.buffer));
    if (0x01 == buf_compare(&a, &b)){
        printf("buf match!\n");
    }else{
        printf("buf not match!\n");
    }

    if (0x01 == member_compare(&a, &b)){
        printf("member match!\n");
    }else{
        printf("member not match!\n");
    }

    return 0;
}

6.不能修改const对象

错误：

void remove_spaces(char const *str, size_t slen) {
    char *p = (char*)str;
    size_t i;
    for (i = 0; i < slen && str[i]; i++) {
        if (str[i] != ' ') *p++ = str[i];
    }
    *p = '\0';
}

函数remove_spaces取消字符串str中的空格，但是str为定义为char const *str,其值不能进行修改。

正确：

void remove_spaces(char *str, size_t slen) {
        char *p = (char*)str;
        size_t i;
        for (i = 0; i < slen && str[i]; i++) {
            if (str[i] != ' ') *p++ = str[i];
        }
        *p = '\0';
    }

7.sizeof()的操作数不应包含副作用。具有副作用的操作数不会被执行或计算。

int a = 14;
int b = sizeof(a++)

b初始化后，a还是等于14.sizeof()中的a++没有执行。
正确：

int a = 14;
int b = sizeof(a);
a++

8.谨慎使用NULL和0，特别关于指针。
一个值为0整型常量表达式或此类表达式强制转换为void *类型，被称为空指针常量。如果一个空指针常量转换成一个指针类型后得到的指针称为空指针，其不等于指向任何对象或函数的指针。

在编译阶段，常量0在指针上下文中被转换成空指针。也就是，在进行初始化，分配或比较时，一边是变量或表达式指针类型时，编译器会把另一边的常量0转换成具有正确类型的空指针值。例如下面代码：

char *p = 0;
if(p != 0)

然而，一个传递给函数的参数不一定识别为一个指针上下文，编译器也不能把一个未修饰的0作为空指针。例如：

execl("/bin/sh", "sh", "-c", "ls", 0)

正确表示：

execl("/bin/sh", "sh", "-c", "ls", (char *)0)

建议如果是与指针相关最好使用NULL(NULL是专门用于这种情况)，它会更容易检查使用不当的指针。

最好使用：

execl("/bin/sh", "sh", "-c", "ls", (char *)NULL)

9.确保指针运算的正确使用

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

struct buffer{
    int a;
    char str[50];
};

int main()
{
    char s[] = "hello world!";

    struct buffer buf;
    buf.a = 0x04;
    memset(buf.str, 0, sizeof(buf.str));

    /* 错误， &buf+sizeof(buf.a)等于加上sizeof(struct buffer)*sizeof(buf.a)的偏移*/
    memcpy(&buf+sizeof(buf.a), s, strlen(s));
    printf("&buf's offset : %d\n", (char *)(&buf+sizeof(buf.a))-(char *)&buf);

    /* correct */
    memcpy(((char *)&buf+sizeof(buf.a)), s, strlen(s));
    printf("(char *)&buf's offset : %d\n", (char *)&buf+sizeof(buf.a)-(char *)&buf);

    return 0;
}

10.使用sizeof来确定一个类型或变量的大小
不要硬编码一个类型的大小到代码中。因为对齐，填充，基本类型因系统不同大小不同（例如，32位与64位指针），大多数类型的大小发生变化在与不同编译器之间，即使是版本相同的编译器。
错误：

int *p = (int *)calloc(1, 4)

正确：

int *p = (int *)calloc(1, sizeof(int)