A note of warning: memcpy and memmove are not optimized away on msvc and icc. That is, every call to those functions is always a function call. Contrast to gcc and clang which always inline those calls even in no-optimizations builds. To do away with memcpy calls, you can use this:

    _Bool check_ip_header_sum(const char* p, size_t size) {
        struct Chunk { char arr[4]; };
        const Chunk* chunks =
                           (const Chunk*)p;
        union {
            Chunk chunk;
            uint32_t n;
        } helper;
        uint64_t sum=0;
        for (size_t i=.....) {
            helper.chunk=chunks[i];
            sum+=helper.n;
        }
        ........
    }

Technically speaking, going through a union like that is also undefined behaviour, however this is used everywhere in the Linux kernel, so both GCC and Clang will support it indefinitely, while MSVC is very conservative anyway, so you can rely on it supporting it as well. There is pretty much zero reason for the compiler to produce garbage code here. Note also that you can't cast p to the union type directly, because the union type has uint32_t alignment, so you have to do it this way. And you have to go through a struct, because you can't copy-assign arrays... Anyway the union+chunk trick seems more readable to me as well, but that's down to personal preference.