OpenSolaris_b135/lib/libpkg/common/pkgserv.c
/*
* 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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <pkglib.h>
#include <alloca.h>
#include <assert.h>
#include <door.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <libintl.h>
#include <sys/mnttab.h>
#include <sys/mkdev.h>
#define PKGADD_MAX (512 * 1024)
#define SADM_DIR "/var/sadm/install"
#define PKGSERV_PATH "/usr/sadm/install/bin/pkgserv"
#define ERR_PATH_TOO_BIG "alternate root path is too long"
#define ERR_OPEN_DOOR "cannot open pkgserv door"
#define ERR_START_SERVER "cannot start pkgserv daemon: %s"
#define ERR_START_FILTER "cannot enumerate database entries"
#define ERR_FIND_SADM "cannot find sadm directory"
struct pkg_server {
FILE *fp;
char *curbuf;
int buflen;
int door;
boolean_t onetime;
};
static PKGserver current_server;
static start_mode_t defmode = INVALID;
static boolean_t registered = B_FALSE;
static pid_t master_pid = -1;
static void
pkgfilename(char path[PATH_MAX], const char *root, const char *sadmdir,
const char *file)
{
if (snprintf(path, PATH_MAX, "%s%s/%s", root == NULL ? "" : root,
sadmdir == NULL ? SADM_DIR : sadmdir, file) >= PATH_MAX) {
progerr(gettext(ERR_PATH_TOO_BIG));
exit(99);
}
}
static void
free_xmnt(struct extmnttab *xmnt)
{
free(xmnt->mnt_special);
free(xmnt->mnt_mountp);
free(xmnt->mnt_fstype);
}
static void
copy_xmnt(const struct extmnttab *xmnt, struct extmnttab *saved)
{
free_xmnt(saved);
/*
* Copy everything and then strdup the strings we later use and NULL
* the ones we don't.
*/
*saved = *xmnt;
if (saved->mnt_special != NULL)
saved->mnt_special = strdup(saved->mnt_special);
if (saved->mnt_mountp != NULL)
saved->mnt_mountp = strdup(saved->mnt_mountp);
if (saved->mnt_fstype != NULL)
saved->mnt_fstype = strdup(saved->mnt_fstype);
saved->mnt_mntopts = NULL;
saved->mnt_time = NULL;
}
static int
testdoor(char *path)
{
int dir;
int fd;
struct door_info di;
int res;
dir = open(path, O_RDONLY);
if (dir == -1)
return (-1);
fd = openat(dir, PKGDOOR, O_RDWR);
(void) close(dir);
if (fd == -1)
return (-1);
res = door_info(fd, &di);
(void) close(fd);
return (res);
}
/*
* We need to make sure that we can locate the pkgserv and the door;
* lofs mounts makes this more difficult: "nosub" mounts don't propagate
* the door and doors created in lofs mounts are not propagated back to
* the original filesystem.
* Here we peel off the lofs mount points until we're
* at /var/sadm/install or
* we find a working door or
* there's nothing more to peel off.
* The fullpath parameter is used to return the result (stored in *sadmdir),
* root is used but returned in the computed sadmdir and so the caller should
* not use "root" any longer or set it to NULL.
*/
static void
pkgfindrealsadmdir(char fullpath[PATH_MAX], const char *root,
const char **sadmdir)
{
struct stat buf;
struct extmnttab xmnt;
FILE *mnttab = NULL;
char temp[PATH_MAX];
struct extmnttab saved = {NULL, NULL, NULL, NULL, NULL, 0, 0};
if (snprintf(temp, PATH_MAX, "%s%s",
root == NULL ? "" : root,
*sadmdir == NULL ? SADM_DIR : *sadmdir) >= PATH_MAX) {
progerr(gettext(ERR_PATH_TOO_BIG));
exit(99);
}
if (stat(temp, &buf) != 0) {
progerr(gettext(ERR_FIND_SADM));
exit(99);
}
/*
* To find the underlying mount point, you will need to
* search the mnttab and find our mountpoint and the underlying
* filesystem.
* To find the mount point: use the longest prefix but limit
* us to the filesystems with the same major/minor numbers.
* To find the underlying mount point: find a non-lofs file
* system or a <mnt> <mnt> entry (fake mountpoint for zones).
*/
for (;;) {
size_t max = 0;
if (realpath(temp, fullpath) == NULL) {
progerr(gettext(ERR_FIND_SADM));
exit(99);
}
if (strcmp(fullpath, SADM_DIR) == 0)
break;
if (testdoor(fullpath) == 0)
break;
if (mnttab == NULL)
mnttab = fopen(MNTTAB, "r");
else
resetmnttab(mnttab);
while (getextmntent(mnttab, &xmnt, 0) == 0) {
size_t len;
if (major(buf.st_dev) != xmnt.mnt_major ||
minor(buf.st_dev) != xmnt.mnt_minor)
continue;
len = strlen(xmnt.mnt_mountp);
if (len < max)
continue;
if (strncmp(xmnt.mnt_mountp, fullpath, len) == 0 &&
(len == 1 || fullpath[len] == '/' ||
fullpath[len] == '\0')) {
max = len;
copy_xmnt(&xmnt, &saved);
}
}
if (strcmp(saved.mnt_fstype, "lofs") != 0 ||
strcmp(saved.mnt_mountp, saved.mnt_special) == 0) {
break;
}
/* Create a new path in the underlying filesystem. */
if (snprintf(temp, PATH_MAX, "%s%s", saved.mnt_special,
&fullpath[max]) >= PATH_MAX) {
progerr(gettext(ERR_PATH_TOO_BIG));
exit(99);
}
}
if (mnttab != NULL) {
free_xmnt(&saved);
(void) fclose(mnttab);
}
*sadmdir = fullpath;
}
static void
pkgexit_close(void)
{
if (current_server != NULL)
pkgcloseserver(current_server);
}
static PKGserver
pkgopenserver_i(const char *root, const char *sadmdir, boolean_t readonly,
start_mode_t mode)
{
PKGserver server;
struct door_info di;
pid_t pid;
int stat;
int first = B_TRUE;
char *cmd[16];
int args;
char pkgdoor[PATH_MAX];
char realsadmdir[PATH_MAX];
extern char **environ;
char *prog;
char pidbuf[12];
if (current_server != NULL)
return (current_server);
if (!registered) {
registered = B_TRUE;
(void) atexit(pkgexit_close);
}
if (readonly) {
int fd;
(void) strcpy(pkgdoor, "/tmp/pkgdoor.XXXXXX");
if ((fd = mkstemp(pkgdoor)) < 0) {
progerr(gettext(ERR_OPEN_DOOR));
return (NULL);
}
(void) close(fd);
} else {
pkgfindrealsadmdir(realsadmdir, root, &sadmdir);
root = NULL;
pkgfilename(pkgdoor, root, sadmdir, PKGDOOR);
}
server = malloc(sizeof (*server));
if (server == NULL)
goto return_null;
server->fp = NULL;
server->onetime = readonly;
openserver:
server->door = open(pkgdoor, O_RDWR);
if (server->door >= 0) {
if (door_info(server->door, &di) == 0 && di.di_target >= 0) {
pkgcmd_t n;
n.cmd = PKG_NOP;
server->buflen = 1024;
server->curbuf = malloc(1024);
if (server->curbuf == NULL ||
pkgcmd(server, &n, sizeof (n), NULL, NULL, NULL)) {
pkgcloseserver(server);
return (NULL);
}
return (current_server = server);
}
(void) close(server->door);
}
if (!first || mode == NEVER)
goto return_null;
first = B_FALSE;
args = 0;
cmd[args++] = strrchr(PKGSERV_PATH, '/') + 1;
if (root != NULL && strcmp(root, "/") != 0) {
cmd[args++] = "-R";
cmd[args++] = (char *)root;
}
if (sadmdir != NULL && strcmp(sadmdir, SADM_DIR) != 0) {
cmd[args++] = "-d";
cmd[args++] = (char *)sadmdir;
}
if (readonly) {
cmd[args++] = "-r";
cmd[args++] = pkgdoor;
}
prog = get_prog_name();
if (prog != NULL) {
cmd[args++] = "-N";
cmd[args++] = prog;
}
switch (mode) {
case FLUSH_LOG:
cmd[args++] = "-e";
break;
case RUN_ONCE:
cmd[args++] = "-o";
break;
case PERMANENT:
cmd[args++] = "-p";
break;
default:
break;
}
if (master_pid != -1) {
cmd[args++] = "-P";
(void) snprintf(pidbuf, sizeof (pidbuf), "%d", master_pid);
cmd[args++] = pidbuf;
}
cmd[args++] = NULL;
assert(args <= sizeof (cmd)/sizeof (char *));
if (posix_spawn(&pid, PKGSERV_PATH, NULL, NULL, cmd, environ) == 0) {
server->onetime |= mode == RUN_ONCE;
while (wait4(pid, &stat, 0, NULL) != -1) {
if (WIFEXITED(stat)) {
int s = WEXITSTATUS(stat);
if (s == 0 || s == 1)
if (mode == FLUSH_LOG)
goto return_null;
else
goto openserver;
if (s == 2)
goto return_null;
break;
} else if (WIFSIGNALED(stat)) {
break;
}
}
}
progerr(gettext(ERR_START_SERVER), strerror(errno));
return_null:
if (readonly)
(void) unlink(pkgdoor);
free(server);
return (NULL);
}
PKGserver
pkgopenserver(const char *root, const char *sadmdir, boolean_t ro)
{
return (pkgopenserver_i(root, sadmdir, ro, pkgservergetmode()));
}
start_mode_t
pkgparsemode(const char *mode)
{
if (strcasecmp(mode, MODE_PERMANENT) == 0) {
return (PERMANENT);
} else if (strncasecmp(mode, MODE_TIMEOUT,
sizeof (MODE_TIMEOUT) - 1) == 0) {
const char *pidstr = mode + sizeof (MODE_TIMEOUT) - 1;
if (pidstr[0] != '\0') {
master_pid = atoi(pidstr);
if (master_pid <= 1 || kill(master_pid, 0) != 0)
master_pid = -1;
}
return (TIMEOUT);
} else if (strcasecmp(mode, MODE_RUN_ONCE) == 0) {
return (RUN_ONCE);
} else {
progerr(gettext("invalid pkgserver mode: %s"), mode);
exit(99);
/*NOTREACHED*/
}
}
char *
pkgmodeargument(start_mode_t mode)
{
static char timebuf[sizeof (PKGSERV_MODE) + sizeof (MODE_TIMEOUT) + 10];
switch (mode) {
case PERMANENT:
return (PKGSERV_MODE MODE_PERMANENT);
case TIMEOUT:
(void) snprintf(timebuf, sizeof (timebuf),
PKGSERV_MODE MODE_TIMEOUT "%d",
(master_pid > 1 && kill(master_pid, 0) == 0) ? master_pid :
getpid());
return (timebuf);
case RUN_ONCE:
return (PKGSERV_MODE MODE_RUN_ONCE);
}
progerr(gettext("Bad pkgserv mode: %d"), (int)mode);
exit(99);
}
void
pkgserversetmode(start_mode_t mode)
{
if (mode == DEFAULTMODE || mode == INVALID) {
char *var = getenv(SUNW_PKG_SERVERMODE);
if (var != NULL)
defmode = pkgparsemode(var);
else
defmode = DEFAULTMODE;
} else {
defmode = mode;
}
}
start_mode_t
pkgservergetmode(void)
{
if (defmode == INVALID)
pkgserversetmode(DEFAULTMODE);
return (defmode);
}
void
pkgcloseserver(PKGserver server)
{
if (server->fp != NULL)
(void) fclose(server->fp);
free(server->curbuf);
if (server->onetime) {
pkgcmd_t cmd;
cmd.cmd = PKG_EXIT;
(void) pkgcmd(server, &cmd, sizeof (cmd), NULL, NULL, NULL);
}
(void) close(server->door);
if (server == current_server)
current_server = NULL;
free(server);
}
int
pkgcmd(PKGserver srv, void *cmd, size_t len, char **result, size_t *rlen,
int *fd)
{
door_arg_t da;
da.data_ptr = cmd;
da.data_size = len;
da.desc_ptr = NULL;
da.desc_num = 0;
da.rbuf = result == NULL ? NULL : *result;
da.rsize = rlen == NULL ? 0 : *rlen;
if (door_call(srv->door, &da) != 0) {
if (((pkgcmd_t *)cmd)->cmd == PKG_EXIT && errno == EINTR)
return (0);
return (-1);
}
if (da.desc_ptr != NULL) {
int i = 0;
if (fd != NULL)
*fd = da.desc_ptr[i++].d_data.d_desc.d_descriptor;
for (; i < da.desc_num; i++)
(void) close(da.desc_ptr[i].d_data.d_desc.d_descriptor);
}
/* Error return */
if (da.data_size == sizeof (int)) {
int x = *(int *)da.data_ptr;
if (x != 0) {
if (result == NULL || da.rbuf != *result)
(void) munmap(da.rbuf, da.rsize);
return (x);
}
}
/* Other result */
if (result != NULL) {
/* Make sure that the result is at the start of the buffer. */
if (da.data_ptr != NULL && da.rbuf != da.data_ptr)
(void) memmove(da.rbuf, da.data_ptr, da.data_size);
*result = da.rbuf;
*rlen = da.data_size;
} else if (da.rbuf != NULL) {
(void) munmap(da.rbuf, da.rsize);
}
return (0);
}
/*
* Pkgsync:
* If the server is running, make sure that the contents
* file is written.
* If the server is not running, check for the log file;
* if there's a non-empty log file, we need to start the server
* as it will incorporate the log file into the contents file.
* And then check if the door is present. If it doesn't, we don't
* need to call it.
*/
boolean_t
pkgsync_needed(const char *root, const char *sadmdir, boolean_t want_quit)
{
struct stat pbuf;
char pkgfile[PATH_MAX];
boolean_t sync_needed, running;
int fd;
struct door_info di;
pkgfilename(pkgfile, root, sadmdir, PKGLOG);
sync_needed = stat(pkgfile, &pbuf) == 0 && pbuf.st_size > 0;
if (!sync_needed && !want_quit)
return (B_FALSE);
pkgfilename(pkgfile, root, sadmdir, PKGDOOR);
/* sync_needed == B_TRUE || want_quit == B_TRUE */
running = B_FALSE;
fd = open(pkgfile, O_RDWR);
if (fd >= 0) {
if (door_info(fd, &di) == 0) {
/* It's mounted, so the server is likely there */
running = B_TRUE;
}
(void) close(fd);
}
return (running || sync_needed);
}
int
pkgsync(const char *root, const char *sadmdir, boolean_t force_quit)
{
void *server;
pkgcmd_t cmd;
/* No need to write contents file; don't start if not running */
if (!pkgsync_needed(root, sadmdir, force_quit))
return (0);
server = pkgopenserver_i(root, sadmdir, B_FALSE, FLUSH_LOG);
/*
* We're assuming that it started the server and exited immediately.
* If that didn't work, there's nothing we can do.
*/
if (server == NULL)
return (0);
cmd.cmd = force_quit ? PKG_EXIT : PKG_DUMP;
(void) pkgcmd(server, &cmd, sizeof (cmd), NULL, NULL, NULL);
(void) pkgcloseserver(server);
return (0);
}
int
pkgservercommitfile(VFP_T *a_vfp, PKGserver server)
{
size_t len = vfpGetModifiedLen(a_vfp);
ssize_t rem = len;
size_t off;
pkgfilter_t *pcmd;
char *map = a_vfp->_vfpStart;
if (len < PKGADD_MAX)
pcmd = alloca(sizeof (*pcmd) + len);
else
pcmd = alloca(sizeof (*pcmd) + PKGADD_MAX);
off = 0;
pcmd->cmd = PKG_ADDLINES;
while (rem > 0) {
char *p = map + off;
len = rem;
if (len >= PKGADD_MAX) {
len = PKGADD_MAX - 1;
while (p[len] != '\n' && len > 0)
len--;
if (p[len] != '\n')
return (-1);
len++;
}
(void) memcpy(&pcmd->buf[0], p, len);
pcmd->len = len;
if (pkgcmd(server, pcmd, sizeof (*pcmd) + len - 1,
NULL, NULL, NULL) != 0) {
return (-1);
}
rem -= len;
off += len;
}
pcmd->len = 0;
pcmd->cmd = PKG_PKGSYNC;
if (pkgcmd(server, pcmd, sizeof (*pcmd), NULL, NULL, NULL) != 0)
return (-1);
/* Mark it unmodified. */
vfpTruncate(a_vfp);
(void) vfpClearModified(a_vfp);
return (0);
}
int
pkgopenfilter(PKGserver server, const char *filt)
{
int fd;
pkgfilter_t *pfcmd;
int clen = filt == NULL ? 0 : strlen(filt);
int len = sizeof (*pfcmd) + clen;
pfcmd = alloca(len);
if (server->fp != NULL) {
(void) fclose(server->fp);
server->fp = NULL;
}
pfcmd->cmd = PKG_FILTER;
pfcmd->len = clen;
if (filt != NULL)
(void) strcpy(pfcmd->buf, filt);
fd = -1;
if (pkgcmd(server, pfcmd, len, NULL, NULL, &fd) != 0 || fd == -1) {
progerr(gettext(ERR_START_FILTER));
return (-1);
}
(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
server->fp = fdopen(fd, "r");
if (server->fp == NULL) {
(void) close(fd);
progerr(gettext(ERR_START_FILTER));
return (-1);
}
return (0);
}
void
pkgclosefilter(PKGserver server)
{
if (server->fp != NULL) {
(void) fclose(server->fp);
server->fp = NULL;
}
}
/*
* Report the next entry from the contents file.
*/
char *
pkggetentry(PKGserver server, int *len, int *pathlen)
{
int num[2];
if (server->fp == NULL)
return (NULL);
if (feof(server->fp) || ferror(server->fp))
return (NULL);
if (fread(num, sizeof (int), 2, server->fp) != 2)
return (NULL);
if (num[0] > server->buflen) {
free(server->curbuf);
server->buflen = num[0];
server->curbuf = malloc(server->buflen);
if (server->curbuf == NULL)
return (NULL);
}
if (fread(server->curbuf, 1, num[0], server->fp) != num[0])
return (NULL);
*len = num[0];
*pathlen = num[1];
return (server->curbuf);
}
char *
pkggetentry_named(PKGserver server, const char *path, int *len, int *pathlen)
{
int plen = strlen(path);
pkgfilter_t *pcmd = alloca(sizeof (*pcmd) + plen);
char *result;
unsigned int rlen;
pcmd->cmd = PKG_FINDFILE;
*pathlen = pcmd->len = plen;
(void) memcpy(pcmd->buf, path, pcmd->len + 1);
result = server->curbuf;
rlen = server->buflen;
if (pkgcmd(server, pcmd, sizeof (*pcmd) + pcmd->len,
&result, &rlen, NULL) != 0) {
return (NULL);
}
if (rlen == 0)
return (NULL);
/* Result too big */
if (result != server->curbuf) {
free(server->curbuf);
server->buflen = rlen;
server->curbuf = malloc(server->buflen);
if (server->curbuf == NULL)
return (NULL);
(void) memcpy(server->curbuf, result, rlen);
(void) munmap(result, rlen);
}
*len = rlen;
return (server->curbuf);
}