/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2017 Peter Tribble.
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */

#ifndef _PKGLIB_H
#define _PKGLIB_H


#ifdef  __cplusplus
extern "C" {
#endif

#include <sys/types.h>
#include <limits.h>
#include <stdio.h>
#include <pkgdev.h>
#include <pkgstrct.h>
#include "cfext.h"

/*
 * The contents database file interface.
 */

typedef struct pkg_server *PKGserver;

/* Some commands modify the internal database: add them here */
#define PKG_WRITE_COMMAND(cmd)  ((cmd) == PKG_ADDLINES)

#define PKG_EXIT                0x0
#define PKG_FINDFILE            0x1
#define PKG_DUMP                0x2
#define PKG_PKGSYNC             0x3
#define PKG_FILTER              0x4
#define PKG_ADDLINES            0x5
#define PKG_NOP                 0x6

#define SUNW_PKG_SERVERMODE     "SUNW_PKG_SERVERMODE"

#define PKGSERV_MODE            "pkg-server-mode="
#define PKGSERV_MODE_LEN        (sizeof (PKGSERV_MODE) - 1)

#define MODE_PERMANENT          "permanent"
#define MODE_RUN_ONCE           "run_once"
#define MODE_TIMEOUT            "timeout"

#define MAXLOGFILESIZE          (20 * 1024 * 1024)

#define PKGLOG                  "pkglog"
#define PKGDOOR                 ".door"

typedef enum {
        INVALID,                /* Not initialized */
        NEVER,                  /* Don't start, does check if it is running. */
        FLUSH_LOG,              /* Run it once to incorporate the log. */
        RUN_ONCE,               /* Run until the current client stops. */
        TIMEOUT,                /* Run until a timeout occurs. */
        PERMANENT,              /* Run until it is externally terminated. */
        DEFAULTMODE = TIMEOUT   /* The default mode, must come last */
} start_mode_t;

typedef struct pkgcmd {
        int cmd;
        char buf[1];
} pkgcmd_t;

typedef struct pkgfilter {
        int cmd;
        int len;
        char buf[1];
} pkgfilter_t;

/*
 * Virtual File Protocol definitions
 */

/*
 * flags associated with virtual file protocol operations; note that these flags
 * may only occupy the low order 16 bits of the 32-bit unsigned flag.
 */

typedef unsigned long VFPFLAGS_T;

#define VFP_NONE        0x00000000      /* no special flags */
#define VFP_NEEDNOW     0x00000001      /* need memory now */
#define VFP_SEQUENTIAL  0x00000002      /* sequential access */
#define VFP_RANDOM      0x00000004      /* random access */
#define VFP_NOMMAP      0x00000008      /* do not use mmap to access file */
#define VFP_NOMALLOC    0x00000010      /* do not use malloc to buffer file */

/* virtual file protocol object */

typedef struct _vfp VFP_T;

/* structure behind the virtual file protocol object */

struct _vfp {
        FILE            *_vfpFile;      /* -> opened FILE */
        char            *_vfpCurr;      /* -> current byte to read/write */
        char            *_vfpHighWater; /* -> last byte modified */
        char            *_vfpEnd;       /* -> last data byte */
        char            *_vfpPath;      /* -> path associated with FILE */
        char            *_vfpStart;     /* -> first data byte */
        void            *_vfpExtra;     /* undefined */
        size_t          _vfpSize;       /* size of mapped/allocated area */
        size_t          _vfpMapSize;    /* # mapped bytes */
        VFPFLAGS_T      _vfpFlags;      /* flags associated with vfp/data */
        int             _vfpOverflow;   /* non-zero if buffer write overflow */
        blkcnt_t        _vfpCkStBlocks; /* checkpoint # blocks */
        dev_t           _vfpCkDev;      /* checkpoint device i.d. */
        ino_t           _vfpCkIno;      /* checkpoint inode # */
        off_t           _vfpCkSize;     /* checkpoint size */
        time_t          _vfpCkMtime;    /* checkpoint modification time */
};

/*
 * get highest modified byte (length) contained in vfp
 *
 * determine number of bytes to write - it will be the highest of:
 *  -- the current pointer into the file - this is updated whenever
 *      the location of the file is changed by a single byte
 *  -- the last "high water mark" - the last known location that
 *      was written to the file - updated only when the location
 *      of the file is directly changed - e.g. vfpSetCurrCharPtr,
 *      vfpTruncate, vfpRewind.
 * this reduces the "bookkeeping" that needs to be done to know
 * how many bytes to write out to the file - typically a file is
 * written sequentially so the current file pointer is sufficient
 * to determine how many bytes to write out.
 */

#define vfpGetModifiedLen(VFP)                                          \
        (size_t)(((VFP)->_vfpHighWater > (VFP)->_vfpCurr) ?             \
                (((ptrdiff_t)(VFP)->_vfpHighWater -                     \
                                (ptrdiff_t)(VFP)->_vfpStart)) :         \
                (((ptrdiff_t)(VFP)->_vfpCurr -                          \
                                (ptrdiff_t)(VFP)->_vfpStart)))

/*
 * increment current pointer by specified delta
 * if the delta exceeds the buffer size, set pointer to buffer end
 */
#define vfpIncCurrPtrBy(VFP, INC)                                       \
        {                                                               \
                ((VFP)->_vfpCurr) += (INC);                             \
                if (((VFP)->_vfpCurr) > ((VFP)->_vfpEnd)) {             \
                        (VFP)->_vfpCurr = (VFP)->_vfpEnd;               \
                        (VFP)->_vfpOverflow = 1;                        \
                }                                                       \
                if ((VFP)->_vfpHighWater < (VFP)->_vfpCurr) {           \
                        (VFP)->_vfpHighWater = (VFP)->_vfpCurr;         \
                }                                                       \
        }

/* get the path associated with the vfp */
#define vfpGetPath(VFP)         ((VFP)->_vfpPath)

/* get a string from the vfp into a fixed size buffer */
#define vfpGets(VFP, PTR, LEN)                                          \
        {                                                               \
                char    *XXpXX = (PTR);                                 \
                size_t  XXlXX = (LEN);                                  \
                while ((*(VFP)->_vfpCurr != '\0') &&                    \
                                (*(VFP)->_vfpCurr != '\n')) {           \
                        if (XXlXX > 1) {                                \
                                *XXpXX++ = *(VFP)->_vfpCurr;            \
                                XXlXX--;                                \
                        }                                               \
                        (VFP)->_vfpCurr++;                              \
                }                                                       \
                *XXpXX++ = '\0';                                        \
                if (*(VFP)->_vfpCurr != '\0') {                         \
                        (VFP)->_vfpCurr++;                              \
                }                                                       \
        }

/* get number of bytes remaining to read */
#define vfpGetBytesRemaining(VFP)       \
        (((((VFP)->_vfpHighWater) <= ((VFP)->_vfpCurr))) ? 0 :          \
        ((((ptrdiff_t)(VFP)->_vfpHighWater)-((ptrdiff_t)(VFP)->_vfpCurr))))

/* get number of bytes remaining to write */
#define vfpGetBytesAvailable(VFP)       \
        (((((VFP)->_vfpEnd) <= ((VFP)->_vfpCurr))) ? 0 :                \
        ((((ptrdiff_t)(VFP)->_vfpEnd)-((ptrdiff_t)(VFP)->_vfpCurr))))

/* put current character and increment to next */
#define vfpPutc(VFP, C)                                                 \
        {                                                               \
                (*(VFP)->_vfpCurr) = ((char)(C));                       \
                vfpIncCurrPtrBy((VFP), 1);                              \
        }

/* put integer to current character and increment */
#define vfpPutInteger(VFP, NUMBER)      vfpPutFormat((VFP), "%d", (NUMBER))

/* put long to current character and increment */
#define vfpPutLong(VFP, NUMBER) vfpPutFormat((VFP), "%ld", (NUMBER))

/* get current character and increment to next */
#define vfpGetc(VFP)            (*(VFP)->_vfpCurr++)

/* get current character - do not increment */
#define vfpGetcNoInc(VFP)       (*(VFP)->_vfpCurr)

/* get pointer to current character */
#define vfpGetCurrCharPtr(VFP)  ((VFP)->_vfpCurr)

/* increment current character pointer */
#define vfpIncCurrPtr(VFP)      vfpIncCurrPtrBy((VFP), 1)

/* decrement current character pointer */
#define vfpDecCurrPtr(VFP)      ((VFP)->_vfpCurr--)

/* get pointer to first data byte in buffer */
#define vfpGetFirstCharPtr(VFP) ((VFP)->_vfpStart)

/* get pointer to last data byte in buffer */
#define vfpGetLastCharPtr(VFP)  ((VFP)->_vfpHighWater)

/* set pointer to current character */
#define vfpSetCurrCharPtr(VFP, PTR)                                     \
        if ((VFP)->_vfpCurr > (VFP)->_vfpHighWater) {                   \
                (VFP)->_vfpHighWater = (VFP)->_vfpCurr;                 \
        }                                                               \
        ((VFP)->_vfpCurr = (PTR))

/* set pointer to last data byte in buffer */
#define vfpSetLastCharPtr(VFP, PTR)                                     \
        if ((PTR) >= (VFP)->_vfpStart) {                                \
                (VFP)->_vfpHighWater = (PTR);                           \
                if ((VFP)->_vfpCurr > (VFP)->_vfpHighWater) {           \
                        (VFP)->_vfpCurr = (VFP)->_vfpHighWater;         \
                }                                                       \
        }

/* seek to end of file - one past last data byte in file */
#define vfpSeekToEnd(VFP)       ((VFP)->_vfpCurr = ((VFP)->_vfpHighWater)+1)

/* get number of bytes between current char and specified char */
#define vfpGetCurrPtrDelta(VFP, P)      \
        (((ptrdiff_t)(P))-((ptrdiff_t)(VFP)->_vfpCurr))

/* put string to current character and increment */
#define vfpPuts(VFP, S)                                                 \
        {                                                               \
                size_t  xxLen;                                          \
                size_t  xxResult;                                       \
                xxLen = vfpGetBytesAvailable((VFP));                    \
                xxResult = strlcpy(((VFP)->_vfpCurr), (S), xxLen);      \
                vfpIncCurrPtrBy((VFP), xxResult);                       \
        }

/* put fixed number of bytes to current character and increment */
#define vfpPutBytes(VFP, PTR, LEN)                                      \
        {                                                               \
                size_t  xxLen;                                          \
                xxLen = vfpGetBytesAvailable((VFP));                    \
                if (xxLen > (LEN)) {                                    \
                        xxLen = (LEN);                                  \
                } else {                                                \
                        (VFP)->_vfpOverflow = 1;                        \
                }                                                       \
                memcpy((VFP)->_vfpCurr, (PTR), (xxLen));                \
                vfpIncCurrPtrBy((VFP), (xxLen));                        \
        }

/* put format one arg to current character and increment */
#define vfpPutFormat(VFP, FORMAT, ARG)                                  \
        {                                                               \
        char    xxTeMpXX[256];                                          \
        (void) snprintf(xxTeMpXX, sizeof (xxTeMpXX), (FORMAT), (ARG));  \
        vfpPuts((VFP), xxTeMpXX);                                       \
        }

struct dm_buf {
        char *text_buffer;      /* start of allocated buffer */
        int offset;             /* number of bytes into the text_buffer */
        int allocation;         /* size of buffer in bytes */
};

/* This structure is used to hold a dynamically growing string */

struct dstr {
        char *pc;
        int   len;
        int   max;
};

/* setmapmode() defines */
#define MAPALL          0       /* resolve all variables */
#define MAPBUILD        1       /* map only build variables */
#define MAPINSTALL      2       /* map only install variables */
#define MAPNONE         3       /* map no variables */

#define NON_ABI_NAMELNGTH       33      /* 32 chars for name + 1 for NULL */

#define BLK_SIZE        512     /* size of logical block */

/* max length for printed attributes */
#define ATTR_MAX        80

/*
 * These three defines indicate that the prototype file contains a '?'
 * meaning do not specify this data in the pkgmap entry.
 */
#define CURMODE         BADMODE         /* current mode has been specified */
#define CUROWNER        BADOWNER        /* ... same for owner ... */
#define CURGROUP        BADGROUP        /* ... and group. */

#define WILDCARD                BADMODE >> 1
#define DB_UNDEFINED_ENTRY      "?"

#define DEFAULT_MODE            0755
#define DEFAULT_MODE_FILE       0644
#define DEFAULT_OWNER   "root"
#define DEFAULT_GROUP   "other"

#define INST_RELEASE "var/sadm/system/admin/INST_RELEASE"

#define RANDOM                  "/dev/urandom"
#define BLOCK                   256

#define TERM_WIDTH              60
#define SMALL_DIVISOR           4
#define MED_DIVISOR             5
#define LARGE_DIVISOR           10

#define PKGADD                  "pkgadd"

/* package header magic tokens */
#define HDR_PREFIX      "# PaCkAgE DaTaStReAm"
#define HDR_SUFFIX      "# end of header"

#define GROUP   "/etc/group"
#define PASSWD  "/etc/passwd"

/*
 * The next three mean that no mode, owner or group was specified or that the
 * one specified is invalid for some reason. Sometimes this is an error in
 * which case it is generally converted to CUR* with a warning. Other times
 * it means "look it up" by stating the existing file system object pointred
 * to in the prototype file.
 */
#define NOMODE          (BADMODE-1)
#define NOOWNER         "@"
#define NOGROUP         "@"

/* string comparitor abbreviators */

#define ci_streq(a, b)          (strcasecmp((a), (b)) == 0)
#define ci_strneq(a, b, c)      (strncasecmp((a), (b), (c)) == 0)
#define streq(a, b)             (strcmp((a), (b)) == 0)
#define strneq(a, b, c)         (strncmp((a), (b), (c)) == 0)

extern FILE     *epopen(char *cmd, char *mode);
extern char     **gpkglist(char *dir, char **pkg, char **catg);
extern int      is_not_valid_length(char **category);
extern int      is_not_valid_category(char **category, char *progname);
extern int      is_same_CATEGORY(char **category, char *installed_category);
extern char **get_categories(char *catg_arg);

extern void     pkglist_cont(char *keyword);
extern char     **pkgalias(char *pkg);
extern char     *get_prog_name(void);
extern char     *set_prog_name(char *name);
extern int      averify(int fix, char *ftype, char *path, struct ainfo *ainfo);
extern int      ckparam(char *param, char *value);
extern int      ckvolseq(char *dir, int part, int nparts);
extern int      cverify(int fix, char *ftype, char *path, struct cinfo *cinfo,
                        int allow_checksum);
extern unsigned long    compute_checksum(int *r_cksumerr, char *a_path);
extern int      fverify(int fix, char *ftype, char *path, struct ainfo *ainfo,
                    struct cinfo *cinfo);
extern char     *getErrbufAddr(void);
extern int      getErrbufSize(void);
extern char     *getErrstr(void);
extern void     setErrstr(char *errstr);
extern int      devtype(char *alias, struct pkgdev *devp);
extern int      ds_totread;     /* total number of parts read */
extern int      ds_close(int pkgendflg);
extern int      ds_findpkg(char *device, char *pkg);
extern int      ds_getinfo(char *string);
extern int      ds_getpkg(char *device, int n, char *dstdir);
extern int      ds_ginit(char *device);
extern boolean_t        ds_fd_open(void);
extern int      ds_init(char *device, char **pkg, char *norewind);
extern int      ds_next(char *, char *);
extern int      ds_readbuf(char *device);
extern int      epclose(FILE *pp);
extern int      esystem(char *cmd, int ifd, int ofd);
extern int      e_ExecCmdArray(int *r_status, char **r_results,
                        char *a_inputFile, char *a_cmd, char **a_args);
extern int      e_ExecCmdList(int *r_status, char **r_results,
                        char *a_inputFile, char *a_cmd, ...);
extern int      gpkgmap(struct cfent *ept, FILE *fp);
extern int      gpkgmapvfp(struct cfent *ept, VFP_T *fpv);
extern void     setmapmode(int mode_no);
extern int      isFdRemote(int a_fd);
extern int      isFstypeRemote(char *a_fstype);
extern int      isPathRemote(char *a_path);
extern int      iscpio(char *path, int *iscomp);
extern int      isdir(char *path);
extern int      isfile(char *dir, char *file);
extern int      fmkdir(char *a_path, int a_mode);
extern int      pkgexecl(char *filein, char *fileout, char *uname, char *gname,
                        ...);
extern int      pkgexecv(char *filein, char *fileout, char *uname, char *gname,
                        char *arg[]);
extern int      pkghead(char *device);
extern int      pkgmount(struct pkgdev *devp, char *pkg, int part, int nparts,
                        int getvolflg);
extern int      pkgtrans(char *device1, char *device2, char **pkg,
                        int options);
extern int      pkgumount(struct pkgdev *devp);
extern int      ppkgmap(struct cfent *ept, FILE *fp);
extern int      putcfile(struct cfent *ept, FILE *fp);
extern int      putcvfpfile(struct cfent *ept, VFP_T *vfp);
extern int      rrmdir(char *path);
extern void     set_memalloc_failure_func(void (*)(int));
extern void     *xmalloc(size_t size);
extern void     *xrealloc(void *ptr, size_t size);
extern char     *xstrdup(char *str);

extern int      srchcfile(struct cfent *ept, char *path, PKGserver server);
extern struct   group *cgrgid(gid_t gid);
extern struct   group *cgrnam(char *nam);
extern struct   passwd *cpwnam(char *nam);
extern struct   passwd *cpwuid(uid_t uid);
extern struct   group *clgrgid(gid_t gid);
extern struct   group *clgrnam(char *nam);
extern struct   passwd *clpwnam(char *nam);
extern struct   passwd *clpwuid(uid_t uid);
extern void     basepath(char *path, char *basedir, char *ir);
extern void     canonize(char *file);
extern void     canonize_slashes(char *file);
extern void     checksum_off(void);
extern void     checksum_on(void);
extern void     cvtpath(char *path, char *copy);
extern void     ds_order(char *list[]);
extern void     ds_putinfo(char *buf, size_t);
extern void     ds_skiptoend(char *device);
extern void     ecleanup(void);
/*PRINTFLIKE1*/
extern void     logerr(char *fmt, ...);
extern int      mappath(int flag, char *path);
extern int      mapvar(int flag, char *varname);
/*PRINTFLIKE1*/
extern void     progerr(char *fmt, ...);
extern void     rpterr(void);
extern void     tputcfent(struct cfent *ept, FILE *fp);
extern void     set_nonABI_symlinks(void);
extern int      nonABI_symlinks(void);
extern void     disable_attribute_check(void);
extern int      get_disable_attribute_check(void);

/* pkgstr.c */
void            pkgstrConvertUllToTimeString_r(unsigned long long a_time,
                        char *a_buf, int a_bufLen);
char            *pkgstrConvertPathToBasename(char *a_path);
char            *pkgstrConvertPathToDirname(char *a_path);
char            *pkgstrDup(char *a_str);
char            *pkgstrLocatePathBasename(char *a_path);
void            pkgstrScaleNumericString(char *a_buf, unsigned long long scale);
void            pkgstrAddToken(char **a_old, char *a_new, char a_separator);
boolean_t       pkgstrContainsToken(char *a_string, char *a_token,
                        char *a_separators);
void            pkgstrExpandTokens(char **a_old, char *a_string,
                        char a_separator, char *a_separators);
char            *pkgstrGetToken(char *r_sep, char *a_string, int a_index,
                        char *a_separators);
void            pkgstrGetToken_r(char *r_sep, char *a_string, int a_index,
                        char *a_separators, char *a_buf, int a_bufLen);
unsigned long   pkgstrNumTokens(char *a_string, char *a_separators);
char            *pkgstrPrintf(char *a_format, ...);
void            pkgstrPrintf_r(char *a_buf, int a_bufLen, char *a_format, ...);
void            pkgstrRemoveToken(char **r_string, char *a_token,
                        char *a_separators, int a_index);
void            pkgstrRemoveLeadingWhitespace(char **a_str);
/* vfpops.c */
extern int      vfpCheckpointFile(VFP_T **r_destVfp, VFP_T **a_vfp,
                        char *a_path);
extern int      vfpCheckpointOpen(VFP_T **a_cvfp, VFP_T **r_vfp, char *a_path,
                        char *a_mode, VFPFLAGS_T a_flags);
extern int      vfpClearModified(VFP_T *a_vfp);
extern int      vfpClose(VFP_T **r_vfp);
extern int      vfpGetModified(VFP_T *a_vfp);
extern int      vfpOpen(VFP_T **r_vfp, char *a_path, char *a_mode,
                        VFPFLAGS_T a_flags);
extern void     vfpRewind(VFP_T *a_vfp);
extern ssize_t  vfpSafePwrite(int a_fildes, void *a_buf,
                        size_t a_nbyte, off_t a_offset);
extern ssize_t  vfpSafeWrite(int a_fildes, void *a_buf, size_t a_nbyte);
extern int      vfpSetFlags(VFP_T *a_vfp, VFPFLAGS_T a_flags);
extern int      vfpSetModified(VFP_T *a_vfp);
extern int      vfpSetSize(VFP_T *a_vfp, size_t a_size);
extern void     vfpTruncate(VFP_T *a_vfp);
extern int      vfpWriteToFile(VFP_T *a_vfp, char *a_path);

/* handlelocalfs.c */
boolean_t       enable_local_fs(void);
boolean_t       restore_local_fs(void);

/* path_valid.c */
extern boolean_t        path_valid(char *);

/* pkgserv.c */
extern PKGserver        pkgopenserver(const char *, const char *, boolean_t);
extern void             pkgcloseserver(PKGserver);
extern int              pkgcmd(PKGserver, void *, size_t, char **, size_t *,
    int *);
extern boolean_t        pkgsync_needed(const char *, const char *, boolean_t);
extern int              pkgsync(const char *, const char *, boolean_t);
extern int              pkgservercommitfile(VFP_T *, PKGserver);
extern int              pkgopenfilter(PKGserver server, const char *pkginst);
extern void             pkgclosefilter(PKGserver);
extern char             *pkggetentry(PKGserver, int *, int *);
extern char             *pkggetentry_named(PKGserver, const char *, int *,
    int *);
extern void             pkgserversetmode(start_mode_t);
extern start_mode_t     pkgservergetmode(void);
extern start_mode_t     pkgparsemode(const char *);
extern char             *pkgmodeargument(start_mode_t);

#ifdef  __cplusplus
}
#endif

#endif  /* _PKGLIB_H */