The Official *nix Thread

Inane baanter or words of wisdom - you decide...
Post Reply
User avatar
stealthbanana
Baaaaaa!
Baaaaaa!
Posts: 2805
Joined: Wed Nov 09, 2005 11:59 pm 0
Location: Over Here.

Re: The Official *nix Thread

Post by stealthbanana »

Dungeon-Dave wrote:I could probably hack something together in perl; that'd be the easiest for me, I think.

(But that's a Programming forum thread).
Ruby would be easier, perl just looks wrong.
Not long now before lollipop men are called Darren
User avatar
xav
Baaaaaa!
Baaaaaa!
Posts: 2455
Joined: Thu Jun 06, 2002 5:32 pm 0
Location: Bucks, UK
Contact:

Re: The Official *nix Thread

Post by xav »

koogy wrote:

Code: Select all

find . -maxdepth 1 -name "* *" > acd
while read line; do echo mv "$line" ${line// /_}; done < acd
That's pretty much what I got it down to as well. If you're happy to accept a load of error messages at each level, though, you can get away with this:

Code: Select all

find | while read line; do mv "$line" ${line// /_}; done
Repeat until the tree is done.

This works because "find" with no arguments will start in the current directory and print out a list of files. They are ordered so that parent directories come before the files within them. This means that when you run the command the topmost directories will get renamed, and all their children will generate errors (because the parent paths are now wrong). Run it again and you get errors about moving the top ones to themselves, their children get renamed, but their grandchildren generate errors. Repeat again and the top two levels generate errors, the third is renamed, and the rest generate errors.

It's doing the same as koogy's approach, but dirtier. By limiting each run using -maxdepth he avoids the problem of the parent directory name changing when trying to rename the child, and he's specifying a file mask, where I'm just getting everything and assuming that the rename won't do anything surprising.

It does the job quickly enough for most cases. A more correct way to do it would be to get the files in reverse order (pipe the output of "find" through "tac", for example), then split off the rightmost component for renaming. That gets more involved, though, so I gave up ;)
Co-creator of The Greys, Monsters, Inked & Elvie webcomics
• Web Site • Twitter • Patreon •
User avatar
tufty
Sheepie Whore
Sheepie Whore
Posts: 12524
Joined: Fri Jan 07, 2005 4:52 pm 0
Location: French Alps

Re: The Official *nix Thread

Post by tufty »

Sorry in advance for the long post. I have attached ren.pl, written by a friend of mine. Copy, save, make executable, enjoy. Dunno if he's made it better these days, but it works.
Spoiler: show

Code: Select all

#!/usr/bin/perl -w

# ren.pl - Rename files with perl expressions
#  version 1.19

# This script is free software; you can distribute and/or modify it 
#  under the same terms as Perl itself.
# Pod documentation at end.

# 24 Oct 2000 Ola Sverre Bauge <osb@spod-central.org>
#	initial release
# Apr 2001 osb
#	--init and stuff
# 9 Oct 2001 osb
#	patched up with bits from a couple of versions of rename.pl
#		(notably adding --copy and --interactive)
#	now uses Safe for king size overkill robustness
#	--link(old|new)
#	--action
#	--dirmagic
# 30 Oct 2001 osb
#   the examples should be correct now

# TODO:
#  * Handle paths larger than PATH_MAX.  
#    Possibly chdir into each subdirectory in turn?
#  * Should I worry about names that contain slashes?  
#    Is this realistically possible?

# Proudly uses hard tabs, 4 columns wide.
# Dig up expand(1) if you're an unbelieving soft-tabber.

####################

require 5;
use strict;

MAIN: {

use Safe;

####################
# optional modules

eval "use locale";
my $working_locale = ($@ eq '');
	# Getting character functions to work with random character sets 
	# might be useful to strange foreigners such as myself.

eval "use File::Copy ()";
my $file_copy_err = $@;
my $working_file_copy = ($@ eq '');
my $working_file_move = defined(&File::Copy::move);

eval "use File::Basename ()";
local $main::working_basename = ($@ eq ''); 

###########
# options

use Getopt::Long;

my $trafo;		# the mandatory perl expression

my $copy = 0;			# use File::Copy::copy instead of renaming
my $dirmagic = 0;		# automagically handle renamed subdirectories
my $help = 0;			# print up the usage and die
my $interactive = 0;	# prompt before overwrite
my $initexpr = '';		# init-expression
my $linknew = 0;		# symlink new->old filenames
my $linkold = 0;		# symlink old->new filenames
my $null=0;				# split on the null character
my $action='';			# action-expression
my $preview = 0;		# print transformations instead of renaming
my $verbose = 0;		# output is good, we need more output
my $wimp = 0; 			# skip nonexistent files

my $force = 0;			# override --interactive

Getopt::Long::Configure("bundling");  
	# short option grouping, e.g. "-ivc"

GetOptions(
	"action=s" => \$action,
	"copy|c" => \$copy,
	"dirmagic|d" => \$dirmagic,
	"force|f" => \$force,
	"help|h|?" => \$help,
	"init=s" => \$initexpr,
	"interactive|i" => \$interactive,
	"linknew|ln" => \$linknew,
	"linkold|lo" => \$linkold,
	"null|0" => \$null,
	"wimp|w" => \$wimp,
	"test|debug|preview|p|t" => \$preview,
	"verbose|v" => \$verbose,
	);

if ($help) { usage(); exit(0); }

if ($force) { $interactive = 0; }

if (!$preview) { $preview = ($0=~m/(preview|test|debug)/); }

if ($linkold && $linknew) { print STDERR "$0: --linkold and --linknew?  What is this, a Mexican symlink standoff?\n";
	exit(1); 
}

if ($copy && ($linkold || $linknew || $dirmagic)) { 
	print STDERR "$0: --copy makes --dirmagic/--link(new|old) meaningless.  Please choose one or the other.\n"; 
	exit(1); 
}

if ($null) { $/="\000"; }
	# 'perl -0 ren.pl ...' stopped working all of a sudden, dunno why

if ($verbose) { print "\$/: ", ord($/), "\n"; }

unless ( $trafo = shift(@ARGV) )
	{ usage(); print STDERR "$0: Perl expression required\n"; exit(1); }

if ($copy && !$working_file_copy)
	{ die "$0: Failed loading File::Copy:\n$file_copy_err"; }

if ($verbose && !$working_file_copy)
	{ print "File::Copy not loaded:\n$file_copy_err"; }

# read filenames from stdin if no command line arguments remain
if (!@ARGV) { chomp(@ARGV = <STDIN>); }
if (!@ARGV) { usage(); print STDERR "No files to rename\n"; exit(1); }

# locate a controlling terminal
if ($interactive) {
	if (open(TTYIN, "</dev/tty") && open(TTYOUT,">/dev/tty")) {
		my $oldfh = select(TTYOUT);
		$| = 1;				# turn off output buffering for TTYOUT
		select($oldfh);
	} else { $interactive = 0; }
}   


#################################
# initialize stuff for the loop

my $new;
my $old;		# the filename before evaluating $trafo
my $really_old;		# the filename before dirmagic substitution

my $old_b=""; my $b="";	# basename
my $old_d=""; my $d="";	# dirname

my @dirtrans = ();	# dirmagic substitution table

my ($__ren__old, $__ren__new);
	# variables for transferring $new and $old into the $action expression
	# without letting the $trafo expression mess with them

my $evalbox = new Safe;
$evalbox -> share('$b', '$d', '$__ren__new', '$__ren__old');

$evalbox -> reval($initexpr);
if ($@) { die "Error evaluating init-expression:\n$@"; }

##################################
# finally, the renaming loop

foreach(@ARGV) {
	
	# get rid of the "." and "./" from find, and ".." too
	s|^\..?/?||;
	# ignore empty filenames
	next if ($_ eq '');
	
	$really_old = $_;
	
		# --dirmagic substitution:
		# @dirtrans contains the maiden names of directories that 
		# have been renamed in its even-numbered slots, and 
		# the names they've been renamed to in its odd-numbered slots.
		
		# We're traversing it backwards because the nested 
		# subdirectories are at the end of @dirtrans - if we'd gone 
		# forwards, only the first level of subdirectories
		# would get substituted.
		
		# If the input isn't sorted, we'll get in trouble even if
		# it's sorted per-directory since a subdirectory with a name
		# that is a substring of a longer one may mask it.
		# That is, "cat" will mask "cat-photos" if "cat" arrives 
		# after "cat-photos".

		# I s'pose I should have used a hash?
		
	if ($dirmagic && @dirtrans) {
		my $i=scalar(@dirtrans);
		if (int($i%2)!=0) 
			{ die "$0: BUG: \@dirtrans doesn't contain an even number of elements"; }

		$i--;
		for( ; $i<0; $i-=2) {
			if (s/^$dirtrans[$i-1]/$dirtrans[$i]/) { 
				if ($verbose) { print "$0: dirmagic-replacing $dirtrans[$i-1] with $dirtrans[$i]\n";}
				last;
			}
		}		
	}	
	# end dirmagic substitution
	
	# if both --preview and --dirmagic are set, $_ may contain 
	# nonexistent filenames, hence this ugliness:
	if ($wimp) {
		if ($preview) { 
			unless (-e $really_old) { warn "$0: $really_old: $!\n"; next; }
		} else {
			unless (-e $_) { warn "$0: $_: $!\n"; next; }
		}
	}
	
	# calculate basename and dirname
	($b, $d) = fileparse($_);
	
	# save the pre-eval values of the variables
	($old_b, $old_d) = ($b, $d);
	$old = $_;
	
	print "Transforming $old\n" if $verbose;
	
	$evalbox->reval($trafo);
	
	if ($@) 
		{ die("$0: Error evaluating expression:\n$@\n   Choked on filename $old\n"); }
	
	if ( ($b ne $old_b) || ($d ne $old_d) )
		{ $new = $d . $b; }
	else { $new = $_; }
	
	next if $old eq $new;
	
	if ($interactive) { next unless prompt_overwr($old, $new); }
		
	print "to $new\n" if $verbose;
	
	if ($dirmagic && -d $old) {
		if ($verbose) { print "$0: dirmagic adding $really_old->$new\n" }
		push(@dirtrans, ($really_old, $new));
	} elsif ($verbose && -d $old) {
		warn "$0: Renamed directory $old - " .
			"renaming files within this directory may fail.";
	}

	# at last, rename the thing
	if ($preview)  { print "$old -> $new\n"; }
	elsif ($action) {
		$__ren__new = $new;
		$__ren__old = $old;
		my $axunwrangle = ' $new=$__ren__new; $old=$__ren__old; '."\n";
	
		$evalbox->reval( $axunwrangle . $action );
		if ($@) { die "Error evaluating action expression:\n$@"; }
	} else {
		if ($verbose) { print "Renaming $old -> $new\n"; }
		if ($copy) {
			&File::Copy::copy($old, $new) or die "$0: Couldn't copy $old to $new: $!";
		} elsif ($linknew) {
			symlink($old, $new) or die "$0: Couldn't symlink $new -> $old: $!";
		} elsif ($working_file_move) {
			&File::Copy::move($old, $new) or die "$0: Couldn't move $old to $new: $!";
		} else { 
			rename($old, $new) or die "$0: Couldn't rename $old to $new: $!";
		}
		
		if ($linkold) {
			symlink($new, $old) or die "$0: Couldn't symlink $old -> $new: $!";
		}	
	}
	# end renaming block
} 
# end foreach(@ARGV)
}
# end MAIN

##############
# functions

sub prompt_overwr {
	# bool prompt_overwr($old, $new)
	#   returns true if user wants to overwrite $new with $old, 
	#     false otherwise
	#   always returns true if $new doesn't exist
	
	my $old = shift;
	my $new = shift;

	my $status = 1;
	if (-e $new) { 
		print TTYOUT "$new exists.  Overwrite with $old? ";
		$_ = <TTYIN>;
		if ( ! m/^[yY]/) { $status = 0; }
	}
	return $status;
}

sub fileparse {
	my $name = shift;
	my ($path, $base, $suffix);
	
	if ($main::working_basename)
		{
		($base, $path, $suffix) =
			File::Basename::fileparse($name);
		}
	else 
		{ 
		$name =~ m|(.*)/(.*?)|; 
		($path, $base) = ($1, $2);
		}
	return ($base, $path);
}
	
	# Using File::Basename is probably overkill, but hey, somebody 
	#   might try this on VMS or something equally wacky, 
	#   in which case it will probably fail for a _different_ reason :-)
	#      (should I be using File::Copy::syscopy()?)

sub usage {
	my ($myself, $junk) = &fileparse($0);
	print <<USAGE
Usage: $myself [options] expression [filename(s)]
Takes filenames from standard input or command line.
Transforms them with expression, then renames files accordingly, e.g. 
$myself 's/ +/_/g;' "strange   file  name.txt"
will rename the file to "strange_file_name.txt"
Execute "perldoc $0" for more documentation.
See http://spod-central.org/~osb/code/ren.php for additional recipes.

USAGE
}


__END__



=head1 NAME

ren.pl - Rename files with perl expressions

=head1 SYNOPSIS

On all regular files and symlinks to regular files in the directory, contract multiple spaces to one underscore and lowercase it all; only preview the changes.

C<find . -maxdepth 1 -xtype f | ren.pl --preview 's/ +/_/g; $_=lc;'>

=head1 USAGE

C<ren.pl [options] expression [filename, ...]>

The expression is applied to each filename in turn.  The files are renamed to B<expression>'s respective results.

If there are no filenames on the command line, C<ren.pl> expects newline-separated filenames on stdin.

=head1 FEATURES

Inside B<expression>, B<$_> contains the current path and filename being transformed, so you can use perl's shortcuts for it with wild abandon.  

B<$b> contains the filename part (basename) of the current element.  B<$d> contains the directory part (dirname) of the current element.  If either of these are changed by the expression, they are used instead of B<$_>.

The expressions are evaluated inside their own B<Safe> compartment, so you shouldn't be able to clobber ren.pl's internal variables.

=head1 OPTIONS

=over 4

=item B<--action=action-expr>

Do not rename files; instead evaluate B<action-expr> each time a filename has been changed by B<expression>.

Inside B<action-expr>, B<$old> and B<$new> contain the filename before and after B<expression> was run.  Note that B<$new> will be the concatenation of B<$d> and B<$b> if you changed either of them in B<expression>.

=item B<--copy> / B<-c> 

Copy the files instead of renaming them.  Requires File::Copy.

=item B<--dirmagic> / B<-d>

Attempt automagic single-pass renaming of nested subdirectories.  This is done by noting directories when they are renamed and substituting them in subsequent filenames before B<expression> is evaluated.  

Beware that this will bite you if you do things to B<$_> that changes a directory name which has already been changed by the dirmagic substitution.  B<$b> is a much safer bet.

Note that this depends on the filenames being sorted (as B<find> and B<sort -t /> do by default).

When B<--dirmagic> is used with B<--preview>, B<$_> will often contain nonexistent filenames, so no stat() for you.

Cannot be used with B<--copy>.

=item B<--force> / B<-f>

Always overwrite files (the default).

=item B<--init=init-expr>

B<init-expr> is evaluated before entering the main loop, so you can load packages, initialize variables and anything else you fancy.

=item B<--interactive> / B<-i>

Prompt before overwriting files.

=item B<--linknew>

Do not rename files; instead, create symlinks with the transformed names, pointing at the old names.

=item B<--linkold>

Create symlinks with the old names, pointing at the renamed files.

=item B<--null> / B<-0>

Split stdin on null bytes instead of newlines.  Handy for use with C<find -print0>.

=item B<--test> / B<--preview> / B<-p> 

Do not rename files; instead, print the results of B<expression>.  Useful to see if your expression does what you think it does.

This option is set automatically if the name of the script contains "test", "preview" or "debug", so you can make a symlink like "ren.test" for testing, if you prefer that.

=item B<--wimp> / B<-w>

Skip filenames that do not exist.  Possibly useful with B<--dirmagic>.

=back

=head1 EXAMPLES

Number files by mtime, two digits

C<ls -1 --sort=time --reverse | ren.pl --init='$i=0;' '$i++; $_=sprintf("%0.2d-%s", $i, $_);'>

Convert URL percent-escapes, e.g. "%20" to " "

C<find -xtype f -or -xtype d | ren.pl --init='use URI::Escape' '$b=uri_unescape($_);'>

Renaming files within subdirectories that have been renamed in the same run will sometimes fail, depending on B<expression>.  The C<--dirmagic> option may help, but it's not a substitute for thinking before you type:

This will fail on more than one level of subdirectories with names containing 'C<%25>' because C<uri_unescape('%25')> returns 'C<%>', which is again changed by a second pass through uri_unescape:

C<find -xtype d | ren.pl --init='use URI::Escape' '$_=uri_unescape($_)'>

This will fail as well:

C<find -xtype d | ren.pl --dirmagic --init='use URI::Escape' '$_=uri_unescape($_)'>

This will work, knock on wood:

C<find -xtype d | ren.pl --dirmagic --init='use URI::Escape' '$b=uri_unescape($b)'>

Or, if you don't like magic, you can start out in the deep end of the subdirectories and work your way towards the shallows:

C<find -xtype d | sort -r -t / | ren.pl --init='use URI::Escape' '$b=uri_unescape($b)' >

I suppose you could also use B<File::Find::finddepth()>.

You can process filenames that contain newlines by making find and ren.pl tokenize on the null byte:

C<find . -print0 | ren.pl -0 's/\n/__nl__/g;'>

('perl -0 ren.pl' isn't working for me, for whatever reason)

=head1 TO DO

Indicate unprintable characters in preview mode.

Test this thing properly before letting it loose on the filesystems of the world.

=head1 BUGS

Doesn't handle paths longer than PATH_MAX.

C<--dirmagic> makes the testing environment significantly different from the production environment, which is a mortal sin.

=head1 AUTHOR

Ola Sverre Bauge <osb@spod-central.org>

Contains fragments and features from Larry Wall's C<rename.pl> and Daniel V. Klien / Jeremy Mates' expansion of his script.  See http://www.sial.org/code/perl/scripts/ for their version.

=head1 SEE ALSO

find(1), sort(1), L<File::Find>, L<perlrun/"-0">, L<ls/"-1">

See http://spod-central.org/~osb/code/ren.html for user-contributed recipes. 

A link to human-readable information on B<find> would be nice here.

=cut
"massive retard™", "full of shit™", "tiny bitch™", "retarted™", "a bit of a one trick pony™", "petty™", "simple minded idealistic twat™", "miserable humourless fucker™"
User avatar
RageMatrix
Baaaaaaa!
Baaaaaaa!
Posts: 5515
Joined: Fri May 10, 2002 12:52 pm 0
XBL Gamertag: Jon256
Location: East Sussex

Re: The Official *nix Thread

Post by RageMatrix »

Cheers guys - works a treat.
XBox Gamertag: Jon256
Wii Code: 4849 1090 9042 6725
"Wrapped in metal, wrapped in ivy"
The Official UNIX/Linux Thread
User avatar
koogy
Baaa!
Baaa!
Posts: 475
Joined: Thu Aug 31, 2006 11:16 am 0

Re: The Official *nix Thread

Post by koogy »

xav wrote:A more correct way to do it would be to get the files in reverse order (pipe the output of "find" through "tac", for example)
the -depth flag to find will list the children before the parent.
User avatar
JQW
Baaaaa!
Baaaaa!
Posts: 1186
Joined: Thu Feb 22, 2007 12:23 pm 0
Location: Ripon, where nothing ever happens.

Re: The Official *nix Thread

Post by JQW »

Be very careful when handling file names with spaces in them. I once managed to empty a whole directory by mistake as it matched the pathname of the directory I was working on right up to the first space, because I hadn't bothered to use double quotes.
User avatar
dom
Baaaaa!
Baaaaa!
Posts: 1370
Joined: Wed Feb 09, 2005 1:17 pm 0
Location: Edinburgh, UK and level 691859
Contact:

Re: The Official *nix Thread

Post by dom »

I tend to check using tab-complete when I'm manipulating files and directories from the commandline, just to see it put the "/" on the end of the directory name.
OMG (or oligodendrocyte myelin glycoprotein) is a molecule found in your central nervous system.
User avatar
JQW
Baaaaa!
Baaaaa!
Posts: 1186
Joined: Thu Feb 22, 2007 12:23 pm 0
Location: Ripon, where nothing ever happens.

Re: The Official *nix Thread

Post by JQW »

dom wrote:I tend to check using tab-complete when I'm manipulating files and directories from the commandline, just to see it put the "/" on the end of the directory name.
In my case I had a script for cleaning up the mess made by an application that liked to scribble over every directory it touched, creating both files and directories to store scratch files and other data. The script searched for these files, and then deleted them. The script worked fine the first few times I used it. Let's call this directory "scratch", simply because I can't remember its actual name.

However I had a couple of directories with similar names, lets call them "Audio" and "Audio (Old format)", both off a drive mounted as External.

So when the application had scribbled inside "Audio (Old format)" my command to remove one of the scratch run by the script was:

rm -rf /mnt/External/Audio (Old format)/scratch

You can see what it ended up deleting instead! Thankfully I had backups.
User avatar
Dungeon-Dave
Baaaaaa!
Baaaaaa!
Posts: 3925
Joined: Thu Aug 04, 2005 12:01 pm 0
Location: UK
Contact:

Re: The Official *nix Thread

Post by Dungeon-Dave »

Anyone use LFTP as a client here?

Been using lftp for a bit now, and like it as a client due to nice inbuilt features and shell-like behaviour.

However, with my recent server I've noticed some strange behaviour with this client, mainly with obtaining directory listings. I can ftp into another server and perform a "dir" or "ls", but when changing directory both commands still show the old listing. Peculiarly, I can use TAB to auto-complete in a "cd" command and it will see that a different directory exists, but then refuse to change to that directory since the name doesn't exist in the (old) dir listing.

I solved this once by turning off caching and flushing it to force a re-read of the directory, but once it had obtained a listing it then stubbornly refused to update remote server listings.

This happens on one box running F9 with lftp3.6.3 - two other boxes running F8+lftp3.5.14 and F4+lftp3.2.1 are fine.

Oddly it only seems to do it over ftp: and ftps: connection to remote servers - sftp: connections are fine, working as expected.

Any ideas?
User avatar
JQW
Baaaaa!
Baaaaa!
Posts: 1186
Joined: Thu Feb 22, 2007 12:23 pm 0
Location: Ripon, where nothing ever happens.

Re: The Official *nix Thread

Post by JQW »

Dunno, really. I do recall having similar problems with FTP clients in the past doing odd things like this - i.e. allowing logging in but denying the ability to change directories. I never really got to the bottom of it, but suspected an issue with a firewall's handling of FTP proxying at the time.
User avatar
stealthbanana
Baaaaaa!
Baaaaaa!
Posts: 2805
Joined: Wed Nov 09, 2005 11:59 pm 0
Location: Over Here.

Re: The Official *nix Thread

Post by stealthbanana »

I have not used an ftp client for ages. If I use a terminal, midnight commander does enough for me, but usually I just use nautilus. Just bookmark your ftp sites and they are mounted and usable just like normal disks. I am even so lazy I just sftp with it into other my other machines rather than setting up full networking (except when I use a windows machine, which is rare).
Not long now before lollipop men are called Darren
User avatar
koogy
Baaa!
Baaa!
Posts: 475
Joined: Thu Aug 31, 2006 11:16 am 0

Re: The Official *nix Thread

Post by koogy »

i also use nautilus. or try to. i find whenever you try to create a new directory it fails which i think is a function of it using the name 'New Folder' for the new directory and the server choking on the space.

(seriously, whoever thought spaces in filenames were a good idea needs a slap)

so i end up just using ftp from the command line. tab completion? kids today don't know they're born...
User avatar
Dungeon-Dave
Baaaaaa!
Baaaaaa!
Posts: 3925
Joined: Thu Aug 04, 2005 12:01 pm 0
Location: UK
Contact:

Re: The Official *nix Thread

Post by Dungeon-Dave »

koogy wrote:so i end up just using ftp from the command line. tab completion? kids today don't know they're born...
That's what "lftp" is - command-line!

I like it since it can have bookmarked sites for quick recall, copes with ftps and sftp, and has scripting ability (lftp -f download.cmds) so I can schedule out-of-hours downloads.

This is only an issue I've encountered on one particular server, and it only seems to affect ftp/ftps connections, not sftp.

Just wondered if anyone else had encountered it at all. And if there's any other scriptable command-line ftp client alternatives people would like to suggest.
User avatar
defsdoor
Baaaaaa!
Baaaaaa!
Posts: 3909
Joined: Fri Jan 30, 2004 12:26 am 0
Location: Sunny Beduff

Re: The Official *nix Thread

Post by defsdoor »

I automate all my ftp processes with expect.
User avatar
Dungeon-Dave
Baaaaaa!
Baaaaaa!
Posts: 3925
Joined: Thu Aug 04, 2005 12:01 pm 0
Location: UK
Contact:

Re: The Official *nix Thread

Post by Dungeon-Dave »

Post Reply