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.96 and 1.136

version 1.96, 2001/01/11 11:08:37	version 1.136, 2001/08/04 14:03:46
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)
# 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 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
	# July Guy Albertelli
	# 8/4 Gerd Kortemeyer

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

Line 94 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 248 sub appenv {	Line 285 sub appenv {

my $lockfh;	my $lockfh;
unless ($lockfh=Apache::File->new("$ENV{'user.environment'}")) {	unless ($lockfh=Apache::File->new("$ENV{'user.environment'}")) {
return 'error';	return 'error: '.$!;
}	}
unless (flock($lockfh,LOCK_EX)) {	unless (flock($lockfh,LOCK_EX)) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=blue>WARNING: ".
Line 261 sub appenv {	Line 298 sub appenv {
{	{
my $fh;	my $fh;
unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {	unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {
return 'error';	return 'error: '.$!;
}	}
@oldenv=<$fh>;	@oldenv=<$fh>;
$fh->close();	$fh->close();
Line 622 sub log {	Line 659 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 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 719 sub coursedescription {	Line 822 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 892 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 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 814 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 863 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;
}	}

# ------------------------------------------------- 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 1082 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 1133 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 1303 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 1351 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 1282 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 1543 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 1571 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 1584 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 1684 sub EXT {	Line 1827 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') {
Line 1709 sub metadata {	Line 1852 sub metadata {
my $token;	my $token;
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;
	}

	} 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'};
}	}
Line 1730 sub metadata {	Line 1892 sub metadata {
) { $metacache{$uri.':'.$unikey}=	) { $metacache{$uri.':'.$unikey}=
$metacache{$uri.':'.$unikey.'.default'};	$metacache{$uri.':'.$unikey.'.default'};
}	}
}	}
	}
}	}
}	}
return $metacache{$uri.':'.$what};	return $metacache{$uri.':'.$what};
Line 1843 sub numval {	Line 2006 sub numval {
sub rndseed {	sub rndseed {
my $symb;	my $symb;
unless ($symb=&symbread()) { return time; }	unless ($symb=&symbread()) { return time; }
my $symbchck=unpack("%32C*",$symb);	{
my $symbseed=numval($symb)%$symbchck;	use integer;
my $namechck=unpack("%32C*",$ENV{'user.name'});	my $symbchck=unpack("%32C*",$symb) << 27;
my $nameseed=numval($ENV{'user.name'})%$namechck;	my $symbseed=numval($symb) << 22;
return int( $symbseed	my $namechck=unpack("%32C*",$ENV{'user.name'}) << 17;
.$nameseed	my $nameseed=numval($ENV{'user.name'}) << 12;
.unpack("%32C*",$ENV{'user.domain'})	my $domainseed=unpack("%32C*",$ENV{'user.domain'}) << 7;
.unpack("%32C*",$ENV{'request.course.id'})	my $courseseed=unpack("%32C*",$ENV{'request.course.id'});
.$namechck	my $num=$symbseed+$nameseed+$domainseed+$courseseed+$namechck+$symbchck;
.$symbchck);	#uncommenting these lines can break things!
	#&Apache::lonxml::debug("$symbseed:$nameseed;$domainseed\|$courseseed;$namechck:$symbchck");
	#&Apache::lonxml::debug("rndseed :$num:$symb");
	return $num;
	}
}	}

sub ireceipt {	sub ireceipt {
Line 2008 if ($readit ne 'done') {	Line 2175 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);
	if ($plain ne '') { $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.96
changed lines
	Added in v.1.136