Return to asd.h CVS log

Up to [Research Unix] / researchv8dc / cmd / asd

Annotation of researchv8dc/cmd/asd/asd.h, revision 1.1.1.1

1.1       root        1: #include "ar.h"
                      2: #include <stdio.h>
                      3: #include <sys/types.h>
                      4: #include <sys/stat.h>
                      5: #include <signal.h>
                      6: #include <ctype.h>
                      7: #include <errno.h>
                      8: 
                      9: /* longest archive component name we will generate */
                     10: #define MAXCOMP 14
                     11: 
                     12: /* macro to allocate storage of a given type */
                     13: #define new(t) ((t *) alloc (sizeof (t)))
                     14: 
                     15: /* constants for tmpname function */
                     16: #define TMPDIR "/tmp/"
                     17: #define TMPNAML        (sizeof(TMPDIR) + 15)
                     18: 
                     19: /* some systems define SIG_TYP, others don't, so we make our own */
                     20: typedef int    (*Sig_typ)();
                     21: 
                     22: struct replist {
                     23:        char *source;
                     24:        char *dest;
                     25:        struct replist *link;
                     26: } *replist;
                     27: 
                     28: /* structures to deal with archive headers */
                     29: struct ar_hdr ar_hdr;
                     30: struct {
                     31:        long size;
                     32:        int mode;
                     33:        long date;
                     34: } hdr;
                     35: 
                     36: /*
                     37:  *     This stat buffer makes it easy to check that none of the
                     38:  *     input files is the same as the output.  This will avoid
                     39:  *     filling up the entire file system by inadvertently saying
                     40:  *
                     41:  *             mkpkg . > foo
                     42:  */
                     43: struct stat outsb;
                     44: 
                     45: /*
                     46:  *     The following structure helps keep track of things being packaged.
                     47:  *     iname is the internal name of the component -- in other words,
                     48:  *     the archive element name.  ename is the (short) pathname of the
                     49:  *     file.  The structures are chained by the "link" field.  All the
                     50:  *     other fields are copies of things returned by "stat" and are
                     51:  *     used mostly to make sure nothing changed while we were packaging.
                     52:  *     head and tail point to the first and last items in the chain.
                     53:  *     The first item is known to refer to the "Instructions" component.
                     54:  */
                     55: struct pack {
                     56:        char *iname;
                     57:        char *ename;
                     58:        struct pack *link;
                     59:        dev_t dev;
                     60:        ino_t ino;
                     61:        int uid, gid, mode;
                     62:        time_t time;
                     63:        off_t size;
                     64: };
                     65: 
                     66: struct pack *pkhead, *pktail;
                     67: 
                     68: 
                     69: FILE *popen();
                     70: char *alloc();
                     71: char *copy();
                     72: char *fgets();
                     73: char *fullname();
                     74: char *getfield();
                     75: char *getpass();
                     76: char *getpath();
                     77: char *hextab;
                     78: char *iname();
                     79: char *index();
                     80: char *instr;
                     81: char *keyfile;
                     82: char *mktemp();
                     83: char *optarg;
                     84: char *pwd();
                     85: char *ralloc();
                     86: char *rindex();
                     87: char *strcat();
                     88: char *strcpy();
                     89: char *strgid();
                     90: char *struid();
                     91: char *tmpname();
                     92: char *transname();
                     93: int Kflag;
                     94: int bflag;
                     95: int consider();
                     96: int dflag;
                     97: int errno;
                     98: int kflag;
                     99: int nflag;
                    100: int install();
                    101: int numgid();
                    102: int numuid();
                    103: int optind;
                    104: int package();
                    105: int pkgend();
                    106: int retcode;
                    107: int seal();
                    108: int unseal();
                    109: int vflag;
                    110: long cvlong();
                    111: long read_header();
                    112: void delete();
                    113: void geteol();
                    114: void next_header();
                    115: void pkgstart();
                    116: void pkgfile();
                    117: void putpath();

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