/Anton.Dobrov/Perl/perlTask/ftp-client/Manage_ftp.pm

http://usu-wtf.googlecode.com/ · Perl · 267 lines · 262 code · 4 blank · 1 comment · 19 complexity · 8d9147f4f47fc9a88af39770edcf17b3 MD5 · raw file 

    

  1. #!/usr/bin/perl

    2. 

  2. 

    3. 

  3. sub open_connection

    4. 

  4. {

    5. 

  5. 	return "exist" if ($REMOTE_SOCK);

    6. 

  6. 	my $paddr = inet_aton($_[0]);

    7. 

  7. 	socket REMOTE_SOCK, PF_INET, SOCK_STREAM, getprotobyname('tcp') or die "Cannot create socket\n";

    8. 

  8. 	connect REMOTE_SOCK, sockaddr_in(21, $paddr) or die "Cannot connect to server '$_[0]'\n";

    9. 

  9. 	$REMOTE_SOCK = 1;

    10. 

  10. 	$server_name = $_[0];

    11. 

  11. 	my $str = listen_sock(*REMOTE_SOCK, $mode{'-T'});

    12. 

  12. 	if ($str =~ /^404/)

    13. 

  13. 	{

    14. 

  14. 		print $str if $mode{'-v'};

    15. 

  15. 		print "   Server is hidden or simply offended at all.\n   If you want to know what really happened,\n   run the program without a parameter '-v'\n" unless $mode{'-v'};

    16. 

  16. 		exit;

    17. 

  17. 	}

    18. 

  18. 	print $str if $mode{'-v'};

    19. 

  19. 	if ($mode{'-a'})

    20. 

  20. 	{

    21. 

  21. 		send REMOTE_SOCK, "USER anonymous".$EOL, 0;

    22. 

  22. 		send REMOTE_SOCK, "PASS Password".$EOL, 0;

    23. 

  23. 	}

    24. 

  24. 	else

    25. 

  25. 	{

    26. 

  26. 		print "User: " unless $mode{'-X'};

    27. 

  27. 		$str = <STDIN>;

    28. 

  28. 		chomp $str;

    29. 

  29. 		send REMOTE_SOCK, "USER $str".$EOL, 0;

    30. 

  30. 		print listen_sock(*REMOTE_SOCK, $mode{'-T'}) if $mode{'-v'};

    31. 

  31. 		print "Password: " unless $mode{'-X'};

    32. 

  32. 		if ($mode{'-X'})

    33. 

  33. 		{

    34. 

  34. 			$str = <STDIN>;

    35. 

  35. 		}

    36. 

  36. 		else

    37. 

  37. 		{

    38. 

  38. 			ReadMode 2, STDIN;

    39. 

  39. 			$str = ReadLine(0);

    40. 

  40. 			ReadMode 0;

    41. 

  41. 			print "\n";

    42. 

  42. 		}

    43. 

  43. 		chomp $str;

    44. 

  44. 		send REMOTE_SOCK, "PASS $str".$EOL, 0;

    45. 

  45. 	}

    46. 

  46. 	print listen_sock(*REMOTE_SOCK, $mode{'-T'}) if $mode{'-v'};

    47. 

  47. 	feat();

    48. 

  48. 	send REMOTE_SOCK, "OPTS UTF8 ON".$EOL, 0 if $feat{'UTF8'};

    49. 

  49. 	send REMOTE_SOCK, "TYPE I".$EOL, 0;

    50. 

  50. 	print listen_sock(*REMOTE_SOCK, $mode{'-T'}) if $mode{'-v'};

    51. 

  51. 	listen_sock(*REMOTE_SOCK, $mode{'-T'}) unless $mode{'-v'};

    52. 

  52. 	return 1;

    53. 

  53. }

    54. 

  54. 

    55. 

  55. sub user

    56. 

  56. {

    57. 

  57. 	return "no_connect" unless $REMOTE_SOCK;

    58. 

  58. 	chomp $_[0];

    59. 

  59. 	send REMOTE_SOCK, "USER $_[0]".$EOL, 0;

    60. 

  60. 	print listen_sock(*REMOTE_SOCK, $mode{'-T'}) if $mode{'-v'};

    61. 

  61. 	print "Password: " unless $mode{'-X'};

    62. 

  62. 	if ($mode{'-X'})

    63. 

  63. 	{

    64. 

  64. 		$str = <STDIN>;

    65. 

  65. 	}

    66. 

  66. 	else

    67. 

  67. 	{

    68. 

  68. 		ReadMode 2, STDIN;

    69. 

  69. 		$str = ReadLine(0);

    70. 

  70. 		ReadMode 0;

    71. 

  71. 		print "\n";

    72. 

  72. 	}

    73. 

  73. 	chomp $str;

    74. 

  74. 	send REMOTE_SOCK, "PASS $str".$EOL, 0;

    75. 

  75. 	send REMOTE_SOCK, "OPTS UTF8 ON".$EOL, 0 if $feat{'UTF8'};

    76. 

  76. 	send REMOTE_SOCK, "TYPE I".$EOL, 0;

    77. 

  77. 	print listen_sock(*REMOTE_SOCK, $mode{'-T'}) if $mode{'-v'};

    78. 

  78. 	listen_sock(*REMOTE_SOCK, $mode{'-T'}) unless $mode{'-v'};

    79. 

  79. 	return 1;

    80. 

  80. }

    81. 

  81. 

    82. 

  82. sub ls

    83. 

  83. {

    84. 

  84. 	return "no_connect" unless $REMOTE_SOCK;

    85. 

  85. 	my ($ip, $port) = get_pasv();

    86. 

  86. 	return 1 if ($ip == 530);

    87. 

  87. 	my $paddr = inet_aton($ip);

    88. 

  88. 	socket LIST_SOCK, PF_INET, SOCK_STREAM, getprotobyname('tcp') or die "Cannot create socket\n";

    89. 

  89. 	connect LIST_SOCK, sockaddr_in($port, $paddr) or die "Cannot connect to server '$ip'\n";

    90. 

  90. 	send REMOTE_SOCK, "$_[0]".$EOL, 0;

    91. 

  91. 	if ($mode{'-v'})

    92. 

  92. 	{

    93. 

  93. 		print listen_sock(*LIST_SOCK, $mode{'-T'});

    94. 

  94. 	}

    95. 

  95. 	else

    96. 

  96. 	{

    97. 

  97. 		my $ls = listen_sock(*LIST_SOCK, $mode{'-T'});

    98. 

  98. 		print "$_\n", grep {$_ !~ /^[0-9]{3} /} (split /(\n)|(\r\n)/, $ls);

    99. 

  99. 	}

    100. 

  100. 	shutdown LIST_SOCK, 2;

    101. 

  101. 	return 1;

    102. 

  102. }

    103. 

  103. 

    104. 

  104. sub mv

    105. 

  105. {

    106. 

  106. 	$_[0] =~ /('|"|)?(.*?)\1 ('|"|)?(.*?)\3/g;

    107. 

  107. 	my ($param1, $param2) = ($2, $4);

    108. 

  108. 	return "no_connect" unless REMOTE_SOCK;

    109. 

  109. 	send REMOTE_SOCK, "RNFR $param1".$EOL, 0;

    110. 

  110. 	send REMOTE_SOCK, "RNTO $param2".$EOL, 0;

    111. 

  111. 	return 1;

    112. 

  112. }

    113. 

  113. 

    114. 

  114. sub size

    115. 

  115. {

    116. 

  116. 	return "no_connect" unless REMOTE_SOCK;

    117. 

  117. 	return "This command is not supported by server\n" unless $feat{'SIZE'};

    118. 

  118. 	my $flag = 0;

    119. 

  119. 	/()/;

    120. 

  120. 	$flag = shift if ($_[0] =~ /^-h (.*)/);

    121. 

  121. 	send REMOTE_SOCK, "SIZE @{_}${1}".$EOL, 0;

    122. 

  122. 	my $str = listen_sock(*REMOTE_SOCK, $mode{'-T'});

    123. 

  123. 	$str =~ /([0-9]{3}) ([0-9]*)/;

    124. 

  124. 	if ($1 != 213)

    125. 

  125. 	{

    126. 

  126. 		print $str if $mode{'-v'};

    127. 

  127. 		return 1;

    128. 

  128. 	}

    129. 

  129. 	unless ($flag)

    130. 

  130. 	{

    131. 

  131. 		print $2, " B\n";

    132. 

  132. 		return 1;

    133. 

  133. 	}

    134. 

  134. 	my $size = $2;

    135. 

  135. 	my @units = ('B', 'KB', 'MB', 'GB', 'TB', 'PB');

    136. 

  136. 	my $units = 0;

    137. 

  137. 	while ($size >= 1024 && $units < 5)

    138. 

  138. 	{

    139. 

  139. 		$size /= 1024;

    140. 

  140. 		$units++;

    141. 

  141. 	}

    142. 

  142. 	print '', (sprintf "%.2f", $size), " $units[$units]\n";

    143. 

  143. 	return 1;

    144. 

  144. }

    145. 

  145. 

    146. 

  146. sub simple_manipulation

    147. 

  147. {

    148. 

  148. 	return "no_connect" unless $REMOTE_SOCK;

    149. 

  149. 	my $todo = shift;

    150. 

  150. 	send REMOTE_SOCK, "$todo @_".$EOL, 0;

    151. 

  151. 	return 1;

    152. 

  152. }

    153. 

  153. 

    154. 

  154. sub disconnect

    155. 

  155. {

    156. 

  156. 	return "no_connect" unless $REMOTE_SOCK;

    157. 

  157. 	send REMOTE_SOCK, "QUIT".$EOL, 0;

    158. 

  158. 	print listen_sock(*REMOTE_SOCK, $mode{'-T'}) if $mode{'-v'};

    159. 

  159. 	shutdown REMOTE_SOCK, 2;

    160. 

  160. 	$REMOTE_SOCK = 0;

    161. 

  161. 	return 1;

    162. 

  162. }

    163. 

  163. 

    164. 

  164. sub get_pasv

    165. 

  165. {

    166. 

  166. 	return "no_connect" unless $REMOTE_SOCK;

    167. 

  167. 	send REMOTE_SOCK, "PASV".$EOL, 0;

    168. 

  168. 	while (1)

    169. 

  169. 	{

    170. 

  170. 		my $str = listen_sock(*REMOTE_SOCK, $mode{'-T'});

    171. 

  171. 		return 1 if $str =~ /530/;

    172. 

  172. 		print $str if $mode{'-v'};

    173. 

  173. 		return ("$1.$2.$3.$4", ($5*256+$6)) if $str =~ /(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)/;

    174. 

  174. 	}

    175. 

  175. }

    176. 

  176. 

    177. 

  177. sub feat

    178. 

  178. {

    179. 

  179. 	return "no_connect" unless $REMOTE_SOCK;

    180. 

  180. 	send REMOTE_SOCK, "FEAT".$EOL, 0;

    181. 

  181. 	my $str = listen_sock(*REMOTE_SOCK, $mode{'-T'});

    182. 

  182. 	$feat{$_} = 1 foreach (grep {/(SIZE)|(UTF8)/} (split " ", $str));

    183. 

  183. 	

    184. 

  184. 	return 1;

    185. 

  185. }

    186. 

  186. 

    187. 

  187. sub listen_sock

    188. 

  188. {

    189. 

  189. 	local *SOURCE = $_[0];

    190. 

  190. 	my $timeout = $_[1];

    191. 

  191. 	my ($buf, $res, $write_command, $rin, $rout) = ('defined :)', '');

    192. 

  192. 	vec ($rin, fileno(SOURCE), 1) = 1;

    193. 

  193. 	while ($buf ne '')

    194. 

  194. 	{

    195. 

  195. 		my $nfound = select($rout = $rin, '', '', $timeout);

    196. 

  196. 		die 'Select() error' if ($nfound == -1);

    197. 

  197. 		last if ($nfound == 0);

    198. 

  198. 		die 'Recv() error' if (!defined(recv SOURCE, $buf, 512, 0));	#kakyato error

    199. 

  199. 		$res .= $buf;

    200. 

  200. 	}

    201. 

  201. 	return $res;

    202. 

  202. }

    203. 

  203. 

    204. 

  204. sub listen_sock_for_file

    205. 

  205. {

    206. 

  206. 	local (*SOURCE, *DEST) = ($_[0], $_[1]);

    207. 

  207. 	my $timeout = $_[2];

    208. 

  208. 	my ($buf, $write_command, $rin, $rout) = ('defined :)');

    209. 

  209. 	vec ($rin, fileno(SOURCE), 1) = 1;

    210. 

  210. 	while ($buf ne '')

    211. 

  211. 	{

    212. 

  212. 		my $nfound = select($rout = $rin, '', '', $timeout);

    213. 

  213. 		die 'Select() error' if ($nfound == -1);

    214. 

  214. 		last if ($nfound == 0);

    215. 

  215. 		die 'Recv() error' if (!defined(recv SOURCE, $buf, 512, 0));

    216. 

  216. 		print DEST $buf;

    217. 

  217. 	}

    218. 

  218. }

    219. 

  219. 

    220. 

  220. sub help

    221. 

  221. {

    222. 

  222. 	my $param = lc shift;

    223. 

  223. 	my %help = 

    224. 

  224. 	(

    225. 

  225. 		'open'			=>	"Connect to remote tftp",

    226. 

  226. 		'ls'			=>	"List contents of remote directory",

    227. 

  227. 		'dir'			=>	"List contents of remote directory (extended)",

    228. 

  228. 		'send'			=>	"Send one file",

    229. 

  229. 		'recv'			=>	"Receive file",

    230. 

  230. 		'cd'			=>	"Change remote working directory",

    231. 

  231. 		'pwd'			=>	"Print working directory on remote machine",

    232. 

  232. 		'user'			=>	"Send new user information",

    233. 

  233. 		'mv'			=>	"Rename file; file name with spaces must be quoted",

    234. 

  234. 		'rm'			=>	"Delete remote file",

    235. 

  235. 		'mkdir'			=>	"Make directory on the remote machine",

    236. 

  236. 		'rmdir'			=>	"Remove directory on the remote machine",

    237. 

  237. 		'disconnect'	=>	"Terminate ftp session",

    238. 

  238. 		'size'			=>	"Returns size of file; type 'size -h' for human-readable format",

    239. 

  239. 		'quit'			=>	"Terminate ftp session and exit"

    240. 

  240. 	);

    241. 

  241. 	if ($param)

    242. 

  242. 	{

    243. 

  243. 		print "$param\t\t$help{$param}\n" if $help{$param};

    244. 

  244. 		print "Unknown command\n" unless $help{$param};

    245. 

  245. 	}

    246. 

  246. 	else

    247. 

  247. 	{

    248. 

  248. 		print "$_\t" foreach (sort keys %help);

    249. 

  249. 		print "\n";

    250. 

  250. 	}

    251. 

  251. 	return 1;

    252. 

  252. }

    253. 

  253. 

    254. 

  254. sub usage_ftp

    255. 

  255. {

    256. 

  256. 	print "Transfers files to and from a computer running an FTP server service.\n\n";

    257. 

  257. 	print "FTP [-h] [-v] [-a] [-T time] [-X filename] [host]\n\n";

    258. 

  258. 	print "  -h\t\tPrint this help and exit.\n";

    259. 

  259. 	print "  -a\t\tlogin as anonymous.\n";

    260. 

  260. 	print "  -v\t\tSuppresses display of remote server responses.\n";

    261. 

  261. 	print "  -T time\tSet how long to wait for a response from the server;\n\t\ttime in seconds.\n";

    262. 

  262. 	print "  -X filename\tSpecifies a text file containing FTP commands; the commands\n\t\twill automatically run after FTP starts.\n";

    263. 

  263. 	print "  host\t\tSpecifies the host name or IP address of the remote host\n\t\tto connect to.\n";

    264. 

  264. 	return 1;

    265. 

  265. }

    266. 

  266. 

    267. 

  267. 1;
    268.