/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 *	Use is subject to license terms.
 */

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

/*
 * Copyright 2026 Oxide Computer Company
 */

/*
 * Print working (current) directory
 *
 * POSIX eventually added two flags in issue 6, which are for -P and -L. -P is
 * basically the mode that has traditionally been used, which should resolve
 * symlinks. -L is a logical mode that is designed to interact with the shell.
 * Basically it says if $PWD is set and meets the following conditions it should
 * be used:
 *
 * 1. It is an absolute path.
 * 2. It does not have any '.' or '..' path components in it.
 * 3. It actually is the current working directory by comparing a stat of that
 *    and '.'.
 *
 * If any of these is not true then it is supposed to fall back to the
 * traditional behavior here.
 *
 * Finally there is one last wrinkle, the default behavior. POSIX mandates that
 * the equivalent of -L be done by default. However, both GNU and *BSD generally
 * follow the traditional default of behaving as though -P is the default. Given
 * the 40+ year history of this command, we maintain that default and do the
 * same thing as others do.
 */

#include	<stdio.h>
#include	<unistd.h>
#include	<stdlib.h>
#include	<limits.h>
#include	<locale.h>
#include	<string.h>
#include	<stdbool.h>
#include	<err.h>
#include	<stdnoreturn.h>
#include	<sys/stat.h>

static char name[PATH_MAX+1];

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

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

	(void) fprintf(stderr, gettext("Usage:  pwd [-L | -P]\n"));
	exit(1);
}

static const char *
getcwd_log(void)
{
	const char *cwd = getenv("PWD");
	if (cwd == NULL || cwd[0] != '/')
		return (NULL);

	/*
	 * Look for path components that aren't solely '.' and '..'.
	 */
	for (size_t i = 0; cwd[i] != '\0'; i++) {
		if (cwd[i] != '/' || cwd[i + 1] != '.')
			continue;

		if (cwd[i + 2] == '\0' || cwd[i + 2] == '/') {
			return (NULL);
		}

		if (cwd[i + 2] == '.' && (cwd[i + 3] == '/' ||
		    cwd[i + 3] == '\0')) {
			return (NULL);
		}
	}

	struct stat log, phys;
	if (stat(cwd, &log) != 0 || stat(".", &phys) != 0 ||
	    log.st_dev != phys.st_dev || log.st_ino != phys.st_ino) {
		return (NULL);
	}

	return (cwd);
}

int
main(int argc, char *argv[])
{
	int c;
	bool Lflag = false;
	const char *cwd = NULL;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, ":LP")) != -1) {
		switch (c) {
		case 'L':
			Lflag = true;
			break;
		case 'P':
			Lflag = false;
			break;
		case ':':
			usage("option -%c requires an argument", optopt);
		case '?':
			usage("unknown option -%c", optopt);
		}
	}

	/*
	 * Historically our implementation of pwd has never checked for this. To
	 * reduce the likelihood of this being a fatal error if someone somehow
	 * gets /usr/bin/pwd, we instead make this a warning.
	 */
	if (argc - optind > 0) {
		warnx(gettext("ignoring unexpected operands starting with %s"),
		    argv[optind]);
	}

	if (Lflag) {
		cwd = getcwd_log();
	}

	if (cwd == NULL) {
		cwd = getcwd(name, PATH_MAX + 1);
		if (cwd == NULL) {
			err(2, gettext("cannot determine current directory"));
		}
	}

	if (puts(cwd) == EOF) {
		err(EXIT_FAILURE, gettext("failed to write out current working "
		    "directory"));
	}

	exit(0);
}