gis/format.c

Go to the documentation of this file.

#include <grass/gis.h>
#include <grass/glocale.h>
#include <unistd.h>
#include <stdlib.h>

#include <grass/config.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include "G.h"

/**********************************************************************
 *
 *   G__check_format(int fd)
 *
 *   Check to see if map with file descriptor "fd" is in compressed
 *   format.   If it is, the offset table at the beginning of the 
 *   file (which gives seek addresses into the file where code for
 *   each row is found) is read into the File Control Buffer (FCB).
 *   The compressed flag in the FCB is appropriately set.
 *
 *   returns:    1 if row pointers were read successfully, -1 otherwise
 **********************************************************************/

int G__check_format(int fd)
{
    struct fileinfo *fcb = &G__.fileinfo[fd];
    unsigned char compress[4];

    /*
     * Check to see if the file is in compress mode
     * 4 possibilites
     *   compressed flag in cellhd is negative (meaning pre 3.0 cell file)
     *       compression flag is first 3 bytes of cell file
     *   compression flag is 0 - not compressed
     *   compression flag is 1 - compressed using RLE (int) or zlib (FP)
     *   compression flag is 2 - compressed using zlib
     */

    if (fcb->cellhd.compressed < 0) {
        if (read(fd, compress, 3) != 3
            || compress[0] != 251 || compress[1] != 255 || compress[2] != 251)
            fcb->cellhd.compressed = 0;
    }

    if (!fcb->cellhd.compressed)
        return fd;

    /* allocate space to hold the row address array */
    fcb->row_ptr = G_calloc(fcb->cellhd.rows + 1, sizeof(off_t));

    /* read the row address array */
    return G__read_row_ptrs(fd);
}

int G__read_row_ptrs(int fd)
{
    struct fileinfo *fcb = &G__.fileinfo[fd];
    int nrows = fcb->cellhd.rows;
    unsigned char nbytes;
    unsigned char *buf, *b;
    int n;
    int row;

    /*
     * pre3.0 row addresses were written directly from the array of off_t's
     * (this makes them machine dependent)
     */

    if (fcb->cellhd.compressed < 0) {
        n = (nrows + 1) * sizeof(off_t);
        if (read(fd, fcb->row_ptr, n) != n)
            goto badread;
        return 1;
    }

    /*
     * 3.0 row address array is in a machine independent format
     * (warning - the format will work even if the sizeof(off_t) is
     *  not the same from machine to machine, as long as the
     *  actual values do not exceed the capability of the off_t)
     */

    if (read(fd, &nbytes, 1) != 1)
        goto badread;
    if (nbytes == 0)
        goto badread;

    n = (nrows + 1) * nbytes;
    buf = G_malloc(n);
    if (read(fd, buf, n) != n)
        goto badread;

    for (row = 0, b = buf; row <= nrows; row++) {
        off_t v = 0;

        for (n = 0; n < (int)nbytes; n++) {
            unsigned char c = *b++;

            if (nbytes > sizeof(off_t) && n < nbytes - sizeof(off_t) &&
                c != 0)
                goto badread;

            v <<= 8;
            v += c;
        }

        fcb->row_ptr[row] = v;
    }

    G_free(buf);

    return 1;

  badread:
    G_warning(_("Fail of initial read of compressed file [%s in %s]"),
              fcb->name, fcb->mapset);
    return -1;
}

int G__write_row_ptrs(int fd)
{
    struct fileinfo *fcb = &G__.fileinfo[fd];
    int nrows = fcb->cellhd.rows;
    int nbytes = sizeof(off_t);
    unsigned char *buf, *b;
    int len, row, result;

    lseek(fd, 0L, SEEK_SET);

    len = (nrows + 1) * nbytes + 1;
    b = buf = G_malloc(len);
    *b++ = nbytes;

    for (row = 0; row <= nrows; row++) {
        off_t v = fcb->row_ptr[row];
        int i;

        for (i = nbytes - 1; i >= 0; i--) {
            b[i] = v & 0xff;
            v >>= 8;
        }

        b += nbytes;
    }

    result = (write(fd, buf, len) == len);
    G_free(buf);

    return result;
}