1: # The LearningOnline Network
2: # TCP networking package
3: #
4: # Functions for use by content handlers:
5: #
6: # plaintext(short) : plain text explanation of short term
7: # fileembstyle(ext) : embed style in page for file extension
8: # filedescription(ext) : descriptor text for file extension
9: # allowed(short,url) : returns codes for allowed actions F,R,S,X,C
10: # definerole(rolename,sys,dom,cou) : define a custom role rolename
11: # set priviledges in format of lonTabs/roles.tab for
12: # system, domain and course level,
13: # assignrole(udom,uname,url,role,end,start) : give a role to a user for the
14: # level given by url. Optional start and end dates
15: # (leave empty string or zero for "no date")
16: # assigncustomrole (udom,uname,url,rdom,rnam,rolename,end,start) : give a
17: # custom role to a user for the level given by url.
18: # Specify name and domain of role author, and role name
19: # revokerole (udom,uname,url,role) : Revoke a role for url
20: # revokecustomrole (udom,uname,url,rdom,rnam,rolename) : Revoke a custom role
21: # appenv(hash) : adds hash to session environment
22: # store(hash) : stores hash permanently for this url
23: # restore : returns hash for this url
24: # eget(namesp,array) : returns hash with keys from array filled in from namesp
25: # get(namesp,array) : returns hash with keys from array filled in from namesp
26: # put(namesp,hash) : stores hash in namesp
27: # dump(namesp) : dumps the complete namespace into a hash
28: # ssi(url,hash) : does a complete request cycle on url to localhost, posts
29: # hash
30: # repcopy(filename) : replicate file
31: # dirlist(url) : gets a directory listing
32: # condval(index) : value of condition index based on state
33: #
34: # 6/1/99,6/2,6/10,6/11,6/12,6/14,6/26,6/28,6/29,6/30,
35: # 7/1,7/2,7/9,7/10,7/12,7/14,7/15,7/19,
36: # 11/8,11/16,11/18,11/22,11/23,12/22,
37: # 01/06,01/13,02/24,02/28,02/29,
38: # 03/01,03/02,03/06,03/07,03/13,
39: # 04/05,05/29,05/31,06/01,
40: # 06/05,06/26 Gerd Kortemeyer
41: # 06/26 Ben Tyszka
42: # 06/30,07/15,07/17,07/18,07/20,07/21,07/22,07/25 Gerd Kortemeyer
43: # 08/14 Ben Tyszka
44: # 08/22,08/28,08/31,09/01 Gerd Kortemeyer
45:
46: package Apache::lonnet;
47:
48: use strict;
49: use Apache::File;
50: use LWP::UserAgent();
51: use HTTP::Headers;
52: use vars
53: qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit);
54: use IO::Socket;
55: use Apache::Constants qw(:common :http);
56:
57: # --------------------------------------------------------------------- Logging
58:
59: sub logthis {
60: my $message=shift;
61: my $execdir=$perlvar{'lonDaemons'};
62: my $now=time;
63: my $local=localtime($now);
64: my $fh=Apache::File->new(">>$execdir/logs/lonnet.log");
65: print $fh "$local ($$): $message\n";
66: return 1;
67: }
68:
69: sub logperm {
70: my $message=shift;
71: my $execdir=$perlvar{'lonDaemons'};
72: my $now=time;
73: my $local=localtime($now);
74: my $fh=Apache::File->new(">>$execdir/logs/lonnet.perm.log");
75: print $fh "$now:$message:$local\n";
76: return 1;
77: }
78:
79: # -------------------------------------------------- Non-critical communication
80: sub subreply {
81: my ($cmd,$server)=@_;
82: my $peerfile="$perlvar{'lonSockDir'}/$server";
83: my $client=IO::Socket::UNIX->new(Peer =>"$peerfile",
84: Type => SOCK_STREAM,
85: Timeout => 10)
86: or return "con_lost";
87: print $client "$cmd\n";
88: my $answer=<$client>;
89: if (!$answer) { $answer="con_lost"; }
90: chomp($answer);
91: return $answer;
92: }
93:
94: sub reply {
95: my ($cmd,$server)=@_;
96: my $answer=subreply($cmd,$server);
97: if ($answer eq 'con_lost') { $answer=subreply($cmd,$server); }
98: if (($answer=~/^error:/) || ($answer=~/^refused/) ||
99: ($answer=~/^rejected/)) {
100: &logthis("<font color=blue>WARNING:".
101: " $cmd to $server returned $answer</font>");
102: }
103: return $answer;
104: }
105:
106: # ----------------------------------------------------------- Send USR1 to lonc
107:
108: sub reconlonc {
109: my $peerfile=shift;
110: &logthis("Trying to reconnect for $peerfile");
111: my $loncfile="$perlvar{'lonDaemons'}/logs/lonc.pid";
112: if (my $fh=Apache::File->new("$loncfile")) {
113: my $loncpid=<$fh>;
114: chomp($loncpid);
115: if (kill 0 => $loncpid) {
116: &logthis("lonc at pid $loncpid responding, sending USR1");
117: kill USR1 => $loncpid;
118: sleep 1;
119: if (-e "$peerfile") { return; }
120: &logthis("$peerfile still not there, give it another try");
121: sleep 5;
122: if (-e "$peerfile") { return; }
123: &logthis(
124: "<font color=blue>WARNING: $peerfile still not there, giving up</font>");
125: } else {
126: &logthis(
127: "<font color=blue>WARNING:".
128: " lonc at pid $loncpid not responding, giving up</font>");
129: }
130: } else {
131: &logthis('<font color=blue>WARNING: lonc not running, giving up</font>');
132: }
133: }
134:
135: # ------------------------------------------------------ Critical communication
136:
137: sub critical {
138: my ($cmd,$server)=@_;
139: my $answer=reply($cmd,$server);
140: if ($answer eq 'con_lost') {
141: my $pingreply=reply('ping',$server);
142: &reconlonc("$perlvar{'lonSockDir'}/$server");
143: my $pongreply=reply('pong',$server);
144: &logthis("Ping/Pong for $server: $pingreply/$pongreply");
145: $answer=reply($cmd,$server);
146: if ($answer eq 'con_lost') {
147: my $now=time;
148: my $middlename=$cmd;
149: $middlename=substr($middlename,0,16);
150: $middlename=~s/\W//g;
151: my $dfilename=
152: "$perlvar{'lonSockDir'}/delayed/$now.$middlename.$server";
153: {
154: my $dfh;
155: if ($dfh=Apache::File->new(">$dfilename")) {
156: print $dfh "$cmd\n";
157: }
158: }
159: sleep 2;
160: my $wcmd='';
161: {
162: my $dfh;
163: if ($dfh=Apache::File->new("$dfilename")) {
164: $wcmd=<$dfh>;
165: }
166: }
167: chomp($wcmd);
168: if ($wcmd eq $cmd) {
169: &logthis("<font color=blue>WARNING: ".
170: "Connection buffer $dfilename: $cmd</font>");
171: &logperm("D:$server:$cmd");
172: return 'con_delayed';
173: } else {
174: &logthis("<font color=red>CRITICAL:"
175: ." Critical connection failed: $server $cmd</font>");
176: &logperm("F:$server:$cmd");
177: return 'con_failed';
178: }
179: }
180: }
181: return $answer;
182: }
183:
184: # ---------------------------------------------------------- Append Environment
185:
186: sub appenv {
187: my %newenv=@_;
188: my @oldenv;
189: {
190: my $fh;
191: unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {
192: return 'error';
193: }
194: @oldenv=<$fh>;
195: }
196: for (my $i=0; $i<=$#oldenv; $i++) {
197: chomp($oldenv[$i]);
198: if ($oldenv[$i] ne '') {
199: my ($name,$value)=split(/=/,$oldenv[$i]);
200: unless (defined($newenv{$name})) {
201: $newenv{$name}=$value;
202: }
203: }
204: }
205: {
206: my $fh;
207: unless ($fh=Apache::File->new(">$ENV{'user.environment'}")) {
208: return 'error';
209: }
210: my $newname;
211: foreach $newname (keys %newenv) {
212: print $fh "$newname=$newenv{$newname}\n";
213: }
214: }
215: return 'ok';
216: }
217:
218: # ------------------------------ Find server with least workload from spare.tab
219:
220: sub spareserver {
221: my $tryserver;
222: my $spareserver='';
223: my $lowestserver=100;
224: foreach $tryserver (keys %spareid) {
225: my $answer=reply('load',$tryserver);
226: if (($answer =~ /\d/) && ($answer<$lowestserver)) {
227: $spareserver="http://$hostname{$tryserver}";
228: $lowestserver=$answer;
229: }
230: }
231: return $spareserver;
232: }
233:
234: # --------- Try to authenticate user from domain's lib servers (first this one)
235:
236: sub authenticate {
237: my ($uname,$upass,$udom)=@_;
238: $upass=escape($upass);
239: if (($perlvar{'lonRole'} eq 'library') &&
240: ($udom eq $perlvar{'lonDefDomain'})) {
241: my $answer=reply("encrypt:auth:$udom:$uname:$upass",$perlvar{'lonHostID'});
242: if ($answer =~ /authorized/) {
243: if ($answer eq 'authorized') {
244: &logthis("User $uname at $udom authorized by local server");
245: return $perlvar{'lonHostID'};
246: }
247: if ($answer eq 'non_authorized') {
248: &logthis("User $uname at $udom rejected by local server");
249: return 'no_host';
250: }
251: }
252: }
253:
254: my $tryserver;
255: foreach $tryserver (keys %libserv) {
256: if ($hostdom{$tryserver} eq $udom) {
257: my $answer=reply("encrypt:auth:$udom:$uname:$upass",$tryserver);
258: if ($answer =~ /authorized/) {
259: if ($answer eq 'authorized') {
260: &logthis("User $uname at $udom authorized by $tryserver");
261: return $tryserver;
262: }
263: if ($answer eq 'non_authorized') {
264: &logthis("User $uname at $udom rejected by $tryserver");
265: return 'no_host';
266: }
267: }
268: }
269: }
270: &logthis("User $uname at $udom could not be authenticated");
271: return 'no_host';
272: }
273:
274: # ---------------------- Find the homebase for a user from domain's lib servers
275:
276: sub homeserver {
277: my ($uname,$udom)=@_;
278:
279: my $index="$uname:$udom";
280: if ($homecache{$index}) { return "$homecache{$index}"; }
281:
282: my $tryserver;
283: foreach $tryserver (keys %libserv) {
284: if ($hostdom{$tryserver} eq $udom) {
285: my $answer=reply("home:$udom:$uname",$tryserver);
286: if ($answer eq 'found') {
287: $homecache{$index}=$tryserver;
288: return $tryserver;
289: }
290: }
291: }
292: return 'no_host';
293: }
294:
295: # ----------------------------- Subscribe to a resource, return URL if possible
296:
297: sub subscribe {
298: my $fname=shift;
299: my $author=$fname;
300: $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;
301: my ($udom,$uname)=split(/\//,$author);
302: my $home=homeserver($uname,$udom);
303: if (($home eq 'no_host') || ($home eq $perlvar{'lonHostID'})) {
304: return 'not_found';
305: }
306: my $answer=reply("sub:$fname",$home);
307: return $answer;
308: }
309:
310: # -------------------------------------------------------------- Replicate file
311:
312: sub repcopy {
313: my $filename=shift;
314: $filename=~s/\/+/\//g;
315: my $transname="$filename.in.transfer";
316: if ((-e $filename) || (-e $transname)) { return OK; }
317: my $remoteurl=subscribe($filename);
318: if ($remoteurl eq 'con_lost') {
319: &logthis("Subscribe returned con_lost: $filename");
320: return HTTP_SERVICE_UNAVAILABLE;
321: } elsif ($remoteurl eq 'not_found') {
322: &logthis("Subscribe returned not_found: $filename");
323: return HTTP_NOT_FOUND;
324: } elsif ($remoteurl eq 'rejected') {
325: &logthis("Subscribe returned rejected: $filename");
326: return FORBIDDEN;
327: } elsif ($remoteurl eq 'directory') {
328: return OK;
329: } else {
330: my @parts=split(/\//,$filename);
331: my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";
332: if ($path ne "$perlvar{'lonDocRoot'}/res") {
333: &logthis("Malconfiguration for replication: $filename");
334: return HTTP_BAD_REQUEST;
335: }
336: my $count;
337: for ($count=5;$count<$#parts;$count++) {
338: $path.="/$parts[$count]";
339: if ((-e $path)!=1) {
340: mkdir($path,0777);
341: }
342: }
343: my $ua=new LWP::UserAgent;
344: my $request=new HTTP::Request('GET',"$remoteurl");
345: my $response=$ua->request($request,$transname);
346: if ($response->is_error()) {
347: unlink($transname);
348: my $message=$response->status_line;
349: &logthis("<font color=blue>WARNING:"
350: ." LWP get: $message: $filename</font>");
351: return HTTP_SERVICE_UNAVAILABLE;
352: } else {
353: if ($remoteurl!~/\.meta$/) {
354: my $mrequest=new HTTP::Request('GET',$remoteurl.'.meta');
355: my $mresponse=$ua->request($mrequest,$filename.'.meta');
356: if ($mresponse->is_error()) {
357: unlink($filename.'.meta');
358: &logthis(
359: "<font color=yellow>INFO: No metadata: $filename</font>");
360: }
361: }
362: rename($transname,$filename);
363: return OK;
364: }
365: }
366: }
367:
368: # --------------------------------------------------------- Server Side Include
369:
370: sub ssi {
371:
372: my ($fn,%form)=@_;
373:
374: my $ua=new LWP::UserAgent;
375:
376: my $request;
377:
378: if (%form) {
379: $request=new HTTP::Request('POST',"http://".$ENV{'HTTP_HOST'}.$fn);
380: $request->content(join '&', map { "$_=$form{$_}" } keys %form);
381: } else {
382: $request=new HTTP::Request('GET',"http://".$ENV{'HTTP_HOST'}.$fn);
383: }
384:
385: $request->header(Cookie => $ENV{'HTTP_COOKIE'});
386: my $response=$ua->request($request);
387:
388: return $response->content;
389: }
390:
391: # ------------------------------------------------------------------------- Log
392:
393: sub log {
394: my ($dom,$nam,$hom,$what)=@_;
395: return reply("log:$dom:$nam:$what",$hom);
396: }
397:
398: # ----------------------------------------------------------------------- Store
399:
400: sub store {
401: my %storehash=shift;
402: my $namevalue='';
403: map {
404: $namevalue.=escape($_).'='.escape($storehash{$_}).'&';
405: } keys %storehash;
406: $namevalue=~s/\&$//;
407: return reply("store:$ENV{'user.domain'}:$ENV{'user.name'}:"
408: ."$ENV{'user.class'}:$ENV{'request.filename'}:$namevalue",
409: "$ENV{'user.home'}");
410: }
411:
412: # --------------------------------------------------------------------- Restore
413:
414: sub restore {
415: my $answer=reply("restore:$ENV{'user.domain'}:$ENV{'user.name'}:"
416: ."$ENV{'user.class'}:$ENV{'request.filename'}",
417: "$ENV{'user.home'}");
418: my %returnhash=();
419: map {
420: my ($name,$value)=split(/\=/,$_);
421: $returnhash{&unescape($name)}=&unescape($value);
422: } split(/\&/,$answer);
423: return %returnhash;
424: }
425:
426: # -------------------------------------------------------- Get user priviledges
427:
428: sub rolesinit {
429: my ($domain,$username,$authhost)=@_;
430: my $rolesdump=reply("dump:$domain:$username:roles",$authhost);
431: if (($rolesdump eq 'con_lost') || ($rolesdump eq '')) { return ''; }
432: my %allroles=();
433: my %thesepriv=();
434: my $now=time;
435: my $userroles="user.login.time=$now\n";
436: my $thesestr;
437:
438: if ($rolesdump ne '') {
439: map {
440: if ($_!~/^rolesdef\&/) {
441: my ($area,$role)=split(/=/,$_);
442: $area=~s/\_\w\w$//;
443: my ($trole,$tend,$tstart)=split(/_/,$role);
444: $userroles.='user.role.'.$trole.'.'.$area.'='.
445: $tstart.'.'.$tend."\n";
446: if ($tend!=0) {
447: if ($tend<$now) {
448: $trole='';
449: }
450: }
451: if ($tstart!=0) {
452: if ($tstart>$now) {
453: $trole='';
454: }
455: }
456: if (($area ne '') && ($trole ne '')) {
457: my ($tdummy,$tdomain,$trest)=split(/\//,$area);
458: if ($trole =~ /^cr\//) {
459: my ($rdummy,$rdomain,$rauthor,$rrole)=split(/\//,$trole);
460: my $homsvr=homeserver($rauthor,$rdomain);
461: if ($hostname{$homsvr} ne '') {
462: my $roledef=
463: reply("get:$rdomain:$rauthor:roles:rolesdef_$rrole",
464: $homsvr);
465: if (($roledef ne 'con_lost') && ($roledef ne '')) {
466: my ($syspriv,$dompriv,$coursepriv)=
467: split(/\_/,unescape($roledef));
468: $allroles{'/'}.=':'.$syspriv;
469: if ($tdomain ne '') {
470: $allroles{'/'.$tdomain.'/'}.=':'.$dompriv;
471: if ($trest ne '') {
472: $allroles{$area}.=':'.$coursepriv;
473: }
474: }
475: }
476: }
477: } else {
478: $allroles{'/'}.=':'.$pr{$trole.':s'};
479: if ($tdomain ne '') {
480: $allroles{'/'.$tdomain.'/'}.=':'.$pr{$trole.':d'};
481: if ($trest ne '') {
482: $allroles{$area}.=':'.$pr{$trole.':c'};
483: }
484: }
485: }
486: }
487: }
488: } split(/&/,$rolesdump);
489: map {
490: %thesepriv=();
491: map {
492: if ($_ ne '') {
493: my ($priviledge,$restrictions)=split(/&/,$_);
494: if ($restrictions eq '') {
495: $thesepriv{$priviledge}='F';
496: } else {
497: if ($thesepriv{$priviledge} ne 'F') {
498: $thesepriv{$priviledge}.=$restrictions;
499: }
500: }
501: }
502: } split(/:/,$allroles{$_});
503: $thesestr='';
504: map { $thesestr.=':'.$_.'&'.$thesepriv{$_}; } keys %thesepriv;
505: $userroles.='user.priv.'.$_.'='.$thesestr."\n";
506: } keys %allroles;
507: }
508: return $userroles;
509: }
510:
511: # --------------------------------------------------------------- get interface
512:
513: sub get {
514: my ($namespace,@storearr)=@_;
515: my $items='';
516: map {
517: $items.=escape($_).'&';
518: } @storearr;
519: $items=~s/\&$//;
520: my $rep=reply("get:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",
521: $ENV{'user.home'});
522: my @pairs=split(/\&/,$rep);
523: my %returnhash=();
524: map {
525: my ($key,$value)=split(/=/,$_);
526: $returnhash{unespace($key)}=unescape($value);
527: } @pairs;
528: return %returnhash;
529: }
530:
531: # -------------------------------------------------------------- dump interface
532:
533: sub dump {
534: my $namespace=shift;
535: my $rep=reply("dump:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace",
536: $ENV{'user.home'});
537: my @pairs=split(/\&/,$rep);
538: my %returnhash=();
539: map {
540: my ($key,$value)=split(/=/,$_);
541: $returnhash{unespace($key)}=unescape($value);
542: } @pairs;
543: return %returnhash;
544: }
545:
546: # --------------------------------------------------------------- put interface
547:
548: sub put {
549: my ($namespace,%storehash)=@_;
550: my $items='';
551: map {
552: $items.=escape($_).'='.escape($storehash{$_}).'&';
553: } keys %storehash;
554: $items=~s/\&$//;
555: return reply("put:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",
556: $ENV{'user.home'});
557: }
558:
559: # -------------------------------------------------------------- eget interface
560:
561: sub eget {
562: my ($namespace,@storearr)=@_;
563: my $items='';
564: map {
565: $items.=escape($_).'&';
566: } @storearr;
567: $items=~s/\&$//;
568: my $rep=reply("eget:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",
569: $ENV{'user.home'});
570: my @pairs=split(/\&/,$rep);
571: my %returnhash=();
572: map {
573: my ($key,$value)=split(/=/,$_);
574: $returnhash{unespace($key)}=unescape($value);
575: } @pairs;
576: return %returnhash;
577: }
578:
579: # ------------------------------------------------- Check for a user priviledge
580:
581: sub allowed {
582: my ($priv,$uri)=@_;
583: $uri=~s/^\/res//;
584: $uri=~s/^\///;
585: if ($uri=~/^adm\//) {
586: return 'F';
587: }
588: my $thisallowed='';
589: if ($ENV{'user.priv./'}=~/$priv\&([^\:]*)/) {
590: $thisallowed.=$1;
591: }
592: if ($ENV{'user.priv./'.(split(/\//,$uri))[0].'/'}=~/$priv\&([^\:]*)/) {
593: $thisallowed.=$1;
594: }
595: if ($ENV{'user.priv./'.$uri}=~/$priv\&([^\:]*)/) {
596: $thisallowed.=$1;
597: }
598: return $thisallowed;
599: }
600:
601: # ----------------------------------------------------------------- Define Role
602:
603: sub definerole {
604: if (allowed('mcr','/')) {
605: my ($rolename,$sysrole,$domrole,$courole)=@_;
606: map {
607: my ($crole,$cqual)=split(/\&/,$_);
608: if ($pr{'cr:s'}!~/$crole/) { return "refused:s:$crole"; }
609: if ($pr{'cr:s'}=~/$crole\&/) {
610: if ($pr{'cr:s'}!~/$crole\&\w*$cqual/) {
611: return "refused:s:$crole&$cqual";
612: }
613: }
614: } split('/',$sysrole);
615: map {
616: my ($crole,$cqual)=split(/\&/,$_);
617: if ($pr{'cr:d'}!~/$crole/) { return "refused:d:$crole"; }
618: if ($pr{'cr:d'}=~/$crole\&/) {
619: if ($pr{'cr:d'}!~/$crole\&\w*$cqual/) {
620: return "refused:d:$crole&$cqual";
621: }
622: }
623: } split('/',$domrole);
624: map {
625: my ($crole,$cqual)=split(/\&/,$_);
626: if ($pr{'cr:c'}!~/$crole/) { return "refused:c:$crole"; }
627: if ($pr{'cr:c'}=~/$crole\&/) {
628: if ($pr{'cr:c'}!~/$crole\&\w*$cqual/) {
629: return "refused:c:$crole&$cqual";
630: }
631: }
632: } split('/',$courole);
633: my $command="encrypt:rolesput:$ENV{'user.domain'}:$ENV{'user.name'}:".
634: "$ENV{'user.domain'}:$ENV{'user.name'}:".
635: "rolesdef_$rolename=".
636: escape($sysrole.'_'.$domrole.'_'.$courole);
637: return reply($command,$ENV{'user.home'});
638: } else {
639: return 'refused';
640: }
641: }
642:
643: # ------------------------------------------------------------------ Plain Text
644:
645: sub plaintext {
646: my $short=shift;
647: return $prp{$short};
648: }
649:
650: # ------------------------------------------------------------------ Plain Text
651:
652: sub fileembstyle {
653: my $ending=shift;
654: return $fe{$ending};
655: }
656:
657: # ------------------------------------------------------------ Description Text
658:
659: sub filedecription {
660: my $ending=shift;
661: return $fd{$ending};
662: }
663:
664: # ----------------------------------------------------------------- Assign Role
665:
666: sub assignrole {
667: my ($udom,$uname,$url,$role,$end,$start)=@_;
668: my $mrole;
669: if ($role =~ /^cr\//) {
670: unless ($url=~/\.course$/) { return 'invalid'; }
671: unless (allowed('ccr',$url)) { return 'refused'; }
672: $mrole='cr';
673: } else {
674: unless (($url=~/\.course$/) || ($url=~/\/$/)) { return 'invalid'; }
675: unless (allowed('c'+$role)) { return 'refused'; }
676: $mrole=$role;
677: }
678: my $command="encrypt:rolesput:$ENV{'user.domain'}:$ENV{'user.name'}:".
679: "$udom:$uname:$url".'_'."$mrole=$role";
680: if ($end) { $command.='_$end'; }
681: if ($start) {
682: if ($end) {
683: $command.='_$start';
684: } else {
685: $command.='_0_$start';
686: }
687: }
688: return &reply($command,&homeserver($uname,$udom));
689: }
690:
691: # ---------------------------------------------------------- Assign Custom Role
692:
693: sub assigncustomrole {
694: my ($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start)=@_;
695: return &assignrole($udom,$uname,$url,'cr/'.$rdom.'/'.$rnam.'/'.$rolename,
696: $end,$start);
697: }
698:
699: # ----------------------------------------------------------------- Revoke Role
700:
701: sub revokerole {
702: my ($udom,$uname,$url,$role)=@_;
703: my $now=time;
704: return &assignrole($udom,$uname,$url,$role,$now);
705: }
706:
707: # ---------------------------------------------------------- Revoke Custom Role
708:
709: sub revokecustomrole {
710: my ($udom,$uname,$url,$rdom,$rnam,$rolename)=@_;
711: my $now=time;
712: return &assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$now);
713: }
714:
715: # ------------------------------------------------------------ Directory lister
716:
717: sub dirlist {
718: my $uri=shift;
719: $uri=~s/^\///;
720: $uri=~s/\/$//;
721: my ($res,$udom,$uname,@rest)=split(/\//,$uri);
722: if ($udom) {
723: if ($uname) {
724: my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/'.$uri,
725: homeserver($uname,$udom));
726: return split(/:/,$listing);
727: } else {
728: my $tryserver;
729: my %allusers=();
730: foreach $tryserver (keys %libserv) {
731: if ($hostdom{$tryserver} eq $udom) {
732: my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/res/'.$udom,
733: $tryserver);
734: if (($listing ne 'no_such_dir') && ($listing ne 'empty')
735: && ($listing ne 'con_lost')) {
736: map {
737: my ($entry,@stat)=split(/&/,$_);
738: $allusers{$entry}=1;
739: } split(/:/,$listing);
740: }
741: }
742: }
743: my $alluserstr='';
744: map {
745: $alluserstr.=$_.'&user:';
746: } sort keys %allusers;
747: $alluserstr=~s/:$//;
748: return split(/:/,$alluserstr);
749: }
750: } else {
751: my $tryserver;
752: my %alldom=();
753: foreach $tryserver (keys %libserv) {
754: $alldom{$hostdom{$tryserver}}=1;
755: }
756: my $alldomstr='';
757: map {
758: $alldomstr.=$perlvar{'lonDocRoot'}.'/res/'.$_.'&domain:';
759: } sort keys %alldom;
760: $alldomstr=~s/:$//;
761: return split(/:/,$alldomstr);
762: }
763: }
764:
765: # -------------------------------------------------------- Value of a Condition
766:
767: sub condval {
768: my $condidx=shift;
769: my $result=0;
770: if ($ENV{'request.course'}) {
771: if ($ENV{'acc.cond.'.$ENV{'request.course'}.'.'.$condidx}) {
772: my $operand='|';
773: my @stack;
774: map {
775: if ($_ eq '(') {
776: push @stack,($operand,$result)
777: } elsif ($_ eq ')') {
778: my $before=pop @stack;
779: if (pop @stack eq '&') {
780: $result=$result>$before?$before:$result;
781: } else {
782: $result=$result>$before?$result:$before;
783: }
784: } elsif (($_ eq '&') || ($_ eq '|')) {
785: $operand=$_;
786: } else {
787: my $new=
788: substr($ENV{'user.state.'.$ENV{'request.course'}},$_,1);
789: if ($operand eq '&') {
790: $result=$result>$new?$new:$result;
791: } else {
792: $result=$result>$new?$result:$new;
793: }
794: }
795: } ($ENV{'acc.cond.'.$ENV{'request.course'}.'.'.$condidx}=~
796: /(\d+|\(|\)|\&|\|)/g);
797: }
798: }
799: return $result;
800: }
801:
802: # -------------------------------------------------------- Escape Special Chars
803:
804: sub escape {
805: my $str=shift;
806: $str =~ s/(\W)/"%".unpack('H2',$1)/eg;
807: return $str;
808: }
809:
810: # ----------------------------------------------------- Un-Escape Special Chars
811:
812: sub unescape {
813: my $str=shift;
814: $str =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C",hex($1))/eg;
815: return $str;
816: }
817:
818: # ================================================================ Main Program
819:
820: sub BEGIN {
821: if ($readit ne 'done') {
822: # ------------------------------------------------------------ Read access.conf
823: {
824: my $config=Apache::File->new("/etc/httpd/conf/access.conf");
825:
826: while (my $configline=<$config>) {
827: if ($configline =~ /PerlSetVar/) {
828: my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);
829: chomp($varvalue);
830: $perlvar{$varname}=$varvalue;
831: }
832: }
833: }
834:
835: # ------------------------------------------------------------- Read hosts file
836: {
837: my $config=Apache::File->new("$perlvar{'lonTabDir'}/hosts.tab");
838:
839: while (my $configline=<$config>) {
840: my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
841: $hostname{$id}=$name;
842: $hostdom{$id}=$domain;
843: if ($role eq 'library') { $libserv{$id}=$name; }
844: }
845: }
846:
847: # ------------------------------------------------------ Read spare server file
848: {
849: my $config=Apache::File->new("$perlvar{'lonTabDir'}/spare.tab");
850:
851: while (my $configline=<$config>) {
852: chomp($configline);
853: if (($configline) && ($configline ne $perlvar{'lonHostID'})) {
854: $spareid{$configline}=1;
855: }
856: }
857: }
858: # ------------------------------------------------------------ Read permissions
859: {
860: my $config=Apache::File->new("$perlvar{'lonTabDir'}/roles.tab");
861:
862: while (my $configline=<$config>) {
863: chomp($configline);
864: my ($role,$perm)=split(/ /,$configline);
865: if ($perm ne '') { $pr{$role}=$perm; }
866: }
867: }
868:
869: # -------------------------------------------- Read plain texts for permissions
870: {
871: my $config=Apache::File->new("$perlvar{'lonTabDir'}/rolesplain.tab");
872:
873: while (my $configline=<$config>) {
874: chomp($configline);
875: my ($short,$plain)=split(/:/,$configline);
876: if ($plain ne '') { $prp{$short}=$plain; }
877: }
878: }
879:
880: # ------------------------------------------------------------- Read file types
881: {
882: my $config=Apache::File->new("$perlvar{'lonTabDir'}/filetypes.tab");
883:
884: while (my $configline=<$config>) {
885: chomp($configline);
886: my ($ending,$emb,@descr)=split(/\s+/,$configline);
887: if ($descr[0] ne '') {
888: $fe{$ending}=$emb;
889: $fd{$ending}=join(' ',@descr);
890: }
891: }
892: }
893:
894:
895: $readit='done';
896: &logthis('<font color=yellow>INFO: Read configuration</font>');
897: }
898: }
899: 1;
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to lonnet.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / lonnet / perl