atheos.c

给出了 zip 压缩算法的完整实现过程。

            unsigned long offset = ptr - *attr_buff;

            *attr_buff = (char *)realloc( *attr_buff, attrs_size );
            if( *attr_buff == NULL ) {
                retval = close_attrdir( fa_dir );
                /* TODO: check retval != EOK */
                close( fd );
                return ENOMEM;
            }

            ptr = *attr_buff + offset;
        }

        /* Now copy the data for this attribute into the buffer. */
        strcpy( ptr, fa_ent->d_name );
        ptr += entname_size;

        memcpy( ptr, &fa_info, sizeof( struct attr_info ) );
        ptr += sizeof( struct attr_info );

        if( fa_info.ai_size > 0 ) {
            ssize_t read_bytes = read_attr( fd, fa_ent->d_name, fa_info.ai_type, ptr, 0, fa_info.ai_size );
            if( read_bytes != fa_info.ai_size ) {
                /* print a warning about mismatched sizes */
                char buff[80];
                sprintf( buff, "read %d, expected %d", read_bytes, (ssize_t)fa_info.ai_size );
                zipwarn( "attribute size mismatch: ", buff );
            }

            ptr += fa_info.ai_size;
        }
    }

    /* ----------------------------------------------------------------- */
    /* Close the attribute directory.                                    */
    retval = close_attrdir( fa_dir );
    /* TODO: check retval != EOK */

    /* ----------------------------------------------------------------- */
    /* If the buffer is too big, shrink it.                              */
    if( attrs_size < INITIAL_BUFF_SIZE ) {
        *attr_buff = (char *)realloc( *attr_buff, attrs_size );
        if( *attr_buff == NULL ) {
            close( fd );
            return ENOMEM;
        }
    }

    *total_size = attrs_size;

    close( fd );

    return EOK;
}

/* ---------------------------------------------------------------------- */
/* Add a 'UT' extra field to the zlist data pointed to by z.              */

#define EB_L_UT_SIZE    (EB_HEADSIZE + EB_UT_LEN(2))
#define EB_C_UT_SIZE    (EB_HEADSIZE + EB_UT_LEN(1))

local int add_UT_ef( struct zlist far *z )
{
    char        *l_ef = NULL;
    char        *c_ef = NULL;
    struct stat  s;

#ifdef IZ_CHECK_TZ
    if (!zp_tz_is_valid)
        return ZE_OK;           /* skip silently if no valid TZ info */
#endif

    /* We can't work if there's no entry to work on. */
    if( z == NULL ) {
        return ZE_LOGIC;
    }

    /* Check to make sure we've got enough room in the extra fields. */
    if( z->ext + EB_L_UT_SIZE > USHRT_MAX ||
        z->cext + EB_C_UT_SIZE > USHRT_MAX ) {
        return ZE_MEM;
    }

    /* stat() the file (or the symlink) to get the data; if we can't get */
    /* the data, there's no point in trying to fill out the fields.      */
    if(LSSTAT( z->name, &s ) ) {
        return ZE_OPEN;
    }

    /* Allocate memory for the local and central extra fields. */
    if( z->extra && z->ext != 0 ) {
        l_ef = (char *)realloc( z->extra, z->ext + EB_L_UT_SIZE );
    } else {
        l_ef = (char *)malloc( EB_L_UT_SIZE );
        z->ext = 0;
    }
    if( l_ef == NULL ) {
        return ZE_MEM;
    }
    z->extra = l_ef;
    l_ef += z->ext;

    if( z->cextra && z->cext != 0 ) {
        c_ef = (char *)realloc( z->cextra, z->cext + EB_C_UT_SIZE );
    } else {
        c_ef = (char *)malloc( EB_C_UT_SIZE );
        z->cext = 0;
    }
    if( c_ef == NULL ) {
        return ZE_MEM;
    }
    z->cextra = c_ef;
    c_ef += z->cext;

    /* Now add the local version of the field. */
    *l_ef++ = 'U';
    *l_ef++ = 'T';
    *l_ef++ = (char)(EB_UT_LEN(2)); /* length of data in local EF */
    *l_ef++ = (char)0;
    *l_ef++ = (char)(EB_UT_FL_MTIME | EB_UT_FL_ATIME);
    *l_ef++ = (char)(s.st_mtime);
    *l_ef++ = (char)(s.st_mtime >> 8);
    *l_ef++ = (char)(s.st_mtime >> 16);
    *l_ef++ = (char)(s.st_mtime >> 24);
    *l_ef++ = (char)(s.st_atime);
    *l_ef++ = (char)(s.st_atime >> 8);
    *l_ef++ = (char)(s.st_atime >> 16);
    *l_ef++ = (char)(s.st_atime >> 24);

    z->ext += EB_L_UT_SIZE;

    /* Now add the central version. */
    memcpy(c_ef, l_ef-EB_L_UT_SIZE, EB_C_UT_SIZE);
    c_ef[EB_LEN] = (char)(EB_UT_LEN(1)); /* length of data in central EF */

    z->cext += EB_C_UT_SIZE;

    return ZE_OK;
}

/* ---------------------------------------------------------------------- */
/* Add a 'Ux' extra field to the zlist data pointed to by z.              */

#define EB_L_UX2_SIZE   (EB_HEADSIZE + EB_UX2_MINLEN)
#define EB_C_UX2_SIZE   (EB_HEADSIZE)

local int add_Ux_ef( struct zlist far *z )
{
    char        *l_ef = NULL;
    char        *c_ef = NULL;
    struct stat  s;

    /* Check to make sure we've got enough room in the extra fields. */
    if( z->ext + EB_L_UX2_SIZE > USHRT_MAX ||
        z->cext + EB_C_UX2_SIZE > USHRT_MAX ) {
        return ZE_MEM;
    }

    /* stat() the file (or the symlink) to get the data; if we can't get */
    /* the data, there's no point in trying to fill out the fields.      */
    if(LSSTAT( z->name, &s ) ) {
        return ZE_OPEN;
    }

    /* Allocate memory for the local and central extra fields. */
    if( z->extra && z->ext != 0 ) {
        l_ef = (char *)realloc( z->extra, z->ext + EB_L_UX2_SIZE );
    } else {
        l_ef = (char *)malloc( EB_L_UX2_SIZE );
        z->ext = 0;
    }
    if( l_ef == NULL ) {
        return ZE_MEM;
    }
    z->extra = l_ef;
    l_ef += z->ext;

    if( z->cextra && z->cext != 0 ) {
        c_ef = (char *)realloc( z->cextra, z->cext + EB_C_UX2_SIZE );
    } else {
        c_ef = (char *)malloc( EB_C_UX2_SIZE );
        z->cext = 0;
    }
    if( c_ef == NULL ) {
        return ZE_MEM;
    }
    z->cextra = c_ef;
    c_ef += z->cext;

    /* Now add the local version of the field. */
    *l_ef++ = 'U';
    *l_ef++ = 'x';
    *l_ef++ = (char)(EB_UX2_MINLEN);
    *l_ef++ = (char)(EB_UX2_MINLEN >> 8);
    *l_ef++ = (char)(s.st_uid);
    *l_ef++ = (char)(s.st_uid >> 8);
    *l_ef++ = (char)(s.st_gid);
    *l_ef++ = (char)(s.st_gid >> 8);

    z->ext += EB_L_UX2_SIZE;

    /* Now add the central version of the field. */
    *c_ef++ = 'U';
    *c_ef++ = 'x';
    *c_ef++ = 0;
    *c_ef++ = 0;

    z->cext += EB_C_UX2_SIZE;

    return ZE_OK;
}

/* ---------------------------------------------------------------------- */
/* Add a 'At' extra field to the zlist data pointed to by z.              */

#define EB_L_AT_SIZE    (EB_HEADSIZE + EB_L_AT_LEN) /* + attr size */
#define EB_C_AT_SIZE    (EB_HEADSIZE + EB_C_AT_LEN)

#define MEMCOMPRESS_HEADER      6   /* ush compression type, ulg CRC */
#define DEFLAT_WORSTCASE_ADD    5   /* byte blocktype, 2 * ush blocklength */
#define MEMCOMPRESS_OVERHEAD    (MEMCOMPRESS_HEADER + DEFLAT_WORSTCASE_ADD)

local int add_At_ef( struct zlist far *z )
{
    char *l_ef       = NULL;
    char *c_ef       = NULL;
    char *attrbuff   = NULL;
    off_t attrsize   = 0;
    char *compbuff   = NULL;
    ush   compsize   = 0;
    uch   flags      = 0;

    /* Check to make sure we've got enough room in the extra fields. */
    if( z->ext + EB_L_AT_SIZE > USHRT_MAX ||
        z->cext + EB_C_AT_SIZE > USHRT_MAX ) {
        return ZE_MEM;
    }

    /* Attempt to load up a buffer full of the file's attributes. */
    {
        if (get_attr_dir( z->name, &attrbuff, &attrsize) != EOK ) {
            return ZE_OPEN;
        }
        if (attrsize == 0) {
            return ZE_OK;
        }
        if (attrbuff == NULL) {
            return ZE_LOGIC;
        }

        /* Check for way too much data. */
        if (attrsize > (off_t)ULONG_MAX) {
            zipwarn( "uncompressed attributes truncated", "" );
            attrsize = (off_t)(ULONG_MAX - MEMCOMPRESS_OVERHEAD);
        }
    }

    if (verbose) {
        printf( "\t[in=%lu]", (unsigned long)attrsize );
    }

    /* Try compressing the data */
    compbuff = (char *)malloc( (size_t)attrsize + MEMCOMPRESS_OVERHEAD );
    if( compbuff == NULL ) {
        return ZE_MEM;
    }
    compsize = memcompress( compbuff,
                            (size_t)attrsize + MEMCOMPRESS_OVERHEAD,
                            attrbuff,
                            (size_t)attrsize );
    if (verbose) {
        printf( " [out=%u]", compsize );
    }

    /* Attempt to optimise very small attributes. */
    if (compsize > attrsize) {
        free( compbuff );
        compsize = (ush)attrsize;
        compbuff = attrbuff;

        flags = EB_AT_FL_NATURAL;
    }

    /* Check to see if we really have enough room in the EF for the data. */
    if( ( z->ext + compsize + EB_L_AT_LEN ) > USHRT_MAX ) {
        compsize = USHRT_MAX - EB_L_AT_LEN - z->ext;
    }

    /* Allocate memory for the local and central extra fields. */
    if( z->extra && z->ext != 0 ) {
        l_ef = (char *)realloc( z->extra, z->ext + EB_L_AT_SIZE + compsize );
    } else {
        l_ef = (char *)malloc( EB_L_AT_SIZE + compsize );
        z->ext = 0;
    }
    if( l_ef == NULL ) {
        return ZE_MEM;
    }
    z->extra = l_ef;
    l_ef += z->ext;

    if( z->cextra && z->cext != 0 ) {
        c_ef = (char *)realloc( z->cextra, z->cext + EB_C_AT_SIZE );
    } else {
        c_ef = (char *)malloc( EB_C_AT_SIZE );
        z->cext = 0;
    }
    if( c_ef == NULL ) {
        return ZE_MEM;
    }
    z->cextra = c_ef;
    c_ef += z->cext;

    /* Now add the local version of the field. */
    *l_ef++ = 'A';
    *l_ef++ = 't';
    *l_ef++ = (char)(compsize + EB_L_AT_LEN);
    *l_ef++ = (char)((compsize + EB_L_AT_LEN) >> 8);
    *l_ef++ = (char)((unsigned long)attrsize);
    *l_ef++ = (char)((unsigned long)attrsize >> 8);
    *l_ef++ = (char)((unsigned long)attrsize >> 16);
    *l_ef++ = (char)((unsigned long)attrsize >> 24);
    *l_ef++ = flags;
    memcpy( l_ef, compbuff, (size_t)compsize );

    z->ext += EB_L_AT_SIZE + compsize;

    /* And the central version. */
    *c_ef++ = 'A';
    *c_ef++ = 't';
    *c_ef++ = (char)(EB_C_AT_LEN);
    *c_ef++ = (char)(EB_C_AT_LEN >> 8);
    *c_ef++ = (char)compsize;
    *c_ef++ = (char)(compsize >> 8);
    *c_ef++ = (char)(compsize >> 16);
    *c_ef++ = (char)(compsize >> 24);
    *c_ef++ = flags;

    z->cext += EB_C_AT_SIZE;

    return ZE_OK;
}

/* Extra field info:
   - 'UT' - UNIX time extra field
   - 'Ux' - UNIX uid/gid extra field
   - 'At' - AtheOS file attributes extra field

   This is done the same way ../unix/unix.c stores the 'UT'/'Ux' fields
   (full data in local header, only modification time in central header),
   with the 'At' field added to the end and the size of the 'At' field
   in the central header.

   See the end of atheos/osdep.h for a simple explanation of the 'At' EF
   layout.
 */
int set_extra_field(z, z_utim)
  struct zlist far *z;
  iztimes *z_utim;
  /* store full data in local header but just modification time stamp info
     in central header */
{
    int retval;

    /* Check to make sure z is valid. */
    if( z == NULL ) {
        return ZE_LOGIC;
    }

    retval = add_UT_ef(z);
    if( retval != ZE_OK ) {
        return retval;
    }

    retval = add_Ux_ef(z);
    if( retval != ZE_OK ) {
        return retval;
    }

    return add_At_ef(z); /* last function; we can use return value directly */
}

/* ---------------------------------------------------------------------- */
/* Set a file's MIME type.                                                */
void setfiletype(const char *file, const char *type)
{
    int fd;
    off_t nLen;
    ssize_t nError;

    fd = open( file, O_RDWR );

    if (fd < 0) {
        zipwarn( "can't open zipfile to write file type", "" );
    }

    else
    {
        nLen = strlen( type );
        /* FIXME: write_attr() should return count of bytes written */
        nError = write_attr( fd, "os::MimeType", O_TRUNC, ATTR_TYPE_STRING, type, 0, nLen );
        if (nError < 0) {
            zipwarn( "couldn't write complete file type", "" );
        }
        close( fd );
    }
}

#endif /* !UTIL */

/******************************/
/*  Function version_local()  */
/******************************/

void version_local()
{
    static ZCONST char CompiledWith[] = "Compiled with %s%s for %s%s%s%s.\n\n";

    printf(CompiledWith,

#ifdef __GNUC__
      "gcc ", __VERSION__,
#else
      "(unknown compiler)", "",
#endif

      "Syllable",

#if defined(i486) || defined(__i486) || defined(__i486__) || defined(i386) || defined(__i386) || defined(__i386__)
      " (x86)",
#else
      " (unknown platform)",
#endif

#ifdef __DATE__
      " on ", __DATE__
#else
      "", ""
#endif
    );

} /* end function version_local() */