/********************************************************************
* wilkinson
* 3.6VMS
* 1995/09/25 14:35
* gopher_root1:[gopher.g2.vms2_13.gopherd]openers.c,v
* Exp
*
* Paul Lindner, University of Minnesota CIS.
*
* Copyright 1991, 1992 by the Regents of the University of Minnesota
* see the file "Copyright" in the distribution for conditions of use.
*********************************************************************
* MODULE: openers.c
* See below
*********************************************************************
* Revision History:
* openers.c,v
* Revision 3.6VMS 1995/09/25 14:35    wilkinson
* Consolodate VMS/Unix source code for server as well as client
*
* Revision 3.6  1995/02/07  07:02:46  lindner
* performance fixes
*
* Revision 3.5  1993/09/18  03:26:17  lindner
* Important Security fix
*
* Revision 3.4  1993/07/27  05:27:54  lindner
* Mondo Debug overhaul from Mitra
*
* Revision 3.3  1993/04/09  16:23:12  lindner
* Additional debug stuff
*
* Revision 3.2  1993/02/19  21:22:05  lindner
* Fixed problems with non-chroot() use
*
* Revision 3.1.1.1  1993/02/11  18:02:52  lindner
* Gopher+1.2beta release
*
* Revision 1.2  1993/01/30  23:57:44  lindner
* Fixes so that opening a file doesn't depend on what the current
* directory is.
*
* Revision 1.1  1992/12/10  23:13:27  lindner
* gopher 1.1 release
*
*
*********************************************************************/



/*
* Routines that implement safe "openers" so that we can do without
* the chroot().  This is an advantage because then you can have
* symbolic links from your gopher server directory to other files
* that are elsewhere on your system, without (if we've done this right)
* compromising your security, or allowing access to any files that
* you don't want made available.
*
* The "r" in the names is meant to indicate "restricted".
* The "u" in the names is meant to indicate "unrestricted".
*/

#include "gopherd.h"
#include "Debug.h"

#ifndef VMS_SERVER
#include <sys/param.h>  /* for MAXPATHLEN */
#else
#ifdef MAXPATHLEN
#undef MAXPATHLEN
#endif
#define MAXPATHLEN  512
#endif

/* and restore our real names */
#undef open
#undef fopen
#undef stat
#undef opendir
#undef chdir

#ifdef VMS_SERVER
#define opendir(a) VMS$Wild_Search(a)
#endif

char    *fixfile();

int
ropen( path, flags, mode )
char *path;
int flags, mode;
{
    char *p;
    p = fixfile(path);
    if (p != NULL)
         return( open( p, flags, mode ) );
    return(-1);        /* failed */
}


FILE *
rfopen( filename, type )
char *filename, *type;
{
    char *p;
    p = fixfile(filename);
    if (p != NULL)
         return( fopen( p, type ) );
    return(NULL);      /* failed */
}


int
rstat( path, buf )
char *path;
struct stat *buf;
{
    char *p;
    p = fixfile(path);
    if (p != NULL)
         return( stat( p, buf ) );
    return(-1);        /* failed */
}


DIR *
ropendir( dirname )
char *dirname;
{
    char *p;
    p = fixfile(dirname);
    if (p != NULL)
         return( opendir( p ) );
    return(NULL);      /* failed */
}


/*
* Restricted chdir.
*
* Change to Data_Dir first if it's an absolute path,
* then do a relative chdir from there....
*/

int
rchdir( path )
char *path;
{
    char *p;
#ifdef VMS_SERVER
    if (strcmp(path,"/")==0)
       path = GDCgetDatadir(Config);
#endif
    p = fixfile(path);

    Debug("Changing to directory %s\n", p);
    return( chdir( p ) );
}


int
uopen( path, flags, mode )
char *path;
int flags, mode;
{
    return( open( path, flags, mode ) );
}


FILE *
ufopen( filename, type )
char *filename, *type;
{
    return( fopen( filename, type ) );
}


int
ustat( path, buf )
char *path;
struct stat *buf;
{
    return( stat( path, buf ) );
}


DIR *
uopendir( dirname )
char *dirname;
{
    return( opendir( dirname ) );
}


int
uchdir( path )
char *path;
{
#ifdef VMS_SERVER
    if (strcmp(path,"/")==0)
       path = GDCgetDatadir(Config);
#endif
    Debug("Changing to directory %s\n", path);
    return( chdir( path ) );
}


/* Make sure the pathname they gave us is safe and secure for use */

char *
fixfile(name)
char *name;
{
#ifndef VMS_SERVER
    char newpathbuf[MAXPATHLEN];
    char *newpath;

    newpath = &newpathbuf[0];

    if (!dochroot) {
         strcpy(newpath, Data_Dir);

         newpath += strlen(Data_Dir);
    }
    else {
         strcpy(newpath, "/");
    }
    /* set errno to EPERM in case we reject the request */
    errno = EPERM;

    /*
    ** rip any .. or . entries out, so they can't sneak up out of
    ** the gopher directory.  Need to use dedot2() so we don't clobber
    ** the string they sent us originally.
    */
    dedot2(name,newpath);
    if (*newpath == '/' || *newpath == '\0')
         return(newpathbuf);
    else
         return(newpath);
#else
   return(name);
#endif
}

#ifdef VMS_SERVER

/**********************
*   Emulate functionality of ropendir() and readdir() for VMS wildcarded search
*/
char *

VMS$Wild_Search(char *path)
{
    static struct FAB   wild_fab;  /* Used in wildcard search              */
    static struct NAM   wild_nam;  /* Used in conjunction with wild_fab    */
    static char fullname[256];     /* ropendir() input, readdir() output   */
    static char expanded[256];     /* filespec after logical expansion     */
    static char result[256];       /* result from search                   */
    register    status;
    char *cp;

/* Validate path, initialize for wildcarded search of directory */

    if (path) {                    /* opendir() emulation      */
       wild_fab = cc$rms_fab;
       wild_nam = cc$rms_nam;
       wild_fab.fab$b_fac = FAB$M_GET;
       wild_fab.fab$l_fop = FAB$V_NAM;
       wild_fab.fab$l_nam = &wild_nam;
       wild_fab.fab$l_dna = "*.*";
       wild_fab.fab$b_dns = strlen(wild_fab.fab$l_dna);
       wild_nam.nam$l_esa = expanded;
       wild_nam.nam$l_rsa = result;
       wild_nam.nam$b_ess = wild_nam.nam$b_rss = 255;
       wild_fab.fab$l_fna = fullname;
       wild_fab.fab$b_fns = fullname[0] = expanded[0] = result[0] = 0;


       if (((status = SYS$PARSE(&wild_fab)) &1) != 1) {
           LOGGopher(-1,"Error on parse of pathname %s, %s",path,
                                                   STRerror(errno));
           return(NULL);
       }
       return(fullname);
    }

/* Get next directory entry */          /* readdir() emulation  */

    if ((( status = SYS$SEARCH(&wild_fab)) &1) != 1) {
       if ( (status == RMS$_NMF) || (status == RMS$_FNF) )
          return(NULL);
       LOGGopher(-1,"Error on search next, %s",STRerror(errno));
       return(NULL);
    }

    fullname[0] = expanded[wild_nam.nam$b_esl]
                       = result[wild_nam.nam$b_rsl] = '\0';
    strcpy(fullname, (char*)strchr(result,']') + 1);
    *((char *)strchr(fullname,';')) = '\0';
    return(fullname);
}
#endif

You are viewing proxied material from bitreich.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.