#ifdef sccs
static char sccsid[] = "@(#)pcnfsd.c 1.4";
#endif
/*
* Copyright (c) 1986 by Sun Microsystems, Inc.
*/
/*
* pcnfsd.c
*
* pcnfsd is intended to remedy the lack of certain critical generic network
* services by providing an simple, customizable set of RPC-based
* mechanisms. For this reason, Sun Microsystems Inc. is distributing it
* in source form as part of the PC-NFS release.
*
* Background: The first NFS networks were composed of systems running
* derivatives of the 4.2BSD release of Unix (Sun's, VAXes, Goulds and
* Pyramids). The immediate utility of the resulting networks was derived
* not only from NFS but also from the availability of a number of TCP/IP
* based network services derived from 4.2BSD. Furthermore the thorny
* question of network-wide user authentication, while remaining a
* security hole, was solved at least in terms of a convenient usage model
* by the Yellow Pages distributed data base facility, which allows
* multiple Unix systems to refer to common password and group files.
*
* The PC-NFS Dilemma: When Sun Microsystems Inc. ported NFS to PC's, two
* things became apparent. First, the memory constraints of the typical PC
* meant that it would be impossible to incorporate the pervasive TCP/IP
* based service suite in a resident fashion. Indeed it was not at all
* clear that the 4.2BSD services would prove sufficient: with the advent
* of Unix System V and (experimental) VAX-VMS NFS implementations, we had
* to consider the existence of networks with no BSD-derived Unix hosts.
* The two key types of functionality we needed to provide were remote
* login and print spooling. The second critical issue was that of user
* authentication. Traditional time-sharing systems such as Unix and VMS
* have well- established user authentication mechanisms based upon user
* id's and passwords: by defining appropriate mappings, these could
* suffice for network-wide authentication provided that appropriate
* administrative procedures were enforced. The PC, however, is typically
* a single-user system, and the standard DOS operating environment
* provides no user authentication mechanisms. While this is acceptable
* within a single PC, it causes problems when attempting to connect to a
* heterogeneous network of systems in which access control, file space
* allocation, and print job accounting and routing may all be based upon
* a user's identity. The initial (and default) approach is to use the
* pseudo-identity 'nobody' defined as part of NFS to handle problems such
* as this. However, taking ease of use into consideration, it became
* necessary to provide a mechanism for establishing a user's identity.
*
* Initially we felt that we needed to implement two types of functionality:
* user authentication and print spooling. (Remote login is addressed by
* the Telnet module.) Since no network services were defined within the
* NFS architecture to support these, it was decided to implement them in
* a fairly portable fashion using Sun's Remote Procedure Call protocol.
* Since these mechanisms will need to be re-implemented ion a variety of
* software environments, we have tried to define a very general model.
*
* Authentication: NFS adopts the Unix model of using a pair of integers
* (uid, gid) to define a user's identity. This happens to map tolerably
* well onto the VMS system. 'pcnfsd' implements a Remote Procedure which
* is required to map a username and password into a (uid, gid) pair.
* Since we cannot predict what mapping is to be performed, and since we
* do not wish to pass clear-text passwords over the net, both the
* username and the password are mildly scrambled using a simple XOR
* operation. The intent is not to be secure (the present NFS architecture
* is inherently insecure) but to defeat "browsers".
*
* The authentication RPC will be invoked when the user enters the PC-NFS
* command:
*
* NET NAME user [password|*]
*
*
* Printing: The availability of NFS file operations simplifies the print
* spooling mechanisms. There are two services which 'pcnfsd' has to
* provide:
* pr_init: given the name of the client system, return the
* name of a directory which is exported via NFS and in which the client
* may create spool files.
* pr_start: given a file name, a user name, the printer name, the client
* system name and an option string, initiate printing of the file
* on the named printer. The file name is relative to the directory
* returned by pr_init. pr_start is to be "idempotent": a request to print
* a file which is already being printed has no effect.
*
* Intent: The first versions of these procedures are implementations for Sun
* 2.0/3.0 software, which will also run on VAX 4.2BSD systems. The intent
* is to build up a set of implementations for different architectures
* (Unix System V, VMS, etc.). Users are encouraged to submit their own
* variations for redistribution. If you need a particular variation which
* you don't see here, either code it yourself (and, hopefully, send it to
* us at Sun) or contact your Customer Support representative.
*/
#include <sys/types.h>
#include <stdio.h>
#ifdef OS2
#undef min
#include <stdlib.h>
#include <types.h>
#include <io.h>
#include <io.h>
#include <string.h>
#include <process.h>
#include <direct.h>
#define mkdir(p, m) mkdir(p)
#define INCL_DOS
#include <os2.h>
extern char *crypt(char *, char*);
#else
#include <sys/file.h>
#endif
#ifdef SHADOWPWD
#include <shadow.h>
#include <shadow/pwauth.h>
#else
#include <pwd.h>
#endif
#include <rpc/rpc.h>
#include <signal.h>
#include <sys/stat.h>
/* #define DEBUG 1 */
#ifdef DEBUG
int buggit = 0;
#endif
#ifdef OS2
# define LP_SPOOL "C:\\spool\\pcnfs"
# define LP_BIN "print.com"
# define DIRSEP "\\"
#else
# define LP_SPOOL "/usr/spool/lp"
# define LP_BIN "/usr/ucb/lpr"
# define DIRSEP "/"
#endif
/*
* *************** RPC parameters ********************
*/
#define PCNFSDPROG (long)150001
#define PCNFSDVERS (long)1
#define PCNFSD_AUTH (long)1
#define PCNFSD_PR_INIT (long)2
#define PCNFSD_PR_START (long)3
/*
* ************* Other #define's **********************
*/
#ifndef MAXPATHLEN
#define MAXPATHLEN 1024
#endif
#define zchar 0x5b
/*
* *********** XDR structures, etc. ********************
*/
enum arstat {
AUTH_RES_OK, AUTH_RES_FAKE, AUTH_RES_FAIL
};
enum pirstat {
PI_RES_OK, PI_RES_NO_SUCH_PRINTER, PI_RES_FAIL
};
enum psrstat {
PS_RES_OK, PS_RES_ALREADY, PS_RES_NULL, PS_RES_NO_FILE,
PS_RES_FAIL
};
struct auth_args {
char *aa_ident;
char *aa_password;
};
struct auth_results {
enum arstat ar_stat;
long ar_uid;
long ar_gid;
};
struct pr_init_args {
char *pia_client;
char *pia_printername;
};
struct pr_init_results {
enum pirstat pir_stat;
char *pir_spooldir;
};
struct pr_start_args {
char *psa_client;
char *psa_printername;
char *psa_username;
char *psa_filename; /* within the spooldir */
char *psa_options;
};
struct pr_start_results {
enum psrstat psr_stat;
};
/*
* ****************** Misc. ************************
*/
char *authproc();
char *pr_start();
char *pr_init();
struct stat statbuf;
char pathname[MAXPATHLEN];
char new_pathname[MAXPATHLEN];
char spoolname[MAXPATHLEN];
/*
* ************** Support procedures ***********************
*/
scramble(s1, s2)
char *s1;
char *s2;
{
while (*s1) {
*s2++ = (*s1 ^ zchar) & 0x7f;
s1++;
}
*s2 = 0;
}
free_child()
{
int pid;
int pstatus;
pid = wait(&pstatus); /* clear exit of child process */
#ifdef DEBUG
if (buggit || pstatus)
fprintf(stderr, "FREE_CHILD: process #%d exited with status 0X%x\r\n",
pid, pstatus);
#endif
return;
}
/*
* *************** XDR procedures *****************
*/
bool_t
xdr_auth_args(xdrs, aap)
XDR *xdrs;
struct auth_args *aap;
{
return (xdr_string(xdrs, &aap->aa_ident, 32) &&
xdr_string(xdrs, &aap->aa_password, 64));
}
bool_t
xdr_auth_results(xdrs, arp)
XDR *xdrs;
struct auth_results *arp;
{
return (xdr_enum(xdrs, (int *) &arp->ar_stat) &&
xdr_long(xdrs, &arp->ar_uid) &&
xdr_long(xdrs, &arp->ar_gid));
}
bool_t
xdr_pr_init_args(xdrs, aap)
XDR *xdrs;
struct pr_init_args *aap;
{
return (xdr_string(xdrs, &aap->pia_client, 64) &&
xdr_string(xdrs, &aap->pia_printername, 64));
}
bool_t
xdr_pr_init_results(xdrs, arp)
XDR *xdrs;
struct pr_init_results *arp;
{
return (xdr_enum(xdrs, (int *) &arp->pir_stat) &&
xdr_string(xdrs, &arp->pir_spooldir, 255));
}
bool_t
xdr_pr_start_args(xdrs, aap)
XDR *xdrs;
struct pr_start_args *aap;
{
return (xdr_string(xdrs, &aap->psa_client, 64) &&
xdr_string(xdrs, &aap->psa_printername, 64) &&
xdr_string(xdrs, &aap->psa_username, 64) &&
xdr_string(xdrs, &aap->psa_filename, 64) &&
xdr_string(xdrs, &aap->psa_options, 64));
}
bool_t
xdr_pr_start_results(xdrs, arp)
XDR *xdrs;
struct pr_start_results *arp;
{
return (xdr_enum(xdrs, (int *) &arp->psr_stat));
}
/*
* ********************** main *********************
*/
main(argc, argv)
int argc;
char **argv;
{
int f1, f2, f3;
extern xdr_string_array();
#ifdef OS2
if (argc < 2) {
strcpy(spoolname, LP_SPOOL);
spoolname[0] = 'A' - 1 + _getdrive();
}
#else
if (fork() == 0) {
if (argc < 2)
strcpy(spoolname, LP_SPOOL);
#endif
else
strcpy(spoolname, argv[1]);
#ifdef DEBUG
if (argc > 2)
buggit++;
#endif
if (stat(spoolname, &statbuf) || !(statbuf.st_mode & S_IFDIR)) {
fprintf(stderr,
"pcnfsd: invalid spool directory %s\r\n", spoolname);
exit(1);
}
/* Comment out for now
if ((f1 = open("/dev/null", O_RDONLY)) == -1) {
fprintf(stderr, "pcnfsd: couldn't open /dev/null\r\n");
exit(1);
}
if ((f2 = open("/dev/console", O_WRONLY)) == -1) {
fprintf(stderr, "pcnfsd: couldn't open /dev/console\r\n");
exit(1);
}
if ((f3 = open("/dev/console", O_WRONLY)) == -1) {
fprintf(stderr, "pcnfsd: couldn't open /dev/console\r\n");
exit(1);
}
dup2(f1, 0);
dup2(f2, 1);
dup2(f3, 2);
end of commented out stuff */
registerrpc(PCNFSDPROG, PCNFSDVERS, PCNFSD_AUTH, authproc,
xdr_auth_args, xdr_auth_results);
registerrpc(PCNFSDPROG, PCNFSDVERS, PCNFSD_PR_INIT, pr_init,
xdr_pr_init_args, xdr_pr_init_results);
registerrpc(PCNFSDPROG, PCNFSDVERS, PCNFSD_PR_START, pr_start,
xdr_pr_start_args, xdr_pr_start_results);
svc_run();
fprintf(stderr, "pcnfsd: error: svc_run returned\r\n");
exit(1);
#ifndef OS2
}
#endif
}
/*
* ******************* RPC procedures **************
*/
char *
authproc(a)
struct auth_args *a;
{
static struct auth_results r;
char username[32];
char password[64];
int c1, c2;
struct passwd *p;
#ifdef SHADOWPWD
struct spwd *spwd;
#endif
r.ar_stat = AUTH_RES_FAIL; /* assume failure */
scramble(a->aa_ident, username);
scramble(a->aa_password, password);
#ifdef DEBUG
if (buggit)
fprintf(stderr, "AUTHPROC username=%s\r\n", username);
#endif
p = getpwnam(username);
if (p == NULL)
return ((char *) &r);
#ifdef SHADOWPWD
if (!(spwd = getspnam(username)))
return ((char *) &r);
else
p->pw_passwd = spwd->sp_pwdp;
if (p->pw_name && p->pw_passwd[0] == '@') {
if (pw_auth(p->pw_passwd+1, username, PW_LOGIN))
return ((char *) &r);
} else {
if (!valid(password, p))
return ((char *) &r);
}
#else
c1 = strlen(password);
c2 = strlen(p->pw_passwd);
if ((c1 && !c2) || (c2 && !c1) ||
(strcmp(p->pw_passwd, crypt(password, p->pw_passwd)))) {
return ((char *) &r);
}
#endif
r.ar_stat = AUTH_RES_OK;
r.ar_uid = p->pw_uid;
r.ar_gid = p->pw_gid;
return ((char *) &r);
}
char *
pr_init(pi_arg)
struct pr_init_args *pi_arg;
{
int dir_mode = 0777;
static struct pr_init_results pi_res;
/* get pathname of current directory and return to client */
strcpy(pathname, spoolname); /* first the spool area */
strcat(pathname, DIRSEP); /* append a slash */
strcat(pathname, pi_arg->pia_client);
/* now the host name */
mkdir(pathname, dir_mode); /* ignore the return code */
if (stat(pathname, &statbuf) || !(statbuf.st_mode & S_IFDIR)) {
fprintf(stderr,
"pcnfsd: unable to create spool directory %s\r\n",
pathname);
pathname[0] = 0;/* null to tell client bad vibes */
pi_res.pir_stat = PI_RES_FAIL;
} else {
pi_res.pir_stat = PI_RES_OK;
}
pi_res.pir_spooldir = &pathname[0];
chmod(pathname, dir_mode);
#ifdef DEBUG
if (buggit)
fprintf(stderr, "PR_INIT pathname=%s\r\n", pathname);
#endif
return ((char *) &pi_res);
}
char *
pr_start(ps_arg)
struct pr_start_args *ps_arg;
{
static struct pr_start_results ps_res;
int pid;
int free_child();
char printer_opt[64];
char username_opt[64];
char clientname_opt[64];
struct passwd *p;
long rnum;
char snum[20];
int z;
#ifdef OS2
strcpy(printer_opt, "/D:");
/* Strangely, sometimes there are garbage characters after the eighth
* character. And since there can at most be eight, we truncate here. */
if (strlen(ps_arg->psa_filename) > 8)
ps_arg->psa_filename[8] = 0;
#else
strcpy(printer_opt, "-P");
#endif
strcpy(username_opt, "-J");
strcpy(clientname_opt, "-C");
#ifdef SIGCHLD
signal(SIGCHLD, free_child); /* when child terminates it sends */
#endif
/* a signal which we must get */
strcpy(pathname, spoolname); /* build filename */
strcat(pathname, DIRSEP);
strcat(pathname, ps_arg->psa_client); /* /spool/host */
strcat(pathname, DIRSEP); /* /spool/host/ */
strcat(pathname, ps_arg->psa_filename); /* /spool/host/file */
#ifdef DEBUG
if (buggit) {
fprintf(stderr, "PR_START pathname=%s\r\n", pathname);
fprintf(stderr, "PR_START username= %s\r\n", ps_arg->psa_username);
fprintf(stderr, "PR_START client= %s\r\n", ps_arg->psa_client);
}
#endif
strcat(printer_opt, ps_arg->psa_printername);
/* make it (e.g.) -Plw */
strcat(username_opt, ps_arg->psa_username);
/* make it (e.g.) -Jbilly */
strcat(clientname_opt, ps_arg->psa_client);
/* make it (e.g.) -Cmypc */
if (stat(pathname, &statbuf)) {
/*
* We can't stat the file. Let's try appending '.spl' and
* see if it's already in progress.
*/
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...can't stat it.\r\n");
#endif
strcat(pathname, ".spl");
if (stat(pathname, &statbuf)) {
/*
* It really doesn't exist.
*/
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...PR_START returns PS_RES_NO_FILE\r\n");
#endif
ps_res.psr_stat = PS_RES_NO_FILE;
return ((char *) &ps_res);
}
/*
* It is already on the way.
*/
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...PR_START returns PS_RES_ALREADY\r\n");
#endif
ps_res.psr_stat = PS_RES_ALREADY;
return ((char *) &ps_res);
}
if (statbuf.st_size == 0) {
/*
* Null file - don't print it, just kill it.
*/
unlink(pathname);
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...PR_START returns PS_RES_NULL\r\n");
#endif
ps_res.psr_stat = PS_RES_NULL;
return ((char *) &ps_res);
}
/*
* The file is real, has some data, and is not already going out.
* We rename it by appending '.spl' and exec "lpr" to do the
* actual work.
*/
strcpy(new_pathname, pathname);
strcat(new_pathname, ".spl");
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...renaming %s -> %s\r\n", pathname, new_pathname);
#endif
/*
* See if the new filename exists so as not to overwrite it.
*/
for(z = 0; z <100; z++) {
if (!stat(new_pathname, &statbuf)){
strcpy(new_pathname, pathname); /* rebuild a new name */
sprintf(snum,"%ld",random()); /* get some number */
strncat(new_pathname, snum, 3);
strcat(new_pathname, ".spl"); /* new spool file */
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...created new spl file -> %s\r\n", new_pathname);
#endif
} else
break;
}
z = rename(pathname, new_pathname);
#ifdef OS2
while (z && errno == EISOPEN) {
/* You can't rename an open file under OS/2, */
/* it may still be opened by the nfsd server. */
DosSleep(100); /* wait a little bit */
z = rename(pathname, new_pathname); /* and retry */
}
#endif
if (z) {
/*
* CAVEAT: Microsoft changed rename for Microsoft C V3.0.
* Check this if porting to Xenix.
*/
/*
* Should never happen.
*/
fprintf(stderr, "pcnfsd: spool file rename (%s->%s) failed.\r\n",
pathname, new_pathname);
ps_res.psr_stat = PS_RES_FAIL;
return ((char *) &ps_res);
}
#ifdef OS2
pid = spawnlp(P_WAIT, LP_BIN, LP_BIN, printer_opt, new_pathname, 0);
if (pid < 0) {
perror("pcnfsd: spawn print failed");
} else {
unlink(new_pathname);
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...spawned child, result = %d\r\n", pid);
#endif
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...PR_START returns PS_RES_OK\r\n");
#endif
ps_res.psr_stat = PS_RES_OK;
return ((char *) &ps_res);
}
#else /* !OS2 */
pid = fork();
if (pid == 0) {
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...print options =%s\r\n", ps_arg->psa_options);
#endif
if (ps_arg->psa_options[1] == 'd') {
/*
* This is a Diablo print stream. Apply the ps630
* filter with the appropriate arguments.
*/
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...run_ps630 invoked\r\n");
#endif
run_ps630(new_pathname, ps_arg->psa_options);
}
execlp(LP_BIN,
"lpr",
"-s",
"-r",
printer_opt,
username_opt,
clientname_opt,
new_pathname,
0);
perror("pcnfsd: exec lpr failed");
exit(0); /* end of child process */
} else if (pid == -1) {
perror("pcnfsd: fork failed");
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...PR_START returns PS_RES_FAIL\r\n");
#endif
ps_res.psr_stat = PS_RES_FAIL;
return ((char *) &ps_res);
} else {
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...forked child #%d\r\n", pid);
#endif
#ifdef DEBUG
if (buggit)
fprintf(stderr, "...PR_START returns PS_RES_OK\r\n");
#endif
ps_res.psr_stat = PS_RES_OK;
return ((char *) &ps_res);
}
#endif /* OS2 */
}
char *
mapfont(f, i, b)
char f;
char i;
char b;
{
static char fontname[64];
fontname[0] = 0; /* clear it out */
switch (f) {
case 'c':
strcpy(fontname, "Courier");
break;
case 'h':
strcpy(fontname, "Helvetica");
break;
case 't':
strcpy(fontname, "Times");
break;
default:
strcpy(fontname, "Times-Roman");
goto exit;
}
if (i != 'o' && b != 'b') { /* no bold or oblique */
if (f == 't') /* special case Times */
strcat(fontname, "-Roman");
goto exit;
}
strcat(fontname, "-");
if (b == 'b')
strcat(fontname, "Bold");
if (i == 'o') /* o-blique */
strcat(fontname, f == 't' ? "Italic" : "Oblique");
exit: return (&fontname[0]);
}
/*
* run_ps630 performs the Diablo 630 emulation filtering process. ps630 is
* currently broken in the Sun release: it will not accept point size or
* font changes. If your version is fixed, define the symbol
* PS630_IS_FIXED and rebuild pcnfsd.
*/
run_ps630(file, options)
char *file;
char *options;
{
char tmpfile[256];
char commbuf[256];
int i;
strcpy(tmpfile, file);
strcat(tmpfile, "X"); /* intermediate file name */
#ifdef PS630_IS_FIXED
sprintf(commbuf, "ps630 -s %c%c -p %s -f ",
options[2], options[3], tmpfile);
strcat(commbuf, mapfont(options[4], options[5], options[6]));
strcat(commbuf, " -F ");
strcat(commbuf, mapfont(options[7], options[8], options[9]));
strcat(commbuf, " ");
strcat(commbuf, file);
#else
/*
* The pitch and font features of ps630 appear to be broken at
* this time. If you think it's been fixed at your site, define
* the compile-time symbol `ps630_is_fixed'.
*/
sprintf(commbuf, "/usr/local/bin/ps630 -p %s %s", tmpfile, file);
#endif
if (i = system(commbuf)) {
/*
* Under (un)certain conditions, ps630 may return -1
* even if it worked. Hence the commenting out of this
* error report.
*/
/* fprintf(stderr, "\r\n\nrun_ps630 rc = %d\r\n", i) */ ;
/* exit(1); */
}
if (rename(tmpfile, file)) {
perror("run_ps630: rename");
exit(1);
}
}
