/*
 * 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   */


/* EMACS_MODES: !fill, lnumb, !overwrite, !nodelete, !picture */

#include "stdio.h"
#include "fcntl.h"
#include "string.h"
#include "errno.h"
#include "pwd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "stdlib.h"
#include <stdarg.h>
#include <unistd.h>
#include "pwd.h"

#include "lp.h"

int
is_printer_uri(char *value)
{
        if (value == NULL)
                return (-1);

        if ((value[0] == '/') && (access(value, F_OK) == 0))
                return (-1); /* a valid path */

        if (strstr(value, "://") == NULL)
                return (-1); /* not in uri form */

        return (0);
}

/*
 * To avoid a race condition, chown() should always be called before
 * chmod().
 */
int
chownmod(char *path, uid_t owner, gid_t group, mode_t mode)
{
        int rc;

        if ((rc = Chown(path, owner, group)) == 0)
                rc = Chmod(path, mode);

        return (rc);
}


int
fdprintf(int fd, char *fmt, ...)
{
        char    buf[BUFSIZ];
        va_list ap;

        if (fd == 1)
                fflush(stdout);
        va_start(ap, fmt);
        vsnprintf(buf, sizeof (buf), fmt, ap);
        va_end(ap);
        return (Write(fd, buf, (int)strlen(buf)));
}

char *
fdgets(char *buf, int len, int fd)
{
        char    tmp;
        int     count = 0;

        memset(buf, 0, len);
        while ((count < len) && (Read(fd, &tmp, 1) > 0))
                if ((buf[count++] = tmp) == '\n') break;

        if (count != 0)
                return (buf);
        return (NULL);
}

int
fdputs(char *buf, int fd)
{
        return (fdprintf(fd, "%s", buf));
}

int
fdputc(char c, int fd)
{
        if (fd == 1)
                fflush(stdout);
        return (write(fd, &c, 1));
}

int
open_locked(char *path, char *type, mode_t mode)
{
        struct flock            l;
        int                     fd,
                                oflag,
                                create,
                                truncate = 0;

        if (!path || !type) {
                errno = EINVAL;
                return (-1);
        }

#define plus (type[1] == '+')
        switch (type[0]) {
        case 'w':
                oflag = plus? O_RDWR : O_WRONLY;
                create = 1;
                truncate = 1;
                break;
        case 'a':
                oflag = (plus? O_RDWR : O_WRONLY) | O_APPEND;
                create = 1;
                break;
        case 'r':
                oflag = plus? O_RDWR : O_RDONLY;
                create = 0;
                break;
        default:
                errno = EINVAL;
                return (-1);
        }
        if ((fd = Open(path, oflag, mode)) == -1)
                if (errno == ENOENT && create) {
                        int             old_umask = umask(0);
                        int             save_errno;

                        if ((fd = Open(path, oflag|O_CREAT, mode)) != -1)
                                chown_lppath(path);
                        save_errno = errno;
                        if (old_umask)
                                umask(old_umask);
                        errno = save_errno;
                }

        if (fd == -1)
        switch (errno) {
        case ENOTDIR:
                errno = EACCES;
                /* FALLTHROUGH */
        default:
                return (-1);
        }

        l.l_type = (oflag & (O_WRONLY|O_RDWR)? F_WRLCK : F_RDLCK);
        l.l_whence = 1;
        l.l_start = 0;
        l.l_len = 0;
        if (Fcntl(fd, F_SETLK, &l) == -1) {
                /*
                 * Early UNIX op. sys. have wrong errno.
                 */
                if (errno == EACCES)
                        errno = EAGAIN;
                Close(fd);
                return (-1);
        }

        if (truncate) {
                if ((lseek(fd, 0, SEEK_SET) == (off_t)-1) ||
                    (ftruncate(fd, 0) == -1)) {
                        Close(fd);
                        return (-1);
                }
        }

        return (fd);
}


FILE *
open_lpfile(char *path, char *type, mode_t mode)
{
        FILE            *fp = NULL;
        int             fd;

        if ((fd = open_locked(path, type, mode)) >= 0) {
                errno = 0;      /* fdopen() may fail and not set errno */
                if (!(fp = fdopen(fd, type))) {
                        Close(fd);
                }
        }
        return (fp);
}
int
close_lpfile(FILE *fp)
{
        return (fclose(fp));
}

/*
 * chown_lppath()
 */

int
chown_lppath(char *path)
{
        static uid_t    lp_uid;

        static gid_t    lp_gid;

        static int      gotids = 0;

        struct passwd   *ppw;


        if (!gotids) {
                if (!(ppw = getpwnam(LPUSER)))
                        ppw = getpwnam(ROOTUSER);
                endpwent();
                if (!ppw)
                        return (-1);
                lp_uid = ppw->pw_uid;
                lp_gid = ppw->pw_gid;
                gotids = 1;
        }
        return (Chown(path, lp_uid, lp_gid));
}

/*
 * rmfile() - UNLINK FILE BUT NO COMPLAINT IF NOT THERE
 */

int
rmfile(char *path)
{
        return (Unlink(path) == 0 || errno == ENOENT);
}

/*
 * loadline() - LOAD A ONE-LINE CHARACTER STRING FROM FILE
 */

char *
loadline(char *path)
{
        int fd;
        register char           *ret;
        register int            len;
        char                    buf[BUFSIZ];

        if ((fd = open_locked(path, "r", MODE_READ)) < 0)
                return (0);

        if (fdgets(buf, BUFSIZ, fd)) {
                if ((len = strlen(buf)) && buf[len - 1] == '\n')
                        buf[--len] = 0;
                if ((ret = Malloc(len + 1)))
                        strcpy(ret, buf);
        } else {
                errno = 0;
                ret = 0;
        }

        close(fd);
        return (ret);
}

/*
 * loadstring() - LOAD A CHARACTER STRING FROM FILE
 */

char *
loadstring(char *path)
{
        int fd;
        register char           *ret;
        register int            len;

        if ((fd = open_locked(path, "r", MODE_READ)) < 0)
                return (0);

        if ((ret = sop_up_rest(fd, (char *)0))) {
                if ((len = strlen(ret)) && ret[len - 1] == '\n')
                        ret[len - 1] = 0;
        } else
                errno = 0;

        close(fd);
        return (ret);
}

/*
 * dumpstring() - DUMP CHARACTER STRING TO FILE
 */

int
dumpstring(char *path, char *str)
{
        int fd;

        if (!str)
                return (rmfile(path));

        if ((fd = open_locked(path, "w", MODE_READ)) < 0)
                return (-1);
        fdprintf(fd, "%s\n", str);
        close(fd);
        return (0);
}