archie/prospero/lib/psrv/dsrobject.c

/*
 * Copyright (c) 1993 by the University of Southern California
 *
 * For copying and distribution information, please see the file
 * <usc-license.h>.
 */

#include <usc-license.h>

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pmachine.h>
#ifndef SOLARIS                 /* if not posix, need MAXPATHLEN still */
#include <sys/param.h>
#endif

#include <pserver.h>		/* For DIRECTORYCACHING and for PLOG
                                   overrides. */ 
#include <pfs.h>
#include <perrno.h>
#include <psrv.h>
#include <plog.h>

#ifdef DSROBJECT_SPEEDUP_IS_EXPERIMENTAL
int dsrobject_speedup = 1;      /* speed up DSROBJECT.  This can be set to 0 to
                                   use the old code.  These changes made by SWA
                                   during the week of 5/9/94 */
#endif


static PATTRIB newamat(void);

#ifdef DIRECTORYCACHING

/* One day */
#define SECONDSPERDAY	(60*60*24)
#define MAXDIRCACHEAGE	(1*SECONDSPERDAY)
int cache_attempt = 0; int cache_can = 0; int cache_yes = 0; 
/* Used to see how many times dsrobject() failed in a retrieval request. */
int dsrobject_fail = 0;

int 
vdir_outofdate(VDIR dir, char *hsoname) 
{
    char native_dirname[MAXPATHLEN];
    char vfs_dirname[MAXPATHLEN];

    nativize_prefix(hsoname, native_dirname, sizeof native_dirname);
    strcpy(vfs_dirname,shadow);  
    strcat(vfs_dirname,native_dirname);
    strcat(vfs_dirname,"/");
    strcat(vfs_dirname,dircont);

    return (stat_age(vfs_dirname) > MAXDIRCACHEAGE);
}
#endif /*DIRECTORYCACHING */
/* Union links are expanded at a higher level.
 * The only message dsrobject() sends to the client is an ardp_rwait().
 * dsrobject() logs NOT-AUTHORIZED failures via plog, but doesn't send messages
 to the client; the caller does that.
 * Checks to make sure hsoname is within the space we're allowed to discuss.
 * Does check to make sure you have r, G, or g rights on a database before it 
 lets you scan that database for information.
 */
 
/* flags honored::
   DRO_VERIFY_DIR
   
*/
/*
  Returns:
  DSRFINFO_FORWARDED
  DIRSRV_NOT_AUTHORIZED
  DIRSRV_NOT_FOUND
  PFAILURE
  PSUCCESS
*/
/* If called with the DRO_VERIFY flag, will set the P_OBJECT_FILE and
   P_OBJECT_DIRECTORY flags in the ob structure, but will not *necessarily* put
   any other information into the ob structure.  Caller is still responsible
   for freeing any links pointed to by the ob structure. */ 

/* If called with the DRO_VERIFY_DIR flag, will return PSUCCESS only if object
   is a directory. Will not necessarily put any other information into the OB
   structure.  Caller is still responsible for freeing any links pointed to by
   the ob structure. */

/* dsrobject(), if it returns anything other than DSRFINFO_FORWARDED or
   PSUCCESS, may leave the ob structure with arbitrary data in it.  The caller
   should not expect the ob structure to remain untouched. */ 

/* At the moment, the only option we look at in dsrobject_list_options is the
   requested_attributes one, and that only to test for the CONTENTS
   attribute. */

/* The database ACL itself may be obtained by using an HSONAME that is just the
   root prefix of the database. */
   
int requested_contents(struct dsrobject_list_options *listopts);
PATTRIB read_contents(char hsoname[]);

int
dsrobject(RREQ req, char hsoname_type[], char hsoname[], long version, 
          long magic_no,  
          int flags, struct dsrobject_list_options *listopts, P_OBJECT ob)
{
    VDIR_ST dir_st;
    register VDIR dir = &dir_st;
    register PFILE fi = NULL;            /*  Only set if it needs to be. */
    int     retval;             /* Integer return value from subfunctions */
    int     dirretval = PFAILURE; 	/* Save initial dsrdir result*/
#ifdef DIRECTORYCACHING
    int	    cancache = TRUE;
#endif

#ifdef DSROBJECT_SPEEDUP_IS_EXPERIMENTAL
    if (!dsrobject_speedup)
        flags &= ~DRO_VERIFY;   /* if not speedup, turn off DRO_VERIFY flag. */
#endif
    VLDEBUGBEGIN;
    vdir_init(dir);             /* empty directory. */
    set_client_addr(req->peer_addr.s_addr); /* temporary hack. */

    /* Check whether HSONAME-TYPE and HSONAME are valid. */
    if (!strequal(hsoname_type, "ASCII")) {
	plog(L_DIR_ERR, req, "dsrobject(): got invalid hsoname-type: %s",
             hsoname_type, 0);
	vdir_freelinks(dir);
	RETURNPFAILURE;
    }
    if (check_handle(hsoname) == FALSE) {
	plog(L_AUTH_ERR, req, "Got an HSONAME outside the part of the \
filesystem that this server is authorized to publish information about: %s", 
             hsoname);
    /* Free the directory links */
	vdir_freelinks(dir);
	return DIRSRV_NOT_AUTHORIZED;
    }

    if ( *hsoname != '/') {	
	/* Database or special prefix in use */
        register int i;
#ifdef DIRECTORYCACHING         /* mitracode */
	cache_attempt++;
        /* SWA bug fix: this assumes listopts is always set, which it need not
           be. */ 
	/* mitra: Can not cache if specifying a component (other than"*") */
        /* swa added: Can not cache if #ALL attributes not set.  This prevents
           us from blowing it badly. */

	if (!listopts 
            || (listopts->thiscompp && strcmp(*(listopts->thiscompp),"*"))
            || !listopts->req_link_ats.all)
            cancache = FALSE;
	if (cancache) {
            cache_can++;
            VLDEBUGBEGIN;
            if (!(dirretval 
                  = dsrdir(hsoname, magic_no, dir, NULL, DSRD_ATTRIBUTES)))
                cache_yes++;
            VLDEBUGDIR(dir);
            VLDEBUGEND;
	}
	   
#endif
	if (dirretval != PSUCCESS 
#ifdef DIRECTORYCACHING
	    || vdir_outofdate(dir,hsoname) 
#endif
	    || !(dir->links) ) {
            for (i = 0; i < db_num_ents; i++) {
                if (strnequal(hsoname, db_prefixes[i].prefix,
                              strlen(db_prefixes[i].prefix))
                    && strequal(db_prefixes[i].hsoname_type, hsoname_type)) {
                    ACL dbacl;
                    
                    VLDEBUGBEGIN;
                    get_named_acl(db_prefixes[i].named_acl, &dbacl);
                    VLDEBUGEND;
                    if (dbacl
                        && !srv_check_acl(dbacl, NULL, req, "r",
                                          SCA_LINKDIR,db_prefixes[i].prefix,NULL)
                        && !srv_check_acl(dbacl, NULL, req, "g",
                                          SCA_LINKDIR,db_prefixes[i].prefix,NULL)
                        && !srv_check_acl(dbacl, NULL, req, "G",
                                          SCA_LINKDIR,db_prefixes[i].prefix,NULL)) {
                        plog(L_AUTH_ERR, req, 
                             "Unauthorized database request: %s %s",
                             hsoname, listopts? *(listopts->thiscompp) : "");
                        vdir_freelinks(dir);
                        return DIRSRV_NOT_AUTHORIZED;
                    }
                    /* This could take a while, tell client not to retry.
                     This should be customized on a per-database basis. */
                    ardp_rwait(req, 180, 0, 0);
                    VLDEBUGBEGIN;
                    retval= db_prefixes[i].read_function(req, hsoname, 
                                                         version, magic_no, flags, listopts, ob);
                    VLDEBUGOB(ob);
                    VLDEBUGEND;
#ifdef DIRECTORYCACHING
                    if (retval == PSUCCESS && ob->links) {
                        if (cancache) {
                            VLDEBUGBEGIN;
                            dswobject(hsoname_type,hsoname,ob);
                            VLDEBUGEND;
                        }
                        vdir_freelinks(dir);
			return(retval);
                    } else if (dirretval == PSUCCESS) { 
                        /* Must just have been old*/
                        /*drop through and reread dir and file*/
			break;
                    } else { /* Neither old nor new version available */
			/* Or directory is really empty */
                        vdir_freelinks(dir);
                        return(retval);
                    }
#else
                    vdir_freelinks(dir);
                    return retval;
#endif /*DIRECTORYCACHING*/
                }
            } /*for*/
        } /*PSUCCESS*/
        /* Here we have a prefix that is not a database, */
        /* but not a normal filename either */
        /* If normal file names need not begin with /    */
        /* fall through and try a normal query           */
    }
    /* Local directories can have associated finfo too. */
    if (dirretval == PSUCCESS) { /* No need to reread if did already */
	retval = dirretval;
    } else {
      VLDEBUGBEGIN;
        retval = dsrdir(hsoname, magic_no, dir, NULL, 
                        /* Set DSRD_VERIFY_DIR iff DRO_VERIFY_DIR is set. */
                        ((flags & DRO_VERIFY_DIR) ? DSRD_VERIFY_DIR : 0)
                        /* Note that dsrdir() curently always returns all
                           object attributes.  This costs us some potentially
                           unnecessary MALLOC()s. */
                        | ((listopts && listopts->requested_attrs) ?
                           DSRD_ATTRIBUTES : 0));
      VLDEBUGDIR(dir);
      VLDEBUGEND;
    }
    if (retval == PSUCCESS) ob->flags |= P_OBJECT_DIRECTORY;
    if (retval == PSUCCESS || retval == DSRDIR_NOT_A_DIRECTORY ||
        retval == DIRSRV_NOT_DIRECTORY || retval == DIRSRV_NOT_FOUND) {
        int dsrfinfo_retval;

#ifdef SERVER_DO_NOT_SUPPORT_FORWARDING
        /* Don't bother with the dsrfinfo() unless a specific attribute or set
           of attributes was requested, or unless a directory was not found. */
        if (listopts->req_obj_ats.all  
            || listopts->req_obj_ats.interesting
            || listopts->req_obj_ats.specific) {
            fi = pfalloc();
            dsrfinfo_retval = dsrfinfo_with_attribs(hsoname, magic_no, fi, 
                                                    &listopts->req_obj_ats);
        } else {
            dsrfinfo_retval = PFAILURE;
        }
#else
	VLDEBUGBEGIN;
        dsrfinfo_retval = dsrfinfo(hsoname,magic_no,fi);
	VLDEBUGFI(fi);
	VLDEBUGEND;
        if (dsrfinfo_retval == DSRFINFO_FORWARDED) {
            ob->inc_native = VDIN_MUNGED;
            ob->forward = fi->forward; fi->forward = NULL;
            pffree(fi);
            vdir_freelinks(dir);
            return dsrfinfo_retval;
        }
#endif
        if (dsrfinfo_retval < 0) {       /* dsrfinfo returns <0 to mean
                                            directory */ 
            ob->flags |= P_OBJECT_DIRECTORY;
            retval = PSUCCESS;
        } else if (dsrfinfo_retval == PSUCCESS) {
            ob->flags |= P_OBJECT_FILE;
            if (requested_contents(listopts)) {
                PATTRIB at = read_contents(hsoname);
                /* Append it to fi->attributes since ob->attributes will get
                   set from that. */
                if (at) APPEND_ITEM(at, fi->attributes);
            }
            retval = PSUCCESS;
        }
    }

#ifndef SERVER_DO_NOT_SUPPORT_FORWARDING
    if (retval == DSRFINFO_FORWARDED) {
        /* Only get here if dsrdir() or dsdb() returned DSRFINFO_FORWARDED */
        ob->inc_native = VDIN_MUNGED;
        ob->forward = dir->f_info->forward; dir->f_info->forward = NULL;
        vdir_freelinks(dir);
        return retval;
    }
#endif
    if (retval) {
        vdir_freelinks(dir);
        if (fi) pffree(fi);
        if (retval == DIRSRV_NOT_DIRECTORY || retval == DSRDIR_NOT_A_DIRECTORY
            || retval == DSRFINFO_NOT_A_FILE)
            return DIRSRV_NOT_FOUND;
        return retval;
    }
    /* Now for some manly calisthenics! 
       Merge f_info and directory info. */
    /* Note this is the model for the VERSION5 version dswobject
       so, if you change this, probably need to change that - Mitra */
    /* Only potential conflict here: ACL.  Handle it by appending the two
       ACLs if both are set. (DIRECTORY first; why not).  If one is unset,
       use the default (DEFAULT SYSTEM for DIRECTORY, CONTAINER for OBJECT).
       If directory and object both have magic numbers set use one from
       directory. 
       */
    if (ob->flags & P_OBJECT_DIRECTORY) {
        ob->version = dir->version;            /* always 0 */
        ob->inc_native = dir->inc_native;
        ob->magic_no = dir->magic_no;
        ob->acl = dir->dacl; dir->dacl = NULL;
        assert(!dir->f_info);   /* should have already been handled */
        ob->links = dir->links; dir->links = NULL;
        ob->ulinks = dir->ulinks; dir->ulinks = NULL;
        ob->native_mtime = dir->native_mtime;
    } else {
        ob->inc_native = VDIN_NOTDIR;
    }
    /* If FINFO present (will not always need to be present), merge it in. */
    if (fi) {
        /* Magic # on directory, if present, supersedes magic # on finfo. */
        if (!ob->magic_no) ob->magic_no = fi->f_magic_no;
        /* Append object ACLs. */
        if (fi->oacl) {
            CONCATENATE_LISTS(ob->acl, fi->oacl); fi->oacl = NULL;
        }
        ob->exp = fi->exp;
        ob->ttl = fi->ttl;
        ob->last_ref = fi->last_ref;
        ob->forward = fi->forward; fi->forward = NULL;
        ob->backlinks = fi->backlinks; fi->backlinks = NULL;
        ob->attributes = fi->attributes; fi->attributes = NULL;
        /* Done merging in attributes from FINFO structure. */
    }

    /* Clean up and return. */
    vdir_freelinks(dir);
    if (fi) pffree(fi); fi = NULL;
    VLDEBUGOB(ob);
    VLDEBUGEND;
    return retval;
}

/* Return a list of OBJECT INTRINSIC ACCESS-METHOD attributes for the local
   real file FILENAME.  These attributes should be usable by the client coming
   from the address client_addr.    One day this function will no longer be
   necessary when we have the Prospero access method working.
   Allocates pattribs and puts them into RETVAL. 

   Note that FILENAME has already been expanded from any HSONAME.  
*/

/* Called by dsrfinfo at the moment. */
void
get_access_method(char filename[], long client_addr, PATTRIB *retval)
{
    PATTRIB at;                 /* temporary working attribute. */
    TOKEN           nfs_am;     /* Access method for NFS (if any) */

    *retval = NULL;              /* return list starts empty. */

    /* Check for PROSPERO-CONTENTS access method */
    /* Always true for any local file. */
    at = newamat();
    at->value.sequence = tkappend("PROSPERO-CONTENTS", at->value.sequence);
    at->value.sequence = tkappend("", at->value.sequence);
    at->value.sequence = tkappend("", at->value.sequence);
    at->value.sequence = tkappend("", at->value.sequence);
    at->value.sequence = tkappend("", at->value.sequence);
    APPEND_ITEM(at, *retval);

    
    /* Check for LOCAL access method. */
    if (myaddress() == client_addr ||
        /* Check for loopback net.  */
#if BYTE_ORDER == BIG_ENDIAN
        (client_addr & 0xff000000) == (127 << 24)
#else
        (client_addr & 0x000000ff) == 127
#endif
        ) {
        /* This may not return information for multi-homed hosts.
           But it will never return incorrect information.  */
        at = newamat();
        at->value.sequence = tkappend("LOCAL", at->value.sequence);
        at->value.sequence = tkappend("", at->value.sequence);
        at->value.sequence = tkappend("", at->value.sequence);
        at->value.sequence = tkappend("", at->value.sequence);
        at->value.sequence = tkappend("", at->value.sequence);
        APPEND_ITEM(at, *retval);
    } else {
#ifdef SHARED_PREFIXES
        char *cp;      /* this memory doesn't need to be freed. */
        if (cp = check_localpath(filename, client_addr)){
            at = newamat();
            at->value.sequence = tkappend("LOCAL", at->value.sequence);
            at->value.sequence = tkappend("", at->value.sequence);
            at->value.sequence = tkappend("", at->value.sequence);
            at->value.sequence = tkappend("", at->value.sequence);
            at->value.sequence = tkappend(cp, at->value.sequence);
            APPEND_ITEM(at, *retval);
        }
#endif            
    }

    /* Check for NFS access method. */
#ifdef NFS_EXPORT
    if(nfs_am = check_nfs(filename,client_addr)) {
        at = newamat();
        at->value.sequence = nfs_am;
        APPEND_ITEM(at, *retval);
    }
#endif NFS_EXPORT

    /* Check for AFS access method.  Note that the hostname is irrelevant. */
    if(*afsdir && strnequal(filename, afsdir, strlen(afsdir))) {
        char *suffix = filename + strlen(afsdir);
        at = newamat();
        at->value.sequence = tkappend("AFS", at->value.sequence);
        at->value.sequence = tkappend("", at->value.sequence);
        at->value.sequence = tkappend("", at->value.sequence);
        at->value.sequence = tkappend("ASCII", at->value.sequence);
        at->value.sequence = tkappend(suffix, at->value.sequence);
        APPEND_ITEM(at, *retval);

#ifdef AFS_AFTP_GATEWAY         /* provide additional access method for sites
                                   that don't run AFS. */
        at = newamat();
        at->value.sequence = tkappend("AFTP", at->value.sequence);
        at->value.sequence = tkappend("INTERNET-D", at->value.sequence);
        at->value.sequence = tkappend(hostname, at->value.sequence);
        at->value.sequence = tkappend("ASCII", at->value.sequence);
        at->value.sequence = 
            tkappend(qsprintf_stcopyr((char *) NULL,
                                      "%s%s", AFS_AFTP_GATEWAY, suffix), 
                     at->value.sequence);
        at->value.sequence = tkappend("BINARY", at->value.sequence);
        APPEND_ITEM(at, *retval);
#endif
    }

    /* Check for AFTP access method. */
    if(*aftpdir && strnequal(filename,aftpdir, strlen(aftpdir))) {
        char *suffix = filename + strlen(aftpdir);

        at = newamat();
        at->value.sequence = tkappend("AFTP", at->value.sequence);
        at->value.sequence = tkappend("INTERNET-D", at->value.sequence);
        at->value.sequence = tkappend(hostname, at->value.sequence);
        at->value.sequence = tkappend("ASCII", at->value.sequence);
        at->value.sequence = tkappend(suffix, at->value.sequence);
        at->value.sequence = tkappend("BINARY", at->value.sequence);
        APPEND_ITEM(at, *retval);
    }
}


/* Allocate a new ACCESS-METHOD attribute. */
static 
PATTRIB
newamat(void)
{
    PATTRIB retval = atalloc();
    retval->aname = stcopyr("ACCESS-METHOD", retval->aname);
    retval->precedence = ATR_PREC_OBJECT;
    retval->nature = ATR_NATURE_INTRINSIC;
    retval->avtype = ATR_SEQUENCE;
    return retval;
}


/* Was the CONTENTS attribute requested on the object itself?  CONTENTS is an
   INTRINSIC- attribute.  Return non-zero (C language "true") if true, zero (C
   language "false") if false. */
int 
requested_contents(struct dsrobject_list_options *listopts)
{
    return listopts 
        && was_attribute_requested("CONTENTS", &listopts->req_obj_ats);
}


/* Return the CONTENTS attribute. */
PATTRIB 
read_contents(char hsoname[])
{
    char *filename;
    PATTRIB retval;
    int fd;                     /* file descriptor to read from. */
    struct stat file_stat_st;
    struct stat * file_stat = &file_stat_st;
    TOKEN tk;                   /* working token */

    /* Code modified from dsrfinfo() */
    /* Expand special file names */
    if((*hsoname != '/') && *aftpdir && strnequal(hsoname,"AFTP",4))
        filename = qsprintf_stcopyr("%s%s", aftpdir, hsoname + 4);
    else 
        filename = stcopy(hsoname);

    fd = open(filename, 0);     /* open for reading */
    if (fd < 0) {
        stfree(filename);
        return NULL;
    }
    if (stat(filename,file_stat) != 0) {
        close(fd);
        stfree(filename);
        return NULL;
    }

    retval = atalloc();
    retval->aname = stcopyr("CONTENTS", retval->aname);
    retval->precedence = ATR_PREC_OBJECT;
    retval->nature = ATR_NATURE_INTRINSIC;
    retval->avtype = ATR_SEQUENCE;
    /* Build a two-element sequence, DATA and a byte stream of the data. */
    retval->value.sequence = tkappend("DATA", retval->value.sequence);

    tk = tkalloc(NULL);
    /* allocate one extra space for the trailing null. */
    tk->token = stalloc(file_stat->st_size + 1);
    /* tk->token is the buffer we fill in.  It remains a valid reference even
       after the APPEND_ITEM.   We call APPEND_ITEM() first so that it's easy
       to abort in case of an error (one less freeing operation to call). */
    APPEND_ITEM(tk, retval->value.sequence);

    /* Read whole contents and close the file.  If either fails, don't set the
       CONTENTS attribute. */
    /* This might fail IF the file size changes between the stat() and the
       read.  Oh well.  */
    if(read(fd, tk->token, file_stat->st_size) != file_stat->st_size  
       || close(fd)) {
        atfree(retval);
        close(fd);
        return NULL;
    }
    p_bst_set_buffer_length_nullterm(tk->token, file_stat->st_size);
    /* Automatically null terminates it for us too. */
    return retval;
}