[Dovecot] 0.99.11-test6

[Timo Sirainen]

On Mon, 2003-08-25 at 15:27, Timo Sirainen wrote:
> I'm actually still wondering a bit if this works. Have to ask from some 
> people who really know. The problem is that if I write 123 over XXX, 
> can a simultaneous read() return 1X3 in some situation? (1XX, 12X, XX3 
> and X23 are fine) That might break my plan..

That would probably work, but just to make sure here's an addition to
the plan. Can anyone think of a situation where this would break?


While MD5 is probably good enough, it doesn't _guarantee_ the
consistency. I just thought of a simple algorithm that I think would.
I'll go and use that unless someone proves it wrong :)

Except of course if there's 256 writes and the last one is non-ordered
and it all happens while a read() is executing.. Less than unlikely I'd
say.

I don't think there's any other potential problems with read() than that
it may not have all data up to date? Such as it would never temporarily
show the data as zero?

static int verify(const unsigned char *buf, size_t size)
{
        const unsigned char *checksum = buf + size;
        unsigned char xor;
        size_t i;

        xor = buf[0] ^ checksum[0];
        for (i = 1; i < size; i++) {
                if ((buf[i] ^ xor) != checksum[i])
                        return 0;
        }
        return 1;
}

void write_data(const void *data, size_t size)
{
        unsigned char *checksum = buf + size;
        unsigned char xor;
        size_t i;

        memcpy(buf, data, size);

        checksum[0]++; // always different checksum
        xor = buf[0] ^ checksum[0];

        for (i = 1; i < size; i++)
                checksum[i] = buf[i] ^ xor;
}

void read_data(void *data, size_t size)
{
        unsigned char copy[size*2];

        do {
                memcpy(copy, buf, size*2);
        } while (!verify(copy, size));
        memcpy(data, copy, size);
}