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