]> git.p6c8.net - devedit.git/blob - modules/Command.pm
Changed my email address (patshaping@gmx.net -> patrick@patshaping.de) in all
[devedit.git] / modules / Command.pm
1 package Command;
2
3 #
4 # Dev-Editor - Module Command
5 #
6 # Execute Dev-Editor's commands
7 #
8 # Author: Patrick Canterino <patrick@patshaping.de>
9 # Last modified: 2004-11-26
10 #
11
12 use strict;
13
14 use vars qw(@EXPORT);
15
16 use File::Access;
17 use File::Copy;
18 use File::Path;
19
20 use POSIX qw(strftime);
21 use Tool;
22
23 use CGI qw(header);
24 use HTML::Entities;
25 use Output;
26 use Template;
27
28 my $script = $ENV{'SCRIPT_NAME'};
29 my $users = eval("getpwuid(0)") && eval("getgrgid(0)");
30
31 my %dispatch = ('show' => \&exec_show,
32 'beginedit' => \&exec_beginedit,
33 'canceledit' => \&exec_canceledit,
34 'endedit' => \&exec_endedit,
35 'mkdir' => \&exec_mkdir,
36 'mkfile' => \&exec_mkfile,
37 'upload' => \&exec_upload,
38 'copy' => \&exec_copy,
39 'rename' => \&exec_rename,
40 'remove' => \&exec_remove,
41 'chprop' => \&exec_chprop,
42 'unlock' => \&exec_unlock,
43 'about' => \&exec_about
44 );
45
46 ### Export ###
47
48 use base qw(Exporter);
49
50 @EXPORT = qw(exec_command);
51
52 # exec_command()
53 #
54 # Execute the specified command
55 #
56 # Params: 1. Command to execute
57 # 2. Reference to user input hash
58 # 3. Reference to config hash
59 #
60 # Return: Output of the command (Scalar Reference)
61
62 sub exec_command($$$)
63 {
64 my ($command,$data,$config) = @_;
65
66 foreach(keys(%dispatch))
67 {
68 if(lc($_) eq lc($command))
69 {
70 my $output = &{$dispatch{$_}}($data,$config);
71 return $output;
72 }
73 }
74
75 return error($config->{'errors'}->{'cmd_unknown'},'/',{COMMAND => $command});
76 }
77
78 # exec_show()
79 #
80 # View a directory or a file
81 #
82 # Params: 1. Reference to user input hash
83 # 2. Reference to config hash
84 #
85 # Return: Output of the command (Scalar Reference)
86
87 sub exec_show($$)
88 {
89 my ($data,$config) = @_;
90 my $physical = $data->{'physical'};
91 my $virtual = $data->{'virtual'};
92 my $upper_path = upper_path($virtual);
93 my $uselist = $data->{'uselist'};
94
95 my $tpl = new Template;
96
97 if(-d $physical)
98 {
99 # Create directory listing
100
101 return error($config->{'errors'}->{'no_dir_access'},$upper_path) unless(-r $physical && -x $physical);
102
103 my $direntries = dir_read($physical);
104 return error($config->{'dir_read_fail'},$upper_path,{DIR => $virtual}) unless($direntries);
105
106 my $files = $direntries->{'files'};
107 my $dirs = $direntries->{'dirs'};
108
109 my $dir_writeable = -w $physical;
110
111 my $dirlist = "";
112
113 # Create the link to the upper directory
114 # (only if we are not in the root directory)
115
116 unless($virtual eq "/")
117 {
118 my @stat = stat($physical."/..");
119
120 my $udtpl = new Template;
121 $udtpl->read_file($config->{'templates'}->{'dirlist_up'});
122
123 $udtpl->fillin("UPPER_DIR",encode_entities($upper_path));
124 $udtpl->fillin("DATE",encode_entities(strftime($config->{'timeformat'},localtime($stat[9]))));
125
126 $dirlist .= $udtpl->get_template;
127 }
128
129 # Directories
130
131 foreach my $dir(@$dirs)
132 {
133 my $phys_path = $physical."/".$dir;
134 my $virt_path = encode_entities($virtual.$dir."/");
135
136 my @stat = stat($phys_path);
137
138 my $dtpl = new Template;
139 $dtpl->read_file($config->{'templates'}->{'dirlist_dir'});
140
141 $dtpl->fillin("DIR",$virt_path);
142 $dtpl->fillin("DIR_NAME",$dir);
143 $dtpl->fillin("DATE",encode_entities(strftime($config->{'timeformat'},localtime($stat[9]))));
144 $dtpl->fillin("URL",equal_url($config->{'httproot'},$virt_path));
145
146 $dtpl->parse_if_block("readable",-r $phys_path && -x $phys_path);
147 $dtpl->parse_if_block("users",$users && -o $phys_path);
148
149 $dirlist .= $dtpl->get_template;
150 }
151
152 # Files
153
154 foreach my $file(@$files)
155 {
156 my $phys_path = $physical."/".$file;
157 my $virt_path = encode_entities($virtual.$file);
158
159 my @stat = stat($phys_path);
160 my $in_use = $uselist->in_use($virtual.$file);
161 my $too_large = $config->{'max_file_size'} && $stat[7] > $config->{'max_file_size'};
162
163 my $ftpl = new Template;
164 $ftpl->read_file($config->{'templates'}->{'dirlist_file'});
165
166 $ftpl->fillin("FILE",$virt_path);
167 $ftpl->fillin("FILE_NAME",$file);
168 $ftpl->fillin("SIZE",$stat[7]);
169 $ftpl->fillin("DATE",encode_entities(strftime($config->{'timeformat'},localtime($stat[9]))));
170 $ftpl->fillin("URL",equal_url($config->{'httproot'},$virt_path));
171
172 $ftpl->parse_if_block("not_readable",not -r $phys_path);
173 $ftpl->parse_if_block("binary",-B $phys_path);
174 $ftpl->parse_if_block("readonly",not -w $phys_path);
175
176 $ftpl->parse_if_block("viewable",-r $phys_path && -T $phys_path && not $too_large);
177 $ftpl->parse_if_block("editable",-r $phys_path && -w $phys_path && -T $phys_path && not $too_large && not $in_use);
178
179 $ftpl->parse_if_block("in_use",$in_use);
180 $ftpl->parse_if_block("unused",not $in_use);
181
182 $ftpl->parse_if_block("too_large",$config->{'max_file_size'} && $stat[7] > $config->{'max_file_size'});
183
184 $ftpl->parse_if_block("users",$users && -o $phys_path);
185
186 $dirlist .= $ftpl->get_template;
187 }
188
189 $tpl->read_file($config->{'templates'}->{'dirlist'});
190
191 $tpl->fillin("DIRLIST",$dirlist);
192 $tpl->fillin("DIR",$virtual);
193 $tpl->fillin("SCRIPT",$script);
194 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
195
196 $tpl->parse_if_block("dir_writeable",$dir_writeable);
197 }
198 else
199 {
200 # View a file
201
202 return error($config->{'errors'}->{'no_view'},$upper_path) unless(-r $physical);
203
204 # Check on binary files
205 # We have to do it in this way, or empty files
206 # will be recognized as binary files
207
208 unless(-T $physical)
209 {
210 # Binary file
211
212 return error($config->{'errors'}->{'binary'},$upper_path);
213 }
214 else
215 {
216 # Text file
217
218 if($config->{'max_file_size'} && -s $physical > $config->{'max_file_size'})
219 {
220 return error($config->{'errors'}->{'file_too_large'},$upper_path,{SIZE => $config->{'max_file_size'}})
221 }
222 else
223 {
224 my $content = file_read($physical);
225 $$content =~ s/\015\012|\012|\015/\n/g;
226
227 $tpl->read_file($config->{'templates'}->{'viewfile'});
228
229 $tpl->fillin("FILE",$virtual);
230 $tpl->fillin("DIR",$upper_path);
231 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
232 $tpl->fillin("SCRIPT",$script);
233
234 $tpl->parse_if_block("editable",-w $physical && $uselist->unused($virtual));
235
236 $tpl->fillin("CONTENT",encode_entities($$content));
237 }
238 }
239 }
240
241 my $output = header(-type => "text/html");
242 $output .= $tpl->get_template;
243
244 return \$output;
245 }
246
247 # exec_beginedit
248 #
249 # Lock a file and display a form to edit it
250 #
251 # Params: 1. Reference to user input hash
252 # 2. Reference to config hash
253 #
254 # Return: Output of the command (Scalar Reference)
255
256 sub exec_beginedit($$)
257 {
258 my ($data,$config) = @_;
259 my $physical = $data->{'physical'};
260 my $virtual = $data->{'virtual'};
261 my $dir = upper_path($virtual);
262 my $uselist = $data->{'uselist'};
263
264 return error($config->{'errors'}->{'editdir'},$dir) if(-d $physical);
265 return error($config->{'errors'}->{'in_use'}, $dir,{FILE => $virtual}) if($uselist->in_use($virtual));
266 return error($config->{'errors'}->{'no_edit'},$dir) unless(-r $physical && -w $physical);
267
268 # Check on binary files
269
270 unless(-T $physical)
271 {
272 # Binary file
273
274 return error($config->{'errors'}->{'binary'},$dir);
275 }
276 else
277 {
278 if($config->{'max_file_size'} && -s $physical > $config->{'max_file_size'})
279 {
280 return error($config->{'errors'}->{'file_too_large'},$dir,{SIZE => $config->{'max_file_size'}})
281 }
282 else
283 {
284 # Text file
285
286 $uselist->add_file($virtual);
287 $uselist->save;
288
289 my $content = file_read($physical);
290 $$content =~ s/\015\012|\012|\015/\n/g;
291
292 my $tpl = new Template;
293 $tpl->read_file($config->{'templates'}->{'editfile'});
294
295 $tpl->fillin("FILE",$virtual);
296 $tpl->fillin("DIR",$dir);
297 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
298 $tpl->fillin("SCRIPT",$script);
299 $tpl->fillin("CONTENT",encode_entities($$content));
300
301 my $output = header(-type => "text/html");
302 $output .= $tpl->get_template;
303
304 return \$output;
305 }
306 }
307 }
308
309 # exec_canceledit()
310 #
311 # Abort file editing
312 #
313 # Params: 1. Reference to user input hash
314 # 2. Reference to config hash
315 #
316 # Return: Output of the command (Scalar Reference)
317
318 sub exec_canceledit($$)
319 {
320 my ($data,$config) = @_;
321 my $virtual = $data->{'virtual'};
322
323 file_unlock($data->{'uselist'},$virtual);
324 return devedit_reload({command => 'show', file => upper_path($virtual)});
325 }
326
327 # exec_endedit()
328 #
329 # Save a file, unlock it and return to directory view
330 #
331 # Params: 1. Reference to user input hash
332 # 2. Reference to config hash
333 #
334 # Return: Output of the command (Scalar Reference)
335
336 sub exec_endedit($$)
337 {
338 my ($data,$config) = @_;
339 my $physical = $data->{'physical'};
340 my $virtual = $data->{'virtual'};
341 my $dir = upper_path($virtual);
342 my $content = $data->{'cgi'}->param('filecontent');
343 my $uselist = $data->{'uselist'};
344
345 # We already unlock the file at the beginning of the
346 # subroutine, because if we have to abort this routine,
347 # the file keeps locked.
348 # Nobody else will access the file during this routine
349 # because of the concept of File::UseList.
350
351 file_unlock($uselist,$virtual);
352
353 # Normalize newlines
354
355 $content =~ s/\015\012|\012|\015/\n/g;
356
357 if($data->{'cgi'}->param('encode_iso'))
358 {
359 # Encode all ISO-8859-1 special chars
360
361 $content = encode_entities($content,"\200-\377");
362 }
363
364 if($data->{'cgi'}->param('saveas') && $data->{'new_physical'} ne '' && $data->{'new_virtual'} ne '')
365 {
366 # Create the new filename
367
368 $physical = $data->{'new_physical'};
369 $virtual = $data->{'new_virtual'};
370
371 # Check if someone else is editing the new file
372
373 return error($config->{'errors'}->{'in_use'},$dir,{FILE => $virtual}) if($uselist->in_use($virtual));
374 }
375
376 return error($config->{'errors'}->{'text_to_binary'},$dir) unless(-T $physical);
377 return error($config->{'errors'}->{'editdir'},$dir) if(-d $physical);
378 return error($config->{'errors'}->{'no_edit'},$dir) if(-e $physical && !(-r $physical && -w $physical));
379
380 if(file_save($physical,\$content))
381 {
382 # Saving of the file was successful - so unlock it!
383
384 return devedit_reload({command => 'show', file => $dir});
385 }
386 else
387 {
388 return error($config->{'errors'}->{'edit_failed'},$dir,{FILE => $virtual});
389 }
390 }
391
392 # exec_mkfile()
393 #
394 # Create a file and return to directory view
395 #
396 # Params: 1. Reference to user input hash
397 # 2. Reference to config hash
398 #
399 # Return: Output of the command (Scalar Reference)
400
401 sub exec_mkfile($$)
402 {
403 my ($data,$config) = @_;
404 my $new_physical = $data->{'new_physical'};
405 my $new_virtual = $data->{'new_virtual'};
406 my $dir = upper_path($new_virtual);
407 $new_virtual = encode_entities($new_virtual);
408
409 if($new_physical)
410 {
411 return error($config->{'errors'}->{'file_exists'},$dir,{FILE => $new_virtual}) if(-e $new_physical);
412
413 file_create($new_physical) or return error($config->{'errors'}->{'mkfile_failed'},$dir,{FILE => $new_virtual});
414 return devedit_reload({command => 'show', file => $dir});
415 }
416 else
417 {
418 my $tpl = new Template;
419 $tpl->read_file($config->{'templates'}->{'mkfile'});
420
421 $tpl->fillin("DIR","/");
422 $tpl->fillin("SCRIPT",$script);
423
424 my $output = header(-type => "text/html");
425 $output .= $tpl->get_template;
426
427 return \$output;
428 }
429 }
430
431 # exec_mkdir()
432 #
433 # Create a directory and return to directory view
434 #
435 # Params: 1. Reference to user input hash
436 # 2. Reference to config hash
437 #
438 # Return: Output of the command (Scalar Reference)
439
440 sub exec_mkdir($$)
441 {
442 my ($data,$config) = @_;
443 my $new_physical = $data->{'new_physical'};
444 my $new_virtual = $data->{'new_virtual'};
445 my $dir = upper_path($new_virtual);
446 $new_virtual = encode_entities($new_virtual);
447
448 return error($config->{'errors'}->{'file_exists'},$dir,{FILE => $new_virtual}) if(-e $new_physical);
449
450 if($new_physical)
451 {
452 mkdir($new_physical,0777) or return error($config->{'errors'}->{'mkdir_failed'},$dir,{DIR => $new_virtual});
453 return devedit_reload({command => 'show', file => $dir});
454 }
455 else
456 {
457 my $tpl = new Template;
458 $tpl->read_file($config->{'templates'}->{'mkdir'});
459
460 $tpl->fillin("DIR","/");
461 $tpl->fillin("SCRIPT",$script);
462
463 my $output = header(-type => "text/html");
464 $output .= $tpl->get_template;
465
466 return \$output;
467 }
468 }
469
470 # exec_upload()
471 #
472 # Upload a file
473 #
474 # Params: 1. Reference to user input hash
475 # 2. Reference to config hash
476 #
477 # Return: Output of the command (Scalar Reference)
478
479 sub exec_upload($$)
480 {
481 my ($data,$config) = @_;
482 my $physical = $data->{'physical'};
483 my $virtual = $data->{'virtual'};
484 my $cgi = $data->{'cgi'};
485
486 return error($config->{'errors'}->{'no_directory'},upper_path($virtual),{FILE => $virtual}) unless(-d $physical);
487 return error($config->{'errors'}->{'dir_no_create'},$virtual,{DIR => $virtual});
488
489 if(my $uploaded_file = $cgi->param('uploaded_file'))
490 {
491 # Process file upload
492
493 my $filename = file_name($uploaded_file);
494 my $file_phys = $physical."/".$filename;
495 my $file_virt = $virtual.$filename;
496
497 return error($config->{'errors'}->{'file_exists'},$virtual,{FILE => $file_virt}) if(-e $file_phys && not $cgi->param('overwrite'));
498
499 my $ascii = $cgi->param('ascii');
500 my $handle = $cgi->upload('uploaded_file');
501
502 local *FILE;
503
504 open(FILE,">".$file_phys) or return error($config->{'errors'}->{'mkfile_failed'},$virtual,{FILE => $file_virt});
505 binmode(FILE) unless($ascii);
506
507 # Read transferred file and write it to disk
508
509 read($handle, my $data, -s $handle);
510 $data =~ s/\015\012|\012|\015/\n/g if($ascii); # Replace line separators if transferring in ASCII mode
511 print FILE $data;
512
513 close(FILE);
514
515 return devedit_reload({command => "show", file => $virtual});
516 }
517 else
518 {
519 my $tpl = new Template;
520 $tpl->read_file($config->{'templates'}->{'upload'});
521
522 $tpl->fillin("DIR",$virtual);
523 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
524 $tpl->fillin("SCRIPT",$script);
525
526 my $output = header(-type => "text/html");
527 $output .= $tpl->get_template;
528
529 return \$output;
530 }
531 }
532
533 # exec_copy()
534 #
535 # Copy a file and return to directory view
536 #
537 # Params: 1. Reference to user input hash
538 # 2. Reference to config hash
539 #
540 # Return: Output of the command (Scalar Reference)
541
542 sub exec_copy($$)
543 {
544 my ($data,$config) = @_;
545 my $physical = $data->{'physical'};
546 my $virtual = encode_entities($data->{'virtual'});
547 my $new_physical = $data->{'new_physical'};
548
549 return error($config->{'errors'}->{'dircopy'},upper_path($virtual)) if(-d $physical);
550 return error($config->{'errors'}->{'no_copy'},upper_path($virtual)) unless(-r $physical);
551
552 if($new_physical)
553 {
554 my $new_virtual = $data->{'new_virtual'};
555 my $dir = upper_path($new_virtual);
556 $new_virtual = encode_entities($new_virtual);
557
558 if(-e $new_physical)
559 {
560 return error($config->{'errors'}->{'exist_edited'},$dir,{FILE => $new_virtual}) if($data->{'uselist'}->in_use($data->{'new_virtual'}));
561
562 if(-d $new_physical)
563 {
564 return error($config->{'errors'}->{'dir_replace'},$dir);
565 }
566 elsif(not $data->{'cgi'}->param('confirmed'))
567 {
568 my $tpl = new Template;
569 $tpl->read_file($config->{'templates'}->{'confirm_replace'});
570
571 $tpl->fillin("FILE",$virtual);
572 $tpl->fillin("NEW_FILE",$new_virtual);
573 $tpl->fillin("NEW_FILENAME",file_name($new_virtual));
574 $tpl->fillin("NEW_DIR",$dir);
575 $tpl->fillin("DIR",upper_path($virtual));
576
577 $tpl->fillin("COMMAND","copy");
578 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
579 $tpl->fillin("SCRIPT",$script);
580
581 my $output = header(-type => "text/html");
582 $output .= $tpl->get_template;
583
584 return \$output;
585 }
586 }
587
588 copy($physical,$new_physical) or return error($config->{'errors'}->{'copy_failed'},upper_path($virtual),{FILE => $virtual, NEW_FILE => $new_virtual});
589 return devedit_reload({command => 'show', file => $dir});
590 }
591 else
592 {
593 my $tpl = new Template;
594 $tpl->read_file($config->{'templates'}->{'copyfile'});
595
596 $tpl->fillin("FILE",$virtual);
597 $tpl->fillin("DIR",upper_path($virtual));
598 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
599 $tpl->fillin("SCRIPT",$script);
600
601 my $output = header(-type => "text/html");
602 $output .= $tpl->get_template;
603
604 return \$output;
605 }
606 }
607
608 # exec_rename()
609 #
610 # Rename/move a file and return to directory view
611 #
612 # Params: 1. Reference to user input hash
613 # 2. Reference to config hash
614 #
615 # Return: Output of the command (Scalar Reference)
616
617 sub exec_rename($$)
618 {
619 my ($data,$config) = @_;
620 my $physical = $data->{'physical'};
621 my $virtual = $data->{'virtual'};
622 my $new_physical = $data->{'new_physical'};
623
624 return error($config->{'errors'}->{'rename_root'},"/") if($virtual eq "/");
625 return error($config->{'errors'}->{'no_rename'},upper_path($virtual)) unless(-w upper_path($physical));
626 return error($config->{'errors'}->{'in_use'},upper_path($virtual),{FILE => $virtual}) if($data->{'uselist'}->in_use($virtual));
627
628 if($new_physical)
629 {
630 my $new_virtual = $data->{'new_virtual'};
631 my $dir = upper_path($new_virtual);
632 $new_virtual = encode_entities($new_virtual);
633
634 if(-e $new_physical)
635 {
636 return error($config->{'errors'}->{'exist_edited'},$dir,{FILE => $new_virtual}) if($data->{'uselist'}->in_use($data->{'new_virtual'}));
637
638 if(-d $new_physical)
639 {
640 return error($config->{'errors'}->{'dir_replace'},$dir);
641 }
642 elsif(not $data->{'cgi'}->param('confirmed'))
643 {
644 my $tpl = new Template;
645 $tpl->read_file($config->{'templates'}->{'confirm_replace'});
646
647 $tpl->fillin("FILE",$virtual);
648 $tpl->fillin("NEW_FILE",$new_virtual);
649 $tpl->fillin("NEW_FILENAME",file_name($new_virtual));
650 $tpl->fillin("NEW_DIR",$dir);
651 $tpl->fillin("DIR",upper_path($virtual));
652
653 $tpl->fillin("COMMAND","rename");
654 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
655 $tpl->fillin("SCRIPT",$script);
656
657 my $output = header(-type => "text/html");
658 $output .= $tpl->get_template;
659
660 return \$output;
661 }
662 }
663
664 rename($physical,$new_physical) or return error($config->{'errors'}->{'rename_failed'},upper_path($virtual),{FILE => $virtual, NEW_FILE => $new_virtual});
665 return devedit_reload({command => 'show', file => $dir});
666 }
667 else
668 {
669 my $tpl = new Template;
670 $tpl->read_file($config->{'templates'}->{'renamefile'});
671
672 $tpl->fillin("FILE",$virtual);
673 $tpl->fillin("DIR",upper_path($virtual));
674 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
675 $tpl->fillin("SCRIPT",$script);
676
677 my $output = header(-type => "text/html");
678 $output .= $tpl->get_template;
679
680 return \$output;
681 }
682 }
683
684 # exec_remove()
685 #
686 # Remove a file or a directory and return to directory view
687 #
688 # Params: 1. Reference to user input hash
689 # 2. Reference to config hash
690 #
691 # Return: Output of the command (Scalar Reference)
692
693 sub exec_remove($$)
694 {
695 my ($data,$config) = @_;
696 my $physical = $data->{'physical'};
697 my $virtual = $data->{'virtual'};
698
699 return error($config->{'errors'}->{'remove_root'},"/") if($virtual eq "/");
700 return error($config->{'errors'}->{'no_delete'},upper_path($virtual)) unless(-w upper_path($physical));
701
702 if(-d $physical)
703 {
704 # Remove a directory
705
706 if($data->{'cgi'}->param('confirmed'))
707 {
708 rmtree($physical);
709 return devedit_reload({command => 'show', file => upper_path($virtual)});
710 }
711 else
712 {
713 my $tpl = new Template;
714 $tpl->read_file($config->{'templates'}->{'confirm_rmdir'});
715
716 $tpl->fillin("DIR",$virtual);
717 $tpl->fillin("UPPER_DIR",upper_path($virtual));
718 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
719 $tpl->fillin("SCRIPT",$script);
720
721 my $output = header(-type => "text/html");
722 $output .= $tpl->get_template;
723
724 return \$output;
725 }
726 }
727 else
728 {
729 # Remove a file
730
731 return error($config->{'errors'}->{'in_use'},upper_path($virtual),{FILE => $virtual}) if($data->{'uselist'}->in_use($virtual));
732
733 if($data->{'cgi'}->param('confirmed'))
734 {
735 unlink($physical) or return error($config->{'errors'}->{'delete_failed'},upper_path($virtual),{FILE => $virtual});
736 return devedit_reload({command => 'show', file => upper_path($virtual)});
737 }
738 else
739 {
740 my $tpl = new Template;
741 $tpl->read_file($config->{'templates'}->{'confirm_rmfile'});
742
743 $tpl->fillin("FILE",$virtual);
744 $tpl->fillin("DIR",upper_path($virtual));
745 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
746 $tpl->fillin("SCRIPT",$script);
747
748 my $output = header(-type => "text/html");
749 $output .= $tpl->get_template;
750
751 return \$output;
752 }
753 }
754 }
755
756 # exec_chprop()
757 #
758 # Change the mode and the group of a file or a directory
759 #
760 # Params: 1. Reference to user input hash
761 # 2. Reference to config hash
762 #
763 # Return: Output of the command (Scalar Reference)
764
765 sub exec_chprop($$)
766 {
767 my ($data,$config) = @_;
768 my $physical = $data->{'physical'};
769 my $virtual = $data->{'virtual'};
770 my $dir = upper_path($virtual);
771 my $cgi = $data->{'cgi'};
772 my $mode = $cgi->param('mode');
773 my $group = $cgi->param('group');
774
775 if($users)
776 {
777 # System supports user and groups
778
779 if(-o $physical)
780 {
781 # We own this file
782
783 if($mode || $group)
784 {
785 if($mode)
786 {
787 # Change the mode
788
789 chmod(oct($mode),$physical);
790 }
791
792 if($group)
793 {
794 # Change the group using the `chgrp` system command
795
796 return error($config->{'errors'}->{'invalid_group'},$dir,{GROUP => encode_entities($group)}) unless($group =~ /^[a-z0-9_]+[a-z0-9_-]*$/i);
797 system("chgrp",$group,$physical);
798 }
799
800 return devedit_reload({command => 'show', file => $dir});
801 }
802 else
803 {
804 # Display the form
805
806 my @stat = stat($physical);
807
808 my $mode = $stat[2];
809 my $mode_oct = substr(sprintf("%04o",$mode),-4);
810 my $gid = $stat[5];
811
812 my $tpl = new Template;
813 $tpl->read_file($config->{'templates'}->{'chprop'});
814
815 # Insert file properties into the template
816
817 $tpl->fillin("MODE_OCTAL",$mode_oct);
818 $tpl->fillin("MODE_STRING",mode_string($mode));
819 $tpl->fillin("GID",$gid);
820
821 if(my $group = getgrgid($gid))
822 {
823 $tpl->fillin("GROUP",encode_entities($group));
824 $tpl->parse_if_block("group_detected",1);
825 }
826 else
827 {
828 $tpl->parse_if_block("group_detected",0);
829 }
830
831 # Insert other information
832
833 $tpl->fillin("FILE",$virtual);
834 $tpl->fillin("DIR",$dir);
835 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
836 $tpl->fillin("SCRIPT",$script);
837
838 my $output = header(-type => "text/html");
839 $output .= $tpl->get_template;
840
841 return \$output;
842 }
843 }
844 else
845 {
846 return error($config->{'errors'}->{'not_owner'},$dir,{FILE => $virtual});
847 }
848 }
849 else
850 {
851 return error($config->{'errors'}->{'no_users'},$dir,{FILE => $virtual});
852 }
853 }
854
855 # exec_unlock()
856 #
857 # Remove a file from the list of used files and
858 # return to directory view
859 #
860 # Params: 1. Reference to user input hash
861 # 2. Reference to config hash
862 #
863 # Return: Output of the command (Scalar Reference)
864
865 sub exec_unlock($$)
866 {
867 my ($data,$config) = @_;
868 my $virtual = $data->{'virtual'};
869 my $uselist = $data->{'uselist'};
870
871 return devedit_reload({command => 'show', file => upper_path($virtual)}) if($uselist->unused($virtual));
872
873 if($data->{'cgi'}->param('confirmed'))
874 {
875 file_unlock($uselist,$virtual);
876 return devedit_reload({command => 'show', file => upper_path($virtual)});
877 }
878 else
879 {
880 my $tpl = new Template;
881 $tpl->read_file($config->{'templates'}->{'confirm_unlock'});
882
883 $tpl->fillin("FILE",$virtual);
884 $tpl->fillin("DIR",upper_path($virtual));
885 $tpl->fillin("URL",equal_url($config->{'httproot'},$virtual));
886 $tpl->fillin("SCRIPT",$script);
887
888 my $output = header(-type => "text/html");
889 $output .= $tpl->get_template;
890
891 return \$output;
892 }
893 }
894
895 # exec_about()
896 #
897 # Display some information about Dev-Editor
898 #
899 # Params: 1. Reference to user input hash
900 # 2. Reference to config hash
901 #
902 # Return: Output of the command (Scalar Reference)
903
904 sub exec_about($$)
905 {
906 my ($data,$config) = @_;
907
908 my $tpl = new Template;
909 $tpl->read_file($config->{'templates'}->{'about'});
910
911 $tpl->fillin("SCRIPT",$script);
912
913 # Dev-Editor's version number
914
915 $tpl->fillin("VERSION",$data->{'version'});
916
917 # Some path information
918
919 $tpl->fillin("SCRIPT_PHYS",encode_entities($ENV{'SCRIPT_FILENAME'}));
920 $tpl->fillin("CONFIG_PATH",encode_entities($data->{'configfile'}));
921 $tpl->fillin("FILE_ROOT", encode_entities($config->{'fileroot'}));
922 $tpl->fillin("HTTP_ROOT", encode_entities($config->{'httproot'}));
923
924 # Perl
925
926 $tpl->fillin("PERL_PROG",encode_entities($^X));
927 $tpl->fillin("PERL_VER",sprintf("%vd",$^V));
928
929 # Information about the server
930
931 $tpl->fillin("HTTPD",encode_entities($ENV{'SERVER_SOFTWARE'}));
932 $tpl->fillin("OS",$^O);
933 $tpl->fillin("TIME",encode_entities(strftime($config->{'timeformat'},localtime)));
934
935 # Process information
936
937 $tpl->fillin("PID",$$);
938
939 # Check if the functions getpwuid() and getgrgid() are available
940
941 if($users)
942 {
943 # Dev-Editor is running on a system which allows users and groups
944 # So we display the user and the group of our process
945
946 my $uid = POSIX::getuid;
947 my $gid = POSIX::getgid;
948
949 $tpl->parse_if_block("users",1);
950
951 # ID's of user and group
952
953 $tpl->fillin("UID",$uid);
954 $tpl->fillin("GID",$gid);
955
956 # Names of user and group
957
958 if(my $user = getpwuid($uid))
959 {
960 $tpl->fillin("USER",encode_entities($user));
961 $tpl->parse_if_block("user_detected",1);
962 }
963 else
964 {
965 $tpl->parse_if_block("user_detected",0);
966 }
967
968 if(my $group = getgrgid($gid))
969 {
970 $tpl->fillin("GROUP",encode_entities($group));
971 $tpl->parse_if_block("group_detected",1);
972 }
973 else
974 {
975 $tpl->parse_if_block("group_detected",0);
976 }
977
978 # Process umask
979
980 $tpl->fillin("UMASK",sprintf("%04o",umask));
981 }
982 else
983 {
984 $tpl->parse_if_block("users",0);
985 }
986
987 my $output = header(-type => "text/html");
988 $output .= $tpl->get_template;
989
990 return \$output;
991 }
992
993 # it's true, baby ;-)
994
995 1;
996
997 #
998 ### End ###

patrick-canterino.de