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.113 and 1.144

version 1.113, 2001/03/22 15:10:35	version 1.144, 2001/08/08 17:56:57
Line 28	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)
# put(namesp,hash) : stores hash in namesp	# : same as store but uses the critical interface to
# cput(namesp,hash) : critical put	# guarentee a store
# dump(namesp) : dumps the complete namespace into a hash	# 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 6 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,udom,uname) : stores hash in namesp
	# cput(namesp,hash,udom,uname) : critical put
	#
	#
# 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 52	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 91	Line 115
# 09/01,10/01,11/01 Gerd Kortemeyer	# 09/01,10/01,11/01 Gerd Kortemeyer
# 02/27/01 Scott Harrison	# 02/27/01 Scott Harrison
# 3/2 Gerd Kortemeyer	# 3/2 Gerd Kortemeyer
# 3/15 Scott Harrison	# 3/15,3/19 Scott Harrison
# 3/19,3/20 Gerd Kortemeyer	# 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
	# July Guy Albertelli
	# 8/4,8/7,8/8 Gerd Kortemeyer

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

Line 101 use Apache::File;	Line 131 use Apache::File;
use LWP::UserAgent();	use LWP::UserAgent();
use HTTP::Headers;	use HTTP::Headers;
use vars	use vars
qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit %metacache);	qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit %metacache %packagetab);
use IO::Socket;	use IO::Socket;
use GDBM_File;	use GDBM_File;
use Apache::Constants qw(:common :http);	use Apache::Constants qw(:common :http);
Line 654 sub devalidate {	Line 684 sub devalidate {
if ($cid) {	if ($cid) {
my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';	my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';
my $status=	my $status=
&reply('del:'.$ENV{'course.'.$cid.'.domain'}.':'.	&del('nohist_calculatedsheet',
$ENV{'course.'.$cid.'.num'}.	[$key.'studentcalc'],
':nohist_calculatedsheets:'.	$ENV{'course.'.$cid.'.domain'},
&escape($key.'studentcalc:'),	$ENV{'course.'.$cid.'.num'})
$ENV{'course.'.$cid.'.home'})	.' '.
.' '.	&del('nohist_calculatedsheets_'.$cid,
&reply('del:'.$ENV{'user.domain'}.':'.	[$key.'assesscalc:'.$symb]);
$ENV{'user.name'}.
':nohist_calculatedsheets_'.$cid.':'.
&escape($key.'assesscalc:'.$symb),
$ENV{'user.home'});
unless ($status eq 'ok ok') {	unless ($status eq 'ok ok') {
&logthis('Could not devalidate spreadsheet '.	&logthis('Could not devalidate spreadsheet '.
$ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.	$ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.
$symb.': '.$status);	$symb.': '.$status);
}	}
}	}
}	}

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

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

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

&devalidate($symb);	&devalidate($symb);

$symb=escape($symb);	$symb=escape($symb);
my $namespace;	if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
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=&symbread()) { return ''; }
	if ($stuname) {
	$home=&homeserver($stuname,$domain);
	}

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

&devalidate($symb);	&devalidate($symb);

$symb=escape($symb);	$symb=escape($symb);
my $namespace;	if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
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 748 sub coursedescription {	Line 796 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 848 sub rolesinit {	Line 892 sub rolesinit {
}	}
}	}
} split(/&/,$rolesdump);	} split(/&/,$rolesdump);
	my $adv=0;
	my $author=0;
map {	map {
%thesepriv=();	%thesepriv=();
	if (($_!~/^st/) && ($_!~/^ta/)) { $adv=1; }
	if (($_=~/^au/) \|\| ($_=~/^ca/)) { $author=1; }
map {	map {
if ($_ ne '') {	if ($_ ne '') {
my ($privilege,$restrictions)=split(/&/,$_);	my ($privilege,$restrictions)=split(/&/,$_);
Line 866 sub rolesinit {	Line 914 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 873 sub rolesinit {	Line 924 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 922 sub dump {	Line 981 sub dump {
# --------------------------------------------------------------- put interface	# --------------------------------------------------------------- put interface

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

# ------------------------------------------------------ critical put interface	# ------------------------------------------------------ critical put interface

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

# -------------------------------------------------------------- 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;
}	}

Line 1242 sub definerole {	Line 1306 sub definerole {
# ---------------- Make a metadata query against the network of library servers	# ---------------- Make a metadata query against the network of library servers

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

# ------------------------------------------------------------------ Plain Text	# ------------------------------------------------------------------ Plain Text
Line 1369 sub modifyuser {	Line 1436 sub modifyuser {
}	}
}	}
# -------------------------------------------------------------- Add names, etc	# -------------------------------------------------------------- Add names, etc
my $names=&reply('get:'.$udom.':'.$uname.	my %names=&get('environment',
':environment:firstname&middlename&lastname&generation',	['firstname','middlename','lastname','generation'],
$uhome);	$udom,$uname);
my ($efirst,$emiddle,$elast,$egene)=split(/\&/,$names);	if ($first) { $names{'firstname'} = $first; }
if ($first) { $efirst = &escape($first); }	if ($middle) { $names{'middlename'} = $middle; }
if ($middle) { $emiddle = &escape($middle); }	if ($last) { $names{'lastname'} = $last; }
if ($last) { $elast = &escape($last); }	if ($gene) { $names{'generation'} = $gene; }
if ($gene) { $egene = &escape($gene); }	my $reply = &put('environment', \%names, $udom,$uname);
my $reply=&reply('put:'.$udom.':'.$uname.	if ($reply ne 'ok') { return 'error: '.$reply; }
':environment:firstname='.$efirst.
'&middlename='.$emiddle.
'&lastname='.$elast.
'&generation='.$egene,$uhome);
if ($reply ne 'ok') {
return 'error: '.$reply;
}
&logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.	&logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.
$umode.', '.$first.', '.$middle.', '.	$umode.', '.$first.', '.$middle.', '.
$last.', '.$gene.' by '.	$last.', '.$gene.' by '.
$ENV{'user.name'}.' at '.$ENV{'user.domain'});	$ENV{'user.name'}.' at '.$ENV{'user.domain'});
return 'ok';	return 'ok';
}	}

# -------------------------------------------------------------- Modify student	# -------------------------------------------------------------- Modify student
Line 1630 sub EXT {	Line 1690 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 1658 sub EXT {	Line 1718 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 1671 sub EXT {	Line 1731 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 1767 sub EXT {	Line 1823 sub EXT {
$metadata=&metadata($ENV{'request.filename'},	$metadata=&metadata($ENV{'request.filename'},
'parameter_'.$spacequalifierrest);	'parameter_'.$spacequalifierrest);
if ($metadata) { return $metadata; }	if ($metadata) { return $metadata; }

	$spacequalifierrest=~/[^\_]+$/;

	$metadata=&metadata($ENV{'request.filename'},'parameter_0'.$1);

	if ($metadata) { return $metadata; }

# ---------------------------------------------------- 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') {
Line 1790 sub metadata {	Line 1852 sub metadata {
my $filename=$uri;	my $filename=$uri;
$uri=~s/\.meta$//;	$uri=~s/\.meta$//;
unless ($metacache{$uri.':keys'}) {	unless ($metacache{$uri.':keys'}) {
	my %metathesekeys=();
unless ($filename=~/\.meta$/) { $filename.='.meta'; }	unless ($filename=~/\.meta$/) { $filename.='.meta'; }
my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);	my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);
my $parser=HTML::TokeParser->new(\$metastring);	my $parser=HTML::TokeParser->new(\$metastring);
my $token;	my $token;
	undef %metathesekeys;
while ($token=$parser->get_token) {	while ($token=$parser->get_token) {
if ($token->[0] eq 'S') {	if ($token->[0] eq 'S') {
	if (defined($token->[2]->{'package'})) {
	my $package=$token->[2]->{'package'};
	my $keyroot='';
	if (defined($token->[2]->{'part'})) {
	$keyroot.='_'.$token->[2]->{'part'};
	}
	if (defined($token->[2]->{'id'})) {
	$keyroot.='_'.$token->[2]->{'id'};
	}
	if ($metacache{$uri.':packages'}) {
	$metacache{$uri.':packages'}.=','.$package.$keyroot;
	} else {
	$metacache{$uri.':packages'}=$package.$keyroot;
	}
	map {
	if ($_=~/^$package\&/) {
	my ($pack,$name,$subp)=split(/\&/,$_);
	my $value=$packagetab{$_};
	my $part=$keyroot;
	$part=~s/^\_//;
	if ($subp eq 'display') {
	$value.=' [Part: '.$part.']';
	}
	my $unikey='parameter'.$keyroot.'_'.$name;
	$metathesekeys{$unikey}=1;
	$metacache{$uri.':'.$unikey.'.part'}=$part;
	unless
	(defined($metacache{$uri.':'.$unikey.'.'.$subp})) {
	$metacache{$uri.':'.$unikey.'.'.$subp}=$value;
	}
	}
	} keys %packagetab;
	} else {
my $entry=$token->[1];	my $entry=$token->[1];
my $unikey=$entry;	my $unikey=$entry;
if (defined($token->[2]->{'part'})) {	if (defined($token->[2]->{'part'})) {
$unikey.='_'.$token->[2]->{'part'};	$unikey.='_'.$token->[2]->{'part'};
}	}
	if (defined($token->[2]->{'id'})) {
	$unikey.='_'.$token->[2]->{'id'};
	}
if (defined($token->[2]->{'name'})) {	if (defined($token->[2]->{'name'})) {
$unikey.='_'.$token->[2]->{'name'};	$unikey.='_'.$token->[2]->{'name'};
}	}
if ($metacache{$uri.':keys'}) {	$metathesekeys{$unikey}=1;
$metacache{$uri.':keys'}.=','.$unikey;
} else {
$metacache{$uri.':keys'}=$unikey;
}
map {	map {
$metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};	$metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};
} @{$token->[3]};	} @{$token->[3]};
Line 1817 sub metadata {	Line 1913 sub metadata {
) { $metacache{$uri.':'.$unikey}=	) { $metacache{$uri.':'.$unikey}=
$metacache{$uri.':'.$unikey.'.default'};	$metacache{$uri.':'.$unikey.'.default'};
}	}
}	}
	}
}	}
	$metacache{$uri.':keys'}=join(',',keys %metathesekeys);
}	}
return $metacache{$uri.':'.$what};	return $metacache{$uri.':'.$what};
}	}
Line 2099 if ($readit ne 'done') {	Line 2197 if ($readit ne 'done') {
}	}
}	}

	# ---------------------------------------------------------- Read package table
	{
	my $config=Apache::File->new("$perlvar{'lonTabDir'}/packages.tab");

	while (my $configline=<$config>) {
	chomp($configline);
	my ($short,$plain)=split(/:/,$configline);
	my ($pack,$name)=split(/\&/,$short);
	if ($plain ne '') {
	$packagetab{$pack.'&'.$name.'&name'}=$name;
	$packagetab{$short}=$plain;
	}
	}
	}

# ------------------------------------------------------------- Read file types	# ------------------------------------------------------------- Read file types
{	{
my $config=Apache::File->new("$perlvar{'lonTabDir'}/filetypes.tab");	my $config=Apache::File->new("$perlvar{'lonTabDir'}/filetypes.tab");

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

Removed from v.1.113
changed lines
	Added in v.1.144