/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * Print the current working directory of an arbitrary process or core file.
 * While this uses libproc, it always does this read only, which is in the
 * spirit of the original pwdx that just read from /proc directly and didn't
 * support additional options.
 */

#include <err.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stdbool.h>
#include <libproc.h>
#include <locale.h>
#include <stdio.h>
#include <wchar.h>

#define EXIT_USAGE      2

typedef enum {
        PWDX_CWD        = 1 << 0,
        PWDX_MOUNT      = 1 << 1,
        PWDX_REST       = 1 << 2,
        PWDX_QUIET      = 1 << 3
} pwdx_output_t;

static void
pwdx_usage(const char *fmt, ...)
{
        if (fmt != NULL) {
                va_list ap;

                va_start(ap, fmt);
                vwarnx(fmt, ap);
                va_end(ap);
        }

        (void) fprintf(stderr, "Usage:  pwdx [-m] [-q | -v] { pid | core } "
            "...\n");
        (void) fprintf(stderr, "Print process and core current working "
            "directory\n"
            "\t-m\t\tshow mountpoint path\n"
            "\t-q\t\tonly output paths\n"
            "\t-v\t\toutput verbose mount information\n");
}

static void
pwdx_escape(char c)
{
        (void) printf("\\%c%c%c", '0' + ((c >> 6) & 07), '0' + ((c >> 3) & 07),
            '0' + (c & 07));
}

/*
 * We have a string that represents a path which is really an arbitrary byte
 * string. It may or may not be safe for the user to actually interpret if
 * we send it to a shell. So we go through and break this into multi-byte
 * characters and if they are printable, print them. If they are not, then we
 * write an escape sequence out byte by byte. We use the octal escape sequence,
 * not because we like it, but because that's consistent with pargs, ls, etc.
 */
static void
pwdx_puts(const char *str, bool newline)
{
        size_t slen = strlen(str), off = 0;

        while (off < slen) {
                wchar_t wc;
                int ret = mbtowc(&wc, str + off, slen - off);

                if (ret < 0) {
                        pwdx_escape(str[off]);
                        off++;
                        continue;
                } else if (ret == 0) {
                        break;
                }

                if (iswprint(wc)) {
                        (void) putwchar(wc);
                } else {
                        for (int i = 0; i < ret; i++) {
                                pwdx_escape(str[off + i]);
                        }
                }

                off += ret;
        }

        if (newline) {
                (void) putchar('\n');
        }
}

static bool
pwdx(const char *str, pwdx_output_t output)
{
        int err;
        bool ret = false;
        struct ps_prochandle *P;
        prcwd_t *cwd = NULL;
        const psinfo_t *info;

        P = proc_arg_grab(str, PR_ARG_ANY, PGRAB_RDONLY, &err);
        if (P == NULL) {
                warnx("failed to open %s: %s", str, Pgrab_error(err));
                return (false);
        }

        info = Ppsinfo(P);
        if (info == NULL) {
                warn("failed to get psinfo from %s", str);
                goto out;
        }

        if (Pcwd(P, &cwd) != 0) {
                warn("failed to read cwd of %s", str);
                goto out;
        }

        if ((output & PWDX_QUIET) == 0) {
                if (Pstate(P) == PS_DEAD) {
                        (void) printf("core '%s' of ", str);
                }
                (void) printf("%" _PRIdID ":\t", info->pr_pid);
        }

        if ((output & PWDX_CWD) != 0) {
                pwdx_puts(cwd->prcwd_cwd, true);
        } else {
                if (cwd->prcwd_mntpt[0] != '\0') {
                        pwdx_puts(cwd->prcwd_mntpt, true);
                } else {
                        (void) puts("<unknown>");
                }
        }

        if (output & PWDX_REST) {
                const char *spec, *point;

                if (cwd->prcwd_mntspec[0] == '\0') {
                        spec = "unknown";
                } else {
                        spec = cwd->prcwd_mntspec;
                }

                if (cwd->prcwd_mntpt[0] == '\0') {
                        point = "unknown";
                } else {
                        point = cwd->prcwd_mntpt;
                }

                (void) printf("\tMountpoint ");
                pwdx_puts(point, false);
                (void) printf(" on ");
                pwdx_puts(spec, true);
                (void) printf("\tFilesystem %s (ID: 0x%" PRIx64 ")\n",
                    cwd->prcwd_fsname, cwd->prcwd_fsid);
        }

        ret = true;

out:
        Pcwd_free(cwd);
        Pfree(P);
        return (ret);
}

int
main(int argc, char *argv[])
{
        int ret = EXIT_SUCCESS;
        pwdx_output_t output = PWDX_CWD;
        int c;

        (void) setlocale(LC_ALL, "");

        while ((c = getopt(argc, argv, ":mqv")) != -1) {
                switch (c) {
                case 'm':
                        output |= PWDX_MOUNT;
                        output &= ~PWDX_CWD;
                        break;
                case 'q':
                        if (output & PWDX_REST) {
                                errx(EXIT_USAGE, "only one of -q and -v may be "
                                    "specified");
                        }
                        output |= PWDX_QUIET;
                        break;
                case 'v':
                        if (output & PWDX_QUIET) {
                                errx(EXIT_USAGE, "only one of -q and -v may be "
                                    "specified");
                        }
                        output |= PWDX_CWD | PWDX_MOUNT | PWDX_REST;
                        break;
                case ':':
                        pwdx_usage("option -%c requires an "
                            "argument", optopt);
                        exit(EXIT_USAGE);
                case '?':
                        pwdx_usage("unknown option: -%c", optopt);
                        exit(EXIT_USAGE);
                }
        }

        argc -= optind;
        argv += optind;

        if (argc < 1) {
                errx(EXIT_FAILURE, "at least one process must be specified");
        }

        for (int i = 0; i < argc; i++) {
                if (!pwdx(argv[i], output))
                        ret = EXIT_FAILURE;
        }

        return (ret);
}