loncom/lonnet/perl/lonnet.pm - diff

Return to lonnet.pm CVS log

Up to [LON-CAPA] / loncom / lonnet / perl

Diff for /loncom/lonnet/perl/lonnet.pm between versions 1.100 and 1.133

version 1.100, 2001/01/19 21:37:39	version 1.133, 2001/07/26 21:40:27
Line 3	Line 3
#	#
# Functions for use by content handlers:	# Functions for use by content handlers:
#	#
	# metadata_query(sql-query-string,custom-metadata-regex) :
	# returns file handle of where sql and
	# regex results will be stored for query
# plaintext(short) : plain text explanation of short term	# plaintext(short) : plain text explanation of short term
# fileembstyle(ext) : embed style in page for file extension	# fileembstyle(ext) : embed style in page for file extension
# filedescription(ext) : descriptor text for file extension	# filedescription(ext) : descriptor text for file extension
Line 13	Line 16
# 1: user needs to choose course	# 1: user needs to choose course
# 2: browse allowed	# 2: browse allowed
# definerole(rolename,sys,dom,cou) : define a custom role rolename	# definerole(rolename,sys,dom,cou) : define a custom role rolename
# set priviledges in format of lonTabs/roles.tab for	# set privileges in format of lonTabs/roles.tab for
# system, domain and course level,	# system, domain and course level,
# assignrole(udom,uname,url,role,end,start) : give a role to a user for the	# assignrole(udom,uname,url,role,end,start) : give a role to a user for the
# level given by url. Optional start and end dates	# level given by url. Optional start and end dates
Line 25	Line 28
# revokecustomrole (udom,uname,url,rdom,rnam,rolename) : Revoke a custom role	# revokecustomrole (udom,uname,url,rdom,rnam,rolename) : Revoke a custom role
# appenv(hash) : adds hash to session environment	# appenv(hash) : adds hash to session environment
# delenv(varname) : deletes all environment entries starting with varname	# delenv(varname) : deletes all environment entries starting with varname
# store(hash) : stores hash permanently for this url	# store(hashref,symb,courseid,udom,uname)
# cstore(hash) : critical store	# : stores hash permanently for this url
# restore : returns hash for this url	# hashref needs to be given, and should be a \%hashname
# eget(namesp,array) : returns hash with keys from array filled in from namesp	# the remaining args aren't required and if they aren't
# get(namesp,array) : returns hash with keys from array filled in from namesp	# passed or are '' they will be derived from the ENV
# del(namesp,array) : deletes keys out of array from namesp	# cstore(hashref,symb,courseid,udom,uname)
	# : same as store but uses the critical interface to
	# guarentee a store
	# restore(symb,courseid,udom,uname)
	# : returns hash for this symb, all args are optional
	# if they aren't given they will be derived from the
	# current enviroment
	#
	#
	# for the next 4 functions udom and uname are optional
	# if supplied they use udom as the domain and uname
	# as the username for the function (supply a courseid
	# for the uname if you want a course database)
	# if not supplied it uses %ENV and looks at
	# user. attribute for the values
	#
	# eget(namesp,arrayref,udom,uname)
	# : returns hash with keys from array reference filled
	# in from namesp (encrypts the return communication)
	# get(namesp,arrayref,udom,uname)
	# : returns hash with keys from array reference filled
	# in from namesp
	# dump(namesp,udom,uname) : dumps the complete namespace into a hash
	# del(namesp,array,udom,uname) : deletes keys out of array from namesp
	#
	#
# put(namesp,hash) : stores hash in namesp	# put(namesp,hash) : stores hash in namesp
# cput(namesp,hash) : critical put	# cput(namesp,hash) : critical put
# dump(namesp) : dumps the complete namespace into a hash
# ssi(url,hash) : does a complete request cycle on url to localhost, posts	# ssi(url,hash) : does a complete request cycle on url to localhost, posts
# hash	# hash
# coursedescription(id) : returns and caches course description for id	# coursedescription(id) : returns and caches course description for id
Line 49	Line 76
# receipt() : returns a receipt to be given out to users	# receipt() : returns a receipt to be given out to users
# getfile(filename) : returns the contents of filename, or a -1 if it can't	# getfile(filename) : returns the contents of filename, or a -1 if it can't
# be found, replicates and subscribes to the file	# be found, replicates and subscribes to the file
# filelocation(dir,file) : returns a farily clean absolute reference to file	# filelocation(dir,file) : returns a fairly clean absolute reference to file
# from the directory dir	# from the directory dir
# hreflocation(dir,file) : same as filelocation, but for hrefs	# hreflocation(dir,file) : same as filelocation, but for hrefs
# log(domain,user,home,msg) : write to permanent log for user	# log(domain,user,home,msg) : write to permanent log for user
Line 86	Line 113
# 05/01,06/01,09/01 Gerd Kortemeyer	# 05/01,06/01,09/01 Gerd Kortemeyer
# 09/01 Guy Albertelli	# 09/01 Guy Albertelli
# 09/01,10/01,11/01 Gerd Kortemeyer	# 09/01,10/01,11/01 Gerd Kortemeyer
	# 02/27/01 Scott Harrison
	# 3/2 Gerd Kortemeyer
	# 3/15,3/19 Scott Harrison
	# 3/19,3/20 Gerd Kortemeyer
	# 3/22,3/27,4/2,4/16,4/17 Scott Harrison
	# 5/26,5/28 Gerd Kortemeyer
	# 5/30 H. K. Ng
	# 6/1 Gerd Kortemeyer
	#

package Apache::lonnet;	package Apache::lonnet;

Line 622 sub log {	Line 658 sub log {
return critical("log:$dom:$nam:$what",$hom);	return critical("log:$dom:$nam:$what",$hom);
}	}

	# --------------------------------------------- Set Expire Date for Spreadsheet

	sub expirespread {
	my ($uname,$udom,$stype,$usymb)=@_;
	my $cid=$ENV{'request.course.id'};
	if ($cid) {
	my $now=time;
	my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;
	return &reply('put:'.$ENV{'course.'.$cid.'.domain'}.':'.
	$ENV{'course.'.$cid.'.num'}.
	':nohist_expirationdates:'.
	&escape($key).'='.$now,
	$ENV{'course.'.$cid.'.home'})
	}
	return 'ok';
	}

	# ----------------------------------------------------- Devalidate Spreadsheets

	sub devalidate {
	my $symb=shift;
	my $cid=$ENV{'request.course.id'};
	if ($cid) {
	my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';
	my $status=
	&del('nohist_calculatedsheet',
	[$key.'studentcalc'],
	$ENV{'course.'.$cid.'.domain'},
	$ENV{'course.'.$cid.'.num'})
	.' '.
	&del('nohist_calculatedsheets_'.$cid,
	[$key.'assesscalc:'.$symb]);
	unless ($status eq 'ok ok') {
	&logthis('Could not devalidate spreadsheet '.
	$ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.
	$symb.': '.$status);
	}
	}
	}

# ----------------------------------------------------------------------- Store	# ----------------------------------------------------------------------- Store

sub store {	sub store {
my %storehash=@_;	my ($storehash,$symb,$namespace,$domain,$stuname) = @_;
my $symb;	my $home='';
unless ($symb=escape(&symbread())) { return ''; }
my $namespace;	if ($stuname) {
unless ($namespace=$ENV{'request.course.id'}) { return ''; }	$home=&homeserver($stuname,$domain);
	}

	if (!$symb) { unless ($symb=&symbread()) { return ''; } }

	&devalidate($symb);

	$symb=escape($symb);
	if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
	if (!$domain) { $domain=$ENV{'user.domain'}; }
	if (!$stuname) { $stuname=$ENV{'user.name'}; }
	if (!$home) { $home=$ENV{'user.home'}; }
my $namevalue='';	my $namevalue='';
map {	map {
$namevalue.=escape($_).'='.escape($storehash{$_}).'&';	$namevalue.=escape($_).'='.escape($$storehash{$_}).'&';
} keys %storehash;	} keys %$storehash;
$namevalue=~s/\&$//;	$namevalue=~s/\&$//;
return reply(	return reply("store:$domain:$stuname:$namespace:$symb:$namevalue","$home");
"store:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$symb:$namevalue",
"$ENV{'user.home'}");
}	}

# -------------------------------------------------------------- Critical Store	# -------------------------------------------------------------- Critical Store

sub cstore {	sub cstore {
my %storehash=@_;	my ($storehash,$symb,$namespace,$domain,$stuname) = @_;
my $symb;	my $home='';
unless ($symb=escape(&symbread())) { return ''; }
my $namespace;	if ($stuname) {
unless ($namespace=$ENV{'request.course.id'}) { return ''; }	$home=&homeserver($stuname,$domain);
	}

	if (!$symb) { unless ($symb=&symbread()) { return ''; } }

	&devalidate($symb);

	$symb=escape($symb);
	if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
	if (!$domain) { $domain=$ENV{'user.domain'}; }
	if (!$stuname) { $stuname=$ENV{'user.name'}; }
	if (!$home) { $home=$ENV{'user.home'}; }

my $namevalue='';	my $namevalue='';
map {	map {
$namevalue.=escape($_).'='.escape($storehash{$_}).'&';	$namevalue.=escape($_).'='.escape($$storehash{$_}).'&';
} keys %storehash;	} keys %$storehash;
$namevalue=~s/\&$//;	$namevalue=~s/\&$//;
return critical(	return critical("store:$domain:$stuname:$namespace:$symb:$namevalue","$home");
"store:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$symb:$namevalue",
"$ENV{'user.home'}");
}	}

# --------------------------------------------------------------------- Restore	# --------------------------------------------------------------------- Restore

sub restore {	sub restore {
my $symb;	my ($symb,$namespace,$domain,$stuname) = @_;
unless ($symb=escape(&symbread())) { return ''; }	my $home='';
my $namespace;
unless ($namespace=$ENV{'request.course.id'}) { return ''; }	if ($stuname) {
my $answer=reply(	$home=&homeserver($stuname,$domain);
"restore:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$symb",	}
"$ENV{'user.home'}");
	if (!$symb) {
	unless ($symb=escape(&symbread())) { return ''; }
	} else {
	$symb=&escape($symb);
	}
	if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
	if (!$domain) { $domain=$ENV{'user.domain'}; }
	if (!$stuname) { $stuname=$ENV{'user.name'}; }
	if (!$home) { $home=$ENV{'user.home'}; }
	my $answer=&reply("restore:$domain:$stuname:$namespace:$symb","$home");

my %returnhash=();	my %returnhash=();
map {	map {
my ($name,$value)=split(/\=/,$_);	my ($name,$value)=split(/\=/,$_);
Line 689 sub coursedescription {	Line 795 sub coursedescription {
$courseid=~s/^\///;	$courseid=~s/^\///;
$courseid=~s/\_/\//g;	$courseid=~s/\_/\//g;
my ($cdomain,$cnum)=split(/\//,$courseid);	my ($cdomain,$cnum)=split(/\//,$courseid);
my $chome=homeserver($cnum,$cdomain);	my $chome=&homeserver($cnum,$cdomain);
if ($chome ne 'no_host') {	if ($chome ne 'no_host') {
my $rep=reply("dump:$cdomain:$cnum:environment",$chome);	my %returnhash=&dump('environment',$cdomain,$cnum);
if ($rep ne 'con_lost') {	if (!exists($returnhash{'con_lost'})) {
my $normalid=$cdomain.'_'.$cnum;	my $normalid=$cdomain.'_'.$cnum;
my %envhash=();	my %envhash=();
my %returnhash=('home' => $chome,	$returnhash{'home'}= $chome;
'domain' => $cdomain,	$returnhash{'domain'} = $cdomain;
'num' => $cnum);	$returnhash{'num'} = $cnum;
map {	while (my ($name,$value) = each %returnhash) {
my ($name,$value)=split(/\=/,$_);
$name=&unescape($name);
$value=&unescape($value);
$returnhash{$name}=$value;
$envhash{'course.'.$normalid.'.'.$name}=$value;	$envhash{'course.'.$normalid.'.'.$name}=$value;
} split(/\&/,$rep);	}
$returnhash{'url'}='/res/'.declutter($returnhash{'url'});	$returnhash{'url'}='/res/'.declutter($returnhash{'url'});
$returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.	$returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.
$ENV{'user.name'}.'_'.$cdomain.'_'.$cnum;	$ENV{'user.name'}.'_'.$cdomain.'_'.$cnum;
Line 719 sub coursedescription {	Line 821 sub coursedescription {
return ();	return ();
}	}

# -------------------------------------------------------- Get user priviledges	# -------------------------------------------------------- Get user privileges

sub rolesinit {	sub rolesinit {
my ($domain,$username,$authhost)=@_;	my ($domain,$username,$authhost)=@_;
Line 789 sub rolesinit {	Line 891 sub rolesinit {
}	}
}	}
} split(/&/,$rolesdump);	} split(/&/,$rolesdump);
	my $adv=0;
	my $author=0;
map {	map {
%thesepriv=();	%thesepriv=();
	if ($_!~/^st/) { $adv=1; }
	if (($_=~/^au/) \|\| ($_=~/^ca/)) { $author=1; }
map {	map {
if ($_ ne '') {	if ($_ ne '') {
my ($priviledge,$restrictions)=split(/&/,$_);	my ($privilege,$restrictions)=split(/&/,$_);
if ($restrictions eq '') {	if ($restrictions eq '') {
$thesepriv{$priviledge}='F';	$thesepriv{$privilege}='F';
} else {	} else {
if ($thesepriv{$priviledge} ne 'F') {	if ($thesepriv{$privilege} ne 'F') {
$thesepriv{$priviledge}.=$restrictions;	$thesepriv{$privilege}.=$restrictions;
}	}
}	}
}	}
Line 807 sub rolesinit {	Line 913 sub rolesinit {
map { $thesestr.=':'.$_.'&'.$thesepriv{$_}; } keys %thesepriv;	map { $thesestr.=':'.$_.'&'.$thesepriv{$_}; } keys %thesepriv;
$userroles.='user.priv.'.$_.'='.$thesestr."\n";	$userroles.='user.priv.'.$_.'='.$thesestr."\n";
} keys %allroles;	} keys %allroles;
	$userroles.='user.adv='.$adv."\n".
	'user.author='.$author."\n";
	$ENV{'user.adv'}=$adv;
}	}
return $userroles;	return $userroles;
}	}
Line 814 sub rolesinit {	Line 923 sub rolesinit {
# --------------------------------------------------------------- get interface	# --------------------------------------------------------------- get interface

sub get {	sub get {
my ($namespace,@storearr)=@_;	my ($namespace,$storearr,$udomain,$uname)=@_;
my $items='';	my $items='';
map {	map {
$items.=escape($_).'&';	$items.=escape($_).'&';
} @storearr;	} @$storearr;
$items=~s/\&$//;	$items=~s/\&$//;
my $rep=reply("get:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",	if (!$udomain) { $udomain=$ENV{'user.domain'}; }
$ENV{'user.home'});	if (!$uname) { $uname=$ENV{'user.name'}; }
	my $uhome=&homeserver($uname,$udomain);

	my $rep=&reply("get:$udomain:$uname:$namespace:$items",$uhome);
my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
my %returnhash=();	my %returnhash=();
my $i=0;	my $i=0;
map {	map {
$returnhash{$_}=unescape($pairs[$i]);	$returnhash{$_}=unescape($pairs[$i]);
$i++;	$i++;
} @storearr;	} @$storearr;
return %returnhash;	return %returnhash;
}	}

# --------------------------------------------------------------- del interface	# --------------------------------------------------------------- del interface

sub del {	sub del {
my ($namespace,@storearr)=@_;	my ($namespace,$storearr,$udomain,$uname)=@_;
my $items='';	my $items='';
map {	map {
$items.=escape($_).'&';	$items.=escape($_).'&';
} @storearr;	} @$storearr;
$items=~s/\&$//;	$items=~s/\&$//;
return reply("del:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",	if (!$udomain) { $udomain=$ENV{'user.domain'}; }
$ENV{'user.home'});	if (!$uname) { $uname=$ENV{'user.name'}; }
	my $uhome=&homeserver($uname,$udomain);

	return &reply("del:$udomain:$uname:$namespace:$items",$uhome);
}	}

# -------------------------------------------------------------- dump interface	# -------------------------------------------------------------- dump interface

sub dump {	sub dump {
my $namespace=shift;	my ($namespace,$udomain,$uname)=@_;
my $rep=reply("dump:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace",	if (!$udomain) { $udomain=$ENV{'user.domain'}; }
$ENV{'user.home'});	if (!$uname) { $uname=$ENV{'user.name'}; }
	my $uhome=&homeserver($uname,$udomain);
	my $rep=reply("dump:$udomain:$uname:$namespace",$uhome);
my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
my %returnhash=();	my %returnhash=();
map {	map {
Line 890 sub cput {	Line 1007 sub cput {
# -------------------------------------------------------------- eget interface	# -------------------------------------------------------------- eget interface

sub eget {	sub eget {
my ($namespace,@storearr)=@_;	my ($namespace,$storearr,$udomain,$uname)=@_;
my $items='';	my $items='';
map {	map {
$items.=escape($_).'&';	$items.=escape($_).'&';
} @storearr;	} @$storearr;
$items=~s/\&$//;	$items=~s/\&$//;
my $rep=reply("eget:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",	if (!$udomain) { $udomain=$ENV{'user.domain'}; }
$ENV{'user.home'});	if (!$uname) { $uname=$ENV{'user.name'}; }
	my $uhome=&homeserver($uname,$udomain);
	my $rep=&reply("eget:$udomain:$uname:$namespace:$items",$uhome);
my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
my %returnhash=();	my %returnhash=();
my $i=0;	my $i=0;
map {	map {
$returnhash{$_}=unescape($pairs[$i]);	$returnhash{$_}=unescape($pairs[$i]);
$i++;	$i++;
} @storearr;	} @$storearr;
return %returnhash;	return %returnhash;
}	}

# ------------------------------------------------- Check for a user priviledge	# ------------------------------------------------- Check for a user privilege

sub allowed {	sub allowed {
my ($priv,$uri)=@_;	my ($priv,$uri)=@_;
Line 959 sub allowed {	Line 1078 sub allowed {
return $thisallowed;	return $thisallowed;
}	}
#	#
# Gathered so far: system, domain and course wide priviledges	# Gathered so far: system, domain and course wide privileges
#	#
# Course: See if uri or referer is an individual resource that is part of	# Course: See if uri or referer is an individual resource that is part of
# the course	# the course
Line 1010 sub allowed {	Line 1129 sub allowed {
}	}

#	#
# Gathered now: all priviledges that could apply, and condition number	# Gathered now: all privileges that could apply, and condition number
#	#
#	#
# Full or no access?	# Full or no access?
Line 1180 sub definerole {	Line 1299 sub definerole {
}	}
}	}

	# ---------------- Make a metadata query against the network of library servers

	sub metadata_query {
	my ($query,$custom,$customshow)=@_;
	# need to put in a library server loop here and return a hash
	my %rhash;
	for my $server (keys %libserv) {
	unless ($custom or $customshow) {
	my $reply=&reply("querysend:".&escape($query),$server);
	$rhash{$server}=$reply;
	}
	else {
	my $reply=&reply("querysend:".&escape($query).':'.
	&escape($custom).':'.&escape($customshow),
	$server);
	$rhash{$server}=$reply;
	}
	}
	return \%rhash;
	}

# ------------------------------------------------------------------ Plain Text	# ------------------------------------------------------------------ Plain Text

sub plaintext {	sub plaintext {
Line 1207 sub assignrole {	Line 1347 sub assignrole {
my ($udom,$uname,$url,$role,$end,$start)=@_;	my ($udom,$uname,$url,$role,$end,$start)=@_;
my $mrole;	my $mrole;
if ($role =~ /^cr\//) {	if ($role =~ /^cr\//) {
unless (&allowed('ccr',$url)) { return 'refused'; }	unless (&allowed('ccr',$url)) {
	&logthis('Refused custom assignrole: '.
	$udom.' '.$uname.' '.$url.' '.$role.' '.$end.' '.$start.' by '.
	$ENV{'user.name'}.' at '.$ENV{'user.domain'});
	return 'refused';
	}
$mrole='cr';	$mrole='cr';
} else {	} else {
my $cwosec=$url;	my $cwosec=$url;
$cwosec=~s/^\/(\w+)\/(\w+)\/.*/$1\/$2/;	$cwosec=~s/^\/(\w+)\/(\w+)\/.*/$1\/$2/;
unless (&allowed('c'.$role,$cwosec)) { return 'refused'; }	unless (&allowed('c'.$role,$cwosec)) {
	&logthis('Refused assignrole: '.
	$udom.' '.$uname.' '.$url.' '.$role.' '.$end.' '.$start.' by '.
	$ENV{'user.name'}.' at '.$ENV{'user.domain'});
	return 'refused';
	}
$mrole=$role;	$mrole=$role;
}	}
my $command="encrypt:rolesput:$ENV{'user.domain'}:$ENV{'user.name'}:".	my $command="encrypt:rolesput:$ENV{'user.domain'}:$ENV{'user.name'}:".
Line 1543 sub EXT {	Line 1693 sub EXT {
if ($realm eq 'user') {	if ($realm eq 'user') {
# --------------------------------------------------------------- user.resource	# --------------------------------------------------------------- user.resource
if ($space eq 'resource') {	if ($space eq 'resource') {
my %restored=&restore;	my %restored=&restore();
return $restored{$qualifierrest};	return $restored{$qualifierrest};
# ----------------------------------------------------------------- user.access	# ----------------------------------------------------------------- user.access
} elsif ($space eq 'access') {	} elsif ($space eq 'access') {
Line 1571 sub EXT {	Line 1721 sub EXT {
# ---------------------------------------------------- Any other user namespace	# ---------------------------------------------------- Any other user namespace
} else {	} else {
my $item=($rest)?$qualifier.'.'.$rest:$qualifier;	my $item=($rest)?$qualifier.'.'.$rest:$qualifier;
my %reply=&get($space,$item);	my %reply=&get($space,[$item]);
return $reply{$item};	return $reply{$item};
}	}
} elsif ($realm eq 'request') {	} elsif ($realm eq 'request') {
Line 1584 sub EXT {	Line 1734 sub EXT {
}	}
} elsif ($realm eq 'course') {	} elsif ($realm eq 'course') {
# ---------------------------------------------------------- course.description	# ---------------------------------------------------------- course.description
my $section='';	return $ENV{'course.'.$ENV{'request.course.id'}.'.'.
if ($ENV{'request.course.sec'}) {
$section='_'.$ENV{'request.course.sec'};
}
return $ENV{'course.'.$ENV{'request.course.id'}.$section.'.'.
$spacequalifierrest};	$spacequalifierrest};
} elsif ($realm eq 'resource') {	} elsif ($realm eq 'resource') {
if ($ENV{'request.course.id'}) {	if ($ENV{'request.course.id'}) {
# ----------------------------------------------------- Cascading lookup scheme	# ----------------------------------------------------- Cascading lookup scheme
my $symbp=&symbread();	my $symbp=&symbread();
my $mapp=(split(/\_\_\_/,$symbp))[0];	my $mapp=(split(/\_\_\_/,$symbp))[0];

my $symbparm=$symbp.'.'.$spacequalifierrest;	my $symbparm=$symbp.'.'.$spacequalifierrest;
my $mapparm=$mapp.'___(all).'.$spacequalifierrest;	my $mapparm=$mapp.'___(all).'.$spacequalifierrest;

my $seclevel=	my $seclevel=
$ENV{'request.course.id'}.'.['.	$ENV{'request.course.id'}.'.['.
$ENV{'request.course.sec'}.'].'.$spacequalifierrest;	$ENV{'request.course.sec'}.'].'.$spacequalifierrest;
my $seclevelr=	my $seclevelr=
$ENV{'request.course.id'}.'.['.	$ENV{'request.course.id'}.'.['.
$ENV{'request.course.sec'}.'].'.$symbparm;	$ENV{'request.course.sec'}.'].'.$symbparm;
my $seclevelm=	my $seclevelm=
$ENV{'request.course.id'}.'.['.	$ENV{'request.course.id'}.'.['.
$ENV{'request.course.sec'}.'].'.$mapparm;	$ENV{'request.course.sec'}.'].'.$mapparm;

my $courselevel=	my $courselevel=
$ENV{'request.course.id'}.'.'.$spacequalifierrest;	$ENV{'request.course.id'}.'.'.$spacequalifierrest;
my $courselevelr=	my $courselevelr=
$ENV{'request.course.id'}.'.'.$symbparm;	$ENV{'request.course.id'}.'.'.$symbparm;
my $courselevelm=	my $courselevelm=
$ENV{'request.course.id'}.'.'.$mapparm;	$ENV{'request.course.id'}.'.'.$mapparm;

# ----------------------------------------------------------- first, check user	# ----------------------------------------------------------- first, check user
my %resourcedata=get('resourcedata',	my %resourcedata=get('resourcedata',
($courselevelr,$courselevelm,$courselevel));	[$courselevelr,$courselevelm,$courselevel]);
if (($resourcedata{$courselevelr}!~/^error\:/) &&	if (($resourcedata{$courselevelr}!~/^error\:/) &&
($resourcedata{$courselevelr}!~/^con_lost/)) {	($resourcedata{$courselevelr}!~/^con_lost/)) {

if ($resourcedata{$courselevelr}) {	if ($resourcedata{$courselevelr}) {
return $resourcedata{$courselevelr}; }	return $resourcedata{$courselevelr}; }
if ($resourcedata{$courselevelm}) {	if ($resourcedata{$courselevelm}) {
return $resourcedata{$courselevelm}; }	return $resourcedata{$courselevelm}; }
if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }	if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }

} else {	} else {
if ($resourcedata{$courselevelr}!~/No such file/) {	if ($resourcedata{$courselevelr}!~/No such file/) {
Line 1684 sub EXT {	Line 1830 sub EXT {
# ---------------------------------------------------- Any other user namespace	# ---------------------------------------------------- Any other user namespace
} elsif ($realm eq 'environment') {	} elsif ($realm eq 'environment') {
# ----------------------------------------------------------------- environment	# ----------------------------------------------------------------- environment
return $ENV{$spacequalifierrest};	return $ENV{'environment.'.$spacequalifierrest};
} elsif ($realm eq 'system') {	} elsif ($realm eq 'system') {
# ----------------------------------------------------------------- system.time	# ----------------------------------------------------------------- system.time
if ($space eq 'time') {	if ($space eq 'time') {

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.100
changed lines
	Added in v.1.133