Return to archive.c CVS log

Up to [WindowsNT SDKs] / mstools / posix / samples / psxarc

Annotation of mstools/posix/samples/psxarc/archive.c, revision 1.1

1.1     ! root        1: //
        !             2: // In this file are routines to perform operations on archive files.
        !             3: // They do this by determining the type of the archive and calling a
        !             4: // corresponding type-specific routine.
        !             5: //
        !             6: 
        !             7: #include <stdlib.h>
        !             8: #include <stdio.h>
        !             9: #include <tar.h>
        !            10: #include <string.h>
        !            11: #include "buf.h"
        !            12: #include "psxarc.h"
        !            13: #include "tarhead.h"
        !            14: #include "cpio.h"
        !            15: #include "links.h"
        !            16: 
        !            17: //
        !            18: // These should be in an include file.
        !            19: //
        !            20: 
        !            21: extern void CpioList(), CpioRead(), CpioWrite();
        !            22: extern void TarList(), TarRead(), TarWrite();
        !            23: extern void cpio_itoa();
        !            24: 
        !            25: void
        !            26: ListArchive(PBUF pb)
        !            27: {
        !            28:        PCPIO_HEAD cp;
        !            29:        PTAR_HEAD tp;
        !            30: 
        !            31:        InitLinkList();
        !            32: 
        !            33:        bfill(pb);
        !            34:        cp = (PCPIO_HEAD)pb->data;
        !            35: 
        !            36:        if (0 == strncmp(cp->c_magic, MAGIC, strlen(MAGIC))) {
        !            37:                CpioList(pb);
        !            38:                return;
        !            39:        }
        !            40:        
        !            41:        tp = (PTAR_HEAD)pb->data;
        !            42: 
        !            43:        if (0 == strncmp(tp->s.magic, TMAGIC, strlen(TMAGIC))) {
        !            44:                TarList(pb);
        !            45:                return;
        !            46:        }
        !            47:        fprintf(stderr, "%s: unknown archive type\n", progname);
        !            48:        exit(4);
        !            49: }
        !            50: 
        !            51: void
        !            52: WriteArchive(PBUF pb, int format, char **files, int count)
        !            53: {
        !            54:        InitLinkList();
        !            55: 
        !            56:        if (FORMAT_CPIO == format) {
        !            57:                int len, i;
        !            58:                CPIO_HEAD h;
        !            59: 
        !            60:                CpioWrite(pb, files, count);
        !            61: 
        !            62:                // write the trailer.
        !            63:                (void)strncpy(h.c_magic, MAGIC, strlen(MAGIC));
        !            64:                cpio_itoa(C_ISREG, h.c_mode, sizeof(h.c_mode));
        !            65:                cpio_itoa(sizeof(LASTFILENAME), h.c_namesize,
        !            66:                        sizeof(h.c_namesize));
        !            67:                cpio_itoa(0, h.c_filesize, sizeof(h.c_namesize));
        !            68: 
        !            69:                for (i = 0; i < sizeof(h); ++i) {
        !            70:                        bputc(pb, ((char *)&h)[i]);
        !            71:                }
        !            72: 
        !            73:                // "sizeof" so we get the nul, too
        !            74:                len = sizeof(LASTFILENAME);
        !            75:                for (i = 0; i < len; ++i) {
        !            76:                        bputc(pb, LASTFILENAME[i]);
        !            77:                }
        !            78:                bflush(pb);
        !            79:                return;
        !            80:        }
        !            81:        if (FORMAT_TAR == format) {
        !            82:                TarWrite(pb, files, count);
        !            83:                
        !            84:                // a tar archive is terminated by two blocks of zeroes.
        !            85:                memset(pb->data, 0, sizeof(pb->data));
        !            86:                bflush(pb);
        !            87:                bflush(pb);
        !            88:                return;
        !            89:        }
        !            90:        // shouldn't get here.
        !            91:        exit(10);
        !            92: }
        !            93: 
        !            94: void
        !            95: ReadArchive(PBUF pb)
        !            96: {
        !            97:        PCPIO_HEAD cp;
        !            98:        PTAR_HEAD tp;
        !            99: 
        !           100:        InitLinkList();
        !           101: 
        !           102:        bfill(pb);
        !           103:        cp = (PCPIO_HEAD)pb->data;
        !           104: 
        !           105:        if (0 == strncmp(cp->c_magic, MAGIC, strlen(MAGIC))) {
        !           106:                CpioRead(pb);
        !           107:                return;
        !           108:        }
        !           109:        
        !           110:        tp = (PTAR_HEAD)pb->data;
        !           111: 
        !           112:        if (0 == strncmp(tp->s.magic, TMAGIC, strlen(TMAGIC))) {
        !           113:                TarRead(pb);
        !           114:                return;
        !           115:        }
        !           116:        fprintf(stderr, "%s: unknown archive type\n", progname);
        !           117:        exit(4);
        !           118: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.