556 lines
21 KiB
C
556 lines
21 KiB
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;
|
|
}
|