2015-09-16T09:51:06 ITobiIDas Ding ist ja das wir uns in den Vorlesungen noch nie mit Perl beschäftigt haben oder der Socket-Programmierung im Detail,
[...]
Quote[...]
mir gehts da auch eigentlich eher um den Syntax...
1
2
3
4
5
6
7
8
9
my $n = 0;
my $i = 0;
my $Anzahl_Elemente = @data;
while($Anzahl_Elemente = $n)
{
$socket->send(@data[$n]);
$n = $i + 1;
$n = $i;
}
1 2 3 4 5 6 7
my @data; open(DATEI, "test.txt"); while(<DATEI>) { @data = <DATEI>; }
1 2 3 4 5 6 7 8 9
my $n = 0; my $i = 0; my $Anzahl_Elemente = @data; while($Anzahl_Elemente = $n) { $socket->send(@data[$n]); $n = $i + 1; $n = $i; }
$socket->send($_) for (@data);
1 2 3 4 5 6 7
my @data open(my $fh, '<:raw', 'test.txt') or die("ERROR OPEN test.txt ($!)\n"); my $block; while(read($fh,$block,1024)) { push(@data,$block); } close($fh);
$socket->recv(@data,1024);
print "@data\n";
alarm(2);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#!/usr/bin/perl -w
#UDP_Client.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
use Time::HiRes qw(gettimeofday);
use Archive::Zip;
#Module importieren
#strict macht debugging einfacher
use strict 'vars';
#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
use IO::Socket::INET;
#auto-flush
$| = 1;
#Variablen deklarieren
my ($socket,$ip,$port,$end,$start_sec,$start_usec,$end_sec,$end_usec,$timeDelta);
my ($Anzahl_Elemente,$block,$fh,$Sende_erneut,$DIR,$zip,$fileName);
my @name;
$ip = $ARGV [0] || "127.0.0.1"; #erster Paramenter wird in $ipaddr eingespeichert
$port = $ARGV [1] || "9999"; #zweiter Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Server
$socket=new IO::Socket::INET
(
PeerAddr=>$ip, #PeerAddr von $sock ist eingegebener Paramenter $ipaddr
PeerPort=>$port, #PeerPort von $sock ist eingegebener Paramenter $port
Proto=>'udp' #Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket;
print "Mit $ip verbunden !\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
#Hauptschleife
while ($end == 'j')
{
$zip = Archive::Zip->new();
$DIR = "/root/Documents/Socket-Programmierung_2/Datei";
opendir(DIR,$DIR) or die "Kann aktuelles Verzeichnis nicht oeffnen: $!\n";
@name = readdir(DIR) or die "Kann Verzeichnis nicht lesen:$!\n";
foreach $fileName (@name)
{
if ($fileName =~ /.txt/ )
{
$zip->addFile($fileName);
}
}
$zip->writeToFileNamed("result.zip")
#Datei Array einlesen und sicherstellen das Datenpakete gleich groß sind
open ($fh,'<:raw','result.zip') or die ("ERROR OPEN result.zip ($!)\n");
while (read($fh,$block,1024))
{
push(@data,$block);
}
#Laenge des Array festlegen
$Anzahl_Elemente = @data;
#Laenge des Array an Server senden
$socket->send($Anzahl_Elemente, 1024);
$Sende_erneut = 0;
#Startzeit setzen
($start_sec, $start_usec) = gettimeofday();
while($Sende_erneut == 1)
{
#sende Datenpakete zu Server
$socket->send($_) for (@data);
#überprüfe ob Server Daten erhalten hat
$socket->recv($Sende_erneut,1024);
#Endzeit setzen
($start_sec, $start_usec) = gettimeofday();
}
#Sendezeit ermitteln
$timeDelta = ($end_usec - $start_usec)/1000 + ($end_sec - $start_sec)*1000;
print "Die Sendezeit betraegt: $timeDelta ms";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#Schließe Datei
close (DATEI);
#Schließe Socket
$socket -> close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#!/usr/bin/perl -w
#UDP_Server.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
#Module importieren
use strict 'vars'; #strict macht debugging einfacher
use strict 'refs';
use IO::Socket::INET;#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
#auto-flush
$| = 1;
#Variablen deklarieren
my ($end,$socket,$peer_address,$peer_port,$n,$i,$Anzahl_Elemente,$Sende_erneut);
my ($Dateien,$VerzPfad,$strAblageVer,$dateien,$strVerzeichnis);
my (@data,@sortdata);
my $ip = $ARGV [0] || "127.0.0.1"; #erste Paramenter wird in $ipaddr eingespeichert
my $port = $ARGV [1] || "9999"; #zweite Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Client
$socket=new IO::Socket::INET
(
LocalHost =>$ip,#LocalHost von $socket ist eingegebener Paramenter $ip
LocalPort=>$port,#LocalPort von $sock ist eingegebener Paramenter $port
Proto=>'udp'#Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket; #wenn fehlgeschlagen dann schließen
print "UDP Server bereit und wartet auf eine Verbingung mit Port $port\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
#Hauptschleife
while($end == 'j')
{
#definiere ip
$peer_address = $socket->peerhost();
#definiere port
$peer_port = $socket->peerport();
#Empfange Anzahl der zu sendenden Elemente
$socket->recv($Anzahl_Elemente,1024);
#Empfange Daten von Client
$socket->send($_) for (@data);
#Empfange und überprüfe Daten
while ($Anzahl_Elemente != @data)
{
$Sende_erneut = 1;
$socket->send($Sende_erneut);
#Empfange Anzahl der zu sendenden Elemente
$socket->recv($Anzahl_Elemente,1024);
}
$strVerzeichnis = "Verzeichnis_A";
$strAblageVer = "Verzeichnis_B";
#Kopieren
foreach $dateien (@data)
{
copy($strVerzeichnis.'/'.$dateien,$strAblageVer.'/'.$dateien);
}
chdir($VerzPfad.$strAblageVer) or die (qq#ERROR chdir "$VerzPfad.$strAblageVer" ($!)\n#);
#Entpacke
foreach $dateien (@data)
{
system("/usrbin/unzip",.'/'$VerzPfad.$strAblageVer.'/'.$dateien) == 0 or die "Systemfehler: $?";
#zip-Dateien löschen
unlink($VerzPfad.$strAblageVer.'/'.$dateien);
}
@sortdata = sort @data;
#Gib Datei aus
print join(",",@sortdata);
}
#Schließe Socket
$socket -> close();
use Archive::Zip;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#!/usr/bin/perl -w
#UDP_Client.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
use Time::HiRes qw(gettimeofday);
#Module importieren
#strict macht debugging einfacher
use strict 'vars';
use warnings;
#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
use IO::Socket::INET;
#auto-flush
$| = 1;
#Variablen deklarieren
my ($socket,$ip,$port,$end,$start_sec,$start_usec,$end_sec,$end_usec,$timeDelta);
my ($Anzahl_Elemente,$block,$fh,$Sende_erneut,$DIR,$zip,$fileName);
my @name;
$ip = $ARGV [0] || "127.0.0.1"; #erster Paramenter wird in $ipaddr eingespeichert
$port = $ARGV [1] || "9999"; #zweiter Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Server
$socket=new IO::Socket::INET
(
PeerAddr=>$ip, #PeerAddr von $sock ist eingegebener Paramenter $ipaddr
PeerPort=>$port, #PeerPort von $sock ist eingegebener Paramenter $port
Proto=>'udp' #Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket;
print "Mit $ip verbunden !\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
#Hauptschleife
while ($end eq 'j')
{
use Archive::Zip qw(:ERROR_CODES:CONSTANTS);
$zip = Archive::Zip->new();
$DIR = "/root/Documents/Socket-Programmierung_2/Datei";
opendir(DIR,$DIR) or die "Kann aktuelles Verzeichnis nicht oeffnen: $!\n";
@data = readdir(DIR) or die "Kann Verzeichnis nicht lesen:$!\n";
foreach $fileName (@data)
{
if ($fileName =~ /.txt/ )
{
$zip->addFile($fileName);
}
}
$zip->writeToFileNamed("result.zip")
#Datei Array einlesen und sicherstellen das Datenpakete gleich groß sind
open ($fh,'<:raw','result.zip') or die ("ERROR OPEN result.zip ($!)\n");
while (read($fh,$block,1024))
{
push(@data,$block);
}
#Laenge des Array festlegen
$Anzahl_Elemente = @data;
#Laenge des Array an Server senden
$socket->send($Anzahl_Elemente, 1024);
$Sende_erneut = 0;
#Startzeit setzen
($start_sec, $start_usec) = gettimeofday();
while($Sende_erneut == 1)
{
#sende Datenpakete zu Server
$socket->send($_) for (@data);
#überprüfe ob Server Daten erhalten hat
$socket->recv($Sende_erneut,1024);
#Endzeit setzen
($start_sec, $start_usec) = gettimeofday();
}
#Sendezeit ermitteln
$timeDelta = ($end_usec - $start_usec)/1000 + ($end_sec - $start_sec)*1000;
print "Die Sendezeit betraegt: $timeDelta ms";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#Schließe Datei
close (DATEI);
#Schließe Socket
$socket -> close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#!/usr/bin/perl -w
#UDP_Server.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
#Module importieren
use strict 'vars'; #strict macht debugging einfacher
use warnings;
use IO::Socket::INET;#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
#auto-flush
$| = 1;
#Variablen deklarieren
my ($end,$socket,$peer_address,$peer_port,$n,$i,$Anzahl_Elemente,$Sende_erneut);
my ($Dateien,$VerzPfad,$strAblageVer,$dateien,$strVerzeichnis);
my (@data,@sortdata);
my $ip = $ARGV [0] || "127.0.0.1"; #erste Paramenter wird in $ipaddr eingespeichert
my $port = $ARGV [1] || "9999"; #zweite Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Client
$socket=new IO::Socket::INET
(
LocalHost =>$ip,#LocalHost von $socket ist eingegebener Paramenter $ip
LocalPort=>$port,#LocalPort von $sock ist eingegebener Paramenter $port
Proto=>'udp'#Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket; #wenn fehlgeschlagen dann schließen
print "UDP Server bereit und wartet auf eine Verbingung mit Port $port\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
#Hauptschleife
while($end eq "j")
{
#definiere ip
$peer_address = $socket->peerhost();
#definiere port
$peer_port = $socket->peerport();
#Empfange Anzahl der zu sendenden Elemente
$socket->recv($Anzahl_Elemente,1024);
#Empfange Daten von Client
$socket->send($_) for (@data);
#Empfange und überprüfe Daten
while ($Anzahl_Elemente != @data)
{
$Sende_erneut = 1;
$socket->send($Sende_erneut);
#Empfange Anzahl der zu sendenden Elemente
$socket->recv($Anzahl_Elemente,1024);
}
$strVerzeichnis = "Verzeichnis_A";
$strAblageVer = "Verzeichnis_B";
#Kopieren
foreach $dateien (@data)
{
copy($strVerzeichnis.'/'.$dateien,$strAblageVer.'/'.$dateien);
}
chdir($VerzPfad.$strAblageVer) or die (qq#ERROR chdir "$VerzPfad.$strAblageVer" ($!)\n#);
#Entpacke
foreach $dateien (@data)
{
system("/usrbin/unzip", $VerzPfad.$strAblageVer.'/'.$dateien) == 0 or die "Systemfehler: $?";
#zip-Dateien löschen
unlink($VerzPfad.$strAblageVer.'/'.$dateien);
}
@sortdata = sort @data;
#Gib Datei aus
print join(",",@sortdata);
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#Schließe Socket
$socket -> close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#!/usr/bin/perl -w
#UDP_Client.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
use Time::HiRes qw(gettimeofday);
#Module importieren
#strict macht debugging einfacher
use strict 'vars';
use warnings;
#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
use IO::Socket::INET;
#auto-flush
$| = 1;
#Variablen deklarieren
my ($socket,$ip,$port,$end,$start_sec,$start_usec,$end_sec,$end_usec,$timeDelta);
my ($Anzahl_Elemente,$block,$fh,$Sende_erneut,$DIR,$zip,$fileName);
my (@data);
$ip = $ARGV [0] || "127.0.0.1"; #erster Paramenter wird in $ipaddr eingespeichert
$port = $ARGV [1] || "9999"; #zweiter Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Server
$socket=new IO::Socket::INET
(
PeerAddr=>$ip, #PeerAddr von $sock ist eingegebener Paramenter $ipaddr
PeerPort=>$port, #PeerPort von $sock ist eingegebener Paramenter $port
Proto=>'udp' #Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket;
print "Mit $ip verbunden !\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
#Hauptschleife
while ($end eq "j")
{
use Archive::Zip;
$zip = Archive::Zip->new();
$DIR = "/root/Documents/Socket-Programmierung_2/Datei";
opendir(DIR,$DIR) or die "Kann aktuelles Verzeichnis nicht oeffnen: $!\n";
@data = readdir(DIR) or die "Kann Verzeichnis nicht lesen:$!\n";
foreach $fileName (@data)
{
if ($fileName =~ /.txt/ )
{
$zip->addFile($fileName);
}
}
$zip->writeToFileNamed("result.zip");
#Datei Array einlesen und sicherstellen das Datenpakete gleich groß sind
open ($fh,'<:raw','result.zip') or die ("ERROR OPEN result.zip ($!)\n");
while (read($fh,$block,1024))
{
push(@data,$block);
}
#Laenge des Array festlegen
$Anzahl_Elemente = @data;
#Laenge des Array an Server senden
$socket->send($Anzahl_Elemente, 1024);
$Sende_erneut = 0;
#Startzeit setzen
($start_sec, $start_usec) = gettimeofday();
while($Sende_erneut == 1)
{
#sende Datenpakete zu Server
$socket->send($_) for (@data);
#überprüfe ob Server Daten erhalten hat
$socket->recv($Sende_erneut,1024);
#Endzeit setzen
($start_sec, $start_usec) = gettimeofday();
}
#Sendezeit ermitteln
$timeDelta = ($end_usec - $start_usec)/1000 + ($end_sec - $start_sec)*1000;
print "Die Sendezeit betraegt: $timeDelta ms";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#Schließe Datei
close (DIR);
#Schließe Socket
$socket -> close();
1
2
3
4
5
6
7
8
9
10
#Empfange Daten von Client
$socket->recv($serialize_data); #line 52
#definiere ip
$peer_address = $socket->peerhost();
#definiere port
$peer_port = $socket->peerport();
#entserialisiere empfangene Daten
@unserialize_data = unserialize(\$serialize_data);
/code]
1
2
#entserialisiere empfangene Daten
@unserialize_data = unserialize($serialize_data); #line 61
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
use Data::Dumper; sub serialize { my $data = shift; $data = Dumper($data); $data =~ s/\$VAR1 = //; return $data; } sub unserialize { my $serial_data = shift; eval "\$serial_data = $serial_data"; return $serial_data; } # Daten sind bspw. in einem anonymen Array my $daten = [1,13,42,"Perl","FooBar"]; my $SER_DATA = serialize($daten); say "Serialisierte Daten: ",$SER_DATA; # und Daten wieder zurück gewinnen $daten = unserialize($SER_DATA); say $daten->[2]; # sollte 42 ergeben
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#!/usr/bin/perl -w
#UDP_Server.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
#Module importieren
use strict 'vars'; #strict macht debugging einfacher
use warnings;
use IO::Socket::INET;#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
#auto-flush
$| = 1;
#Variablen deklarieren
my ($end,$socket,$peer_address,$peer_port,$n,$i,$Anzahl_Elemente,$Sende_erneut,$Bestaetigung,$checksum_Client,$checksum_Server);
my ($VerzPfad,$strAblageVer,$dateien,$strVerzeichnis,$daten);
my (@data,@sortdata);
my $ip = $ARGV [0] || "127.0.0.1"; #erste Paramenter wird in $ipaddr eingespeichert
my $port = $ARGV [1] || "9999"; #zweite Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Client
$socket=new IO::Socket::INET
(
LocalHost =>$ip,#LocalHost von $socket ist eingegebener Paramenter $ip
LocalPort=>$port,#LocalPort von $sock ist eingegebener Paramenter $port
Proto=>'udp'#Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket; #wenn fehlgeschlagen dann schließen
print "UDP Server bereit und wartet auf eine Verbingung mit Port $port\n";
#Hauptschleife
while(1)
#do
{
#Empfange Prüfsumme von Client
$socket->recv($checksum_Client,1024);
#definiere ip
$peer_address = $socket->peerhost();
#definiere port
$peer_port = $socket->peerport();
#Empfange und überprüfe Daten
do
{
#Bestätige nicht erfolgreiches Senden
$Bestaetigung = 0;
$socket->send($Bestaetigung);
$socket->recv($daten,1024);
#Bilde Prüfsumme nach Empfang der Daten
$checksum_Server = unpack ("%16C*", $daten);
}
while ($checksum_Client != $checksum_Server);
#Bestätige erfolgreiches Senden
$Bestaetigung = 1;
$socket->send($Bestaetigung);
$strVerzeichnis = "Verzeichnis_A";
$strAblageVer = "Verzeichnis_B";
#Wandle String in Array um
@data = join(", ", $daten);
#Kopieren
use File::Copy;
foreach $dateien (@data)
{
copy($strVerzeichnis.'/'.$dateien,$strAblageVer.'/'.$dateien);
}
chdir($VerzPfad.$strAblageVer) or die (qq#ERROR chdir "$VerzPfad.$strAblageVer" ($!)\n#); #line 90
#Entpacke
foreach $dateien (@data)
{
system("/usrbin/unzip", $VerzPfad.$strAblageVer.'/'.$dateien) == 0 or die "Systemfehler: $?";
#zip-Dateien löschen
unlink($VerzPfad.$strAblageVer.'/'.$dateien);
}
@sortdata = sort @data;
#Gib Datei aus
print join(",",@sortdata);
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#while($end = 'j');
#Schließe Socket
$socket -> close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#!/usr/bin/perl -w
#UDP_Client.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
use Time::HiRes qw(gettimeofday);
#Module importieren
#strict macht debugging einfacher
use strict 'vars';
use warnings;
#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
use IO::Socket::INET;
#auto-flush
$| = 1;
#Variablen deklarieren
my ($socket,$ip,$port,$end,$start_sec,$start_usec,$end_sec,$end_usec,$timeDelta,$checksum_Client);
my ($Anzahl_Elemente,$block,$fh,$Sende_erneut,$DIR,$zip,$fileName,$daten,$Bestaetigung);
my (@data);
$ip = $ARGV [0] || "127.0.0.1"; #erster Paramenter wird in $ipaddr eingespeichert
$port = $ARGV [1] || "9999"; #zweiter Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Server
$socket=new IO::Socket::INET
(
PeerAddr=>$ip, #PeerAddr von $sock ist eingegebener Paramenter $ipaddr
PeerPort=>$port, #PeerPort von $sock ist eingegebener Paramenter $port
Proto=>'udp' #Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket;
print "Mit $ip verbunden !\n";
#Hauptschleife
#do
while(1)
{
use Archive::Zip;
$zip = Archive::Zip->new();
$DIR = "/root/Documents/Socket-Programmierung_2/Datei";
opendir(DIR,$DIR) or die "Kann aktuelles Verzeichnis nicht oeffnen: $!\n";
@data = readdir(DIR) or die "Kann Verzeichnis nicht lesen:$!\n";
foreach $fileName (@data)
{
if ($fileName =~ /.txt/ )
{
$zip->addFile($fileName);
}
}
$zip->writeToFileNamed("result.zip");
#Datei Array einlesen und sicherstellen das Datenpakete gleich groß sind
open ($fh,'<:raw','result.zip') or die ("ERROR OPEN result.zip ($!)\n");
while (read($fh,$block,1024))
{
push(@data,$block);
}
#Wandle Array in String um
$daten = join(", ", @data);
#Prüfsumme ermitteln
$checksum_Client = unpack ("%16C*", $daten);
#Prüfsumme an Server senden
$socket->send($checksum_Client, 1024);
$Bestaetigung = 0;
#Startzeit setzen
($start_sec, $start_usec) = gettimeofday();
while($Bestaetigung == 0)
{
#Bestaetigung senden
$socket->recv($Bestaetigung,1024);
if($Bestaetigung == 0)
{
#sende Datenpakete zu Server
$socket->send($daten);
}
}
#Endzeit setzen
($start_sec, $start_usec) = gettimeofday();
#Sendezeit ermitteln
$timeDelta = ($end_usec - $start_usec)/1000 + ($end_sec - $start_sec)*1000; #line 112
print "Die Sendezeit betraegt: $timeDelta ms\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#while($end eq 'j');
#Schließe DIR
close (DIR);
#Schließe Socket
$socket -> close();
my $skalar = join('', <DATEI>);
my @array = split(/\n/, $skalar);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#!/usr/bin/perl -w
#UDP_Server.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
#Module importieren
use strict 'vars'; #strict macht debugging einfacher
use warnings;
use IO::Socket::INET;#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
#auto-flush
$| = 1;
#Variablen deklarieren
my ($end,$socket,$peer_address,$peer_port,$Bestaetigung,$checksum_Client,$checksum_Server,$fh);
my ($zip_daten,$daten);
my $ip = $ARGV [0] || "127.0.0.1"; #erste Paramenter wird in $ipaddr eingespeichert
my $port = $ARGV [1] || "9999"; #zweite Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Client
$socket=new IO::Socket::INET
(
LocalHost =>$ip,#LocalHost von $socket ist eingegebener Paramenter $ip
LocalPort=>$port,#LocalPort von $sock ist eingegebener Paramenter $port
Proto=>'udp'#Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket; #wenn fehlgeschlagen dann schließen
print "UDP Server bereit und wartet auf eine Verbingung mit Port $port\n";
#Hauptschleife
while(1)
#do
{
#Empfange Prüfsumme von Client
$socket->recv($checksum_Client,1024);
#definiere ip
$peer_address = $socket->peerhost();
#definiere port
$peer_port = $socket->peerport();
print "1\n";
#Empfange und überprüfe Daten
do
{
#Bestätige nicht erfolgreiches Senden
$Bestaetigung = 0;
$socket->send($Bestaetigung);
print "11\n";
#Empfange Daten
$socket->recv($daten,1024);
#Bilde Prüfsumme nach Empfang der Daten
$checksum_Server = unpack ("%16C*", $daten);
print("Prüfsumme: $checksum_Server\n");
print "12\n";
}
while ($checksum_Client != $checksum_Server);
print "2\n";
#Bestätige erfolgreiches Senden
$Bestaetigung = 1;
$socket->send($Bestaetigung);
print "3\n";
#Entpacke
#Gib Datei aus
print "$daten";
#Abfrage ob Programm beenden
print "\nWenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#while($end = 'j');
#Schließe Socket
$socket -> close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#!/usr/bin/perl -w
#UDP_Client.pl
#Hartych, Tobias EIT 4056051
#Dreißig, Tobias EIT 40?????
use Time::HiRes qw(gettimeofday);
#Module importieren
#strict macht debugging einfacher
use strict 'vars';
use warnings;
#Modul wird benoetigt um Netzwerkfunktionen zu nutzen
use IO::Socket::INET;
#auto-flush
$| = 1;
#Variablen deklarieren
my ($socket,$ip,$port,$end,$start_sec,$start_usec,$end_sec,$end_usec,$timeDelta,$checksum_Client);
my ($daten,$Bestaetigung,$zip_daten);
$ip = $ARGV [0] || "127.0.0.1"; #erster Paramenter wird in $ipaddr eingespeichert
$port = $ARGV [1] || "9999"; #zweiter Paramenter wird in $ipaddr eingespeichert
#Socket erschaffen zur Kommunikation mit Server
$socket=new IO::Socket::INET
(
PeerAddr=>$ip, #PeerAddr von $sock ist eingegebener Paramenter $ipaddr
PeerPort=>$port, #PeerPort von $sock ist eingegebener Paramenter $port
Proto=>'udp' #Transportprotokoll: UDP
);
die "Konnte keine Verbindung herstellen: $!\n" unless $socket;
print "Mit $ip verbunden !\n";
#Hauptschleife
#do
while(1)
{
#Datei in String einlesen
open (DATEI, "/root/Documents/Socket-Programmierung_2/Datei/test.txt") or die $!;
while(<DATEI>)
{
$daten = $daten.$_;
}
close (DATEI);
#Prüfsumme ermitteln
$checksum_Client = unpack ("%16C*", $daten);
#Prüfsumme an Server senden
$socket->send($checksum_Client);
print("Prüfsumme: $checksum_Client\n");
#packen
$Bestaetigung = 0;
print "3\n";
#Startzeit setzen
($start_sec, $start_usec) = gettimeofday();
while($Bestaetigung == 0)
{
print "31\n";
#Bestaetigung erhalten
$socket->recv($Bestaetigung,1024);
print "32\n";
if($Bestaetigung == 0)
{
print "33\n";
#sende Datenpakete zu Server
$socket->send($daten);
print "34\n";
}
}
#Endzeit setzen
($end_sec, $end_usec) = gettimeofday();
print "4\n";
#Sendezeit ermitteln
$timeDelta = ($end_usec - $start_usec)/1000 + ($end_sec - $start_sec)*1000;
print "Die Sendezeit betraegt: $timeDelta ms\n";
#Abfrage ob Programm beenden
print "Wenn Programm durchgeführt werden soll dann bitte j eingeben, ansonsten beliebiges anderes Zeichen eingeben\n";
$end = <STDIN>;
}
#while($end eq 'j');
#Schließe Socket
$socket -> close();
1 2 3 4 5 6 7 8 9 10 11
my $buffer = 'Das ist ein Text \x0D\x07Test,!#FooBar'; my $zipped_output = ''; my $unzipped_output = ''; # komprimieren use IO::Compress:Zip qw(zip $ZipError); my $status = zip \$buffer => \$zipped_outputor die "zip schlug fehl!: $ZipError\n"; # dekomprimieren use IO::Uncompress::Unzip qw(unzip $UnzipError); my $status = unzip \$buffer => \$unzipped_output or die "unzip schlug fehl: $UnzipError\n";
1 2 3 4 5 6 7 8 9 10 11 12 13 14
sub ge_16bit { use bytes; return length($_[0])>=2 ? 1 : 0; } my $buffer = "Z"; say $buffer, ' >=16bit: ', ge_16bit($buffer); $buffer = "Fo"; say $buffer, ' >=16bit: ', ge_16bit($buffer); $buffer = "FooBar"; say $buffer, ' >=16bit: ', ge_16bit($buffer);
1 2 3 4 5 6
use constant TRUE => 1; use constant FALSE => 0; my $TEST = not FALSE; print $TEST;
1
2
3
4
#packen
$zip_daten = '';
use IO::Compress::Zip qw(zip $ZipError);
$status = zip $daten => $zip_daten or die "zip schlug fehl!: $ZipError\n";
1
2
3
4
#Entpacke
$unzip_daten = '';
use IO::Uncompress::Unzip qw(unzip $UnzipError);
$status = unzip $zip_daten => $unzip_daten or die "unzip schlug fehl: $UnzipError\n";