Return to asd.h CVS log

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

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

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

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