[IO::Socket] Größe einer Nachricht (Netzwerkprogrammierung und Netzwerke mit Perl)

[thread]16264[/thread]

[IO::Socket] Größe einer Nachricht

Tags: perl5 IO::Socket Ähnliche Threads

Leser: 30

Articles: hide open all | hide show old branches

+14 replies
pktm

2011-05-09 16:11
User since
2003-08-07
2921 Artikel
BenutzerIn
Hallo!

Wenn ich einen Socket habe:
Code: (dl )

1 2 3 4 5 6 7 8 9 10 11 12

my $client = IO::Socket::SSL->new ( PeerAddr => 'host', PeerPort => '123456789', Proto => 'tcp', ) || warn "Problem: " . IO::Socket::SSL::errstr(); my $msg = q~ this_msg_size:X blablabla blabla ~; $client->print($msg);
Wie bekomme ich raus, wie groß die Nachricht in $msg in Bytes ist? Ich möchte die Nachrichtengröße an der Stelle mit dem X einfügen. Dadurch ändert sich die Größe, nehme ich an. Wie bekomme ich die endgültige Größe vorher raus?

Grüße, pktm
http://www.intergastro-service.de (mein erstes CMS :) )
- +3 replies
- topeg
  
  2011-05-09 16:20
  User since
  2006-07-10
  2611 Artikel
  BenutzerIn
  ungetestet:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9
  
  my $msg=q~ this_msg_size: blablabla blabla ~; my $size=length($msg); $size+=length($size); $msg=~s/(this_msg_size:)/$1$size/s;
  
  Oder meinst du die Größe die das TCP-Paket haben wird?
  
  EDIT: Der Code hat einen Fehler, wenn ein Zehnersprung dabei ist.
  Last edited: 2011-05-09 16:37:12 +0200 (CEST)
  - +2 replies
  - pktm
    
    2011-05-09 16:33
    
    User since
    2003-08-07
    2921 Artikel
    BenutzerIn
    
    Hm... das wird som in der HBCI-Definition gefordert. Da steht zu diesem Feld:
    
    Quote
    Nachrichtengröße
    
    Größe der Nachricht (nach Verschlüsselung und Komprimierung) in Byte. Das DE ist mit führenden Nullen auf die vorgegebene feste Länge aufzufüllen. Dies ist erforderlich, damit die Nachrichtenlänge nicht mit der Länge des DE variiert.
    
    Typ: DE Format: dig
    Länge: 12
    Version: 1
    
    Also nehme ich mal an, ist es so ziemlich genau das, was du geschrieben hast. Mal schauen, wann ich das testen kann :)
    http://www.intergastro-service.de (mein erstes CMS :) )
    - topeg
      
      2011-05-09 16:52
      
      User since
      2006-07-10
      2611 Artikel
      BenutzerIn
      
      Hier die korrekte Berechnung:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9
      
      my $msg=q~ this_msg_size: blablabla blabla ~; my $size=length($msg); $size+=length($size+length($size)); $msg=~s/(this_msg_size:)/$1$size/s;
      
      Hoffe ich. :-)
- +10 replies
- rosti
  
  2011-05-09 18:35
  
  User since
  2011-03-19
  3193 Artikel
  BenutzerIn
  
  Hmm, also normalerweise kann stat auch mit einem Handle umgehen und ein Socket ist ja ein Handle. Aber ich gebe zu, ich habs mit stat auch nicht herausbekommen, bei der Abfrage eines Zeitservers ist [7] auf 0 und ich weiß, dass es 4 Byte sind.
  
  Teste Du bitte mal, ob Dir stat oder File::stat was Brauchbares liefert.
  - +9 replies
  - pktm
    
    2011-05-10 09:33
    
    User since
    2003-08-07
    2921 Artikel
    BenutzerIn
    
    Ja Moment, wenn ich mit stat() auf das Handle gehe, muss ich die Nachricht doch bereits versendet haben - oder? Und in der Nachricht muss die Größe bereits enthalten sein.
    http://www.intergastro-service.de (mein erstes CMS :) )
    - +8 replies
    - rosti
      
      2011-05-10 19:33
      
      User since
      2011-03-19
      3193 Artikel
      BenutzerIn
      
      Hi,
      stat liefert "was" und danach kann das Handle gelesen werden, Beispiel:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
      
      use strict; use IO::Socket; my $socket = new IO::Socket::INET ( PeerAddr => 'ptbtime1.ptb.de', PeerPort => 37, Proto => 'tcp' ) or die "Kein Socket bekommen!"; my @stat = stat($socket); print join "\n", @stat; read ($socket, my $buffer, 4); print unpack "N", $buffer; # seconds since 1.1.1900
      
      Allerdings ist [7] auf 0. Guck Du mal bitte, ob [7] in Deinem Fall was liefert.
      
      Was Du auf den "Server" machen könntest (falls möglich): Einen "Header" senden, z.B. 4 Byte mit der Längenangabe. Das läuft dann so ab: 4 Byte lesen zum Ermitteln der Länge. Danach kann mit read() das komplette Socket gelesen werden, oder es wird halt gepuffert.
      
      --Rosti
      - +7 replies
      - pktm
        
        2011-05-10 20:31
        
        User since
        2003-08-07
        2921 Artikel
        BenutzerIn
        
        Hier ist meine Ausgabe:
        
        Code: (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13
        
        3 0 4096 1 0 0 3 0 0 0 0 3514040766
        
        Also 0.
        
        Allerdings ist es so, dass ich keinen Zugriff auf den Server habe. Oder ich stehe gerade auf dem Schlauch, kann auch sein.
        
        Der Server ist einer von einer Bank mit einem HBCI-Interface, meine Nachricht geht da hin, um mich zu authentifizieren. Wenn ich mit dem Server kommunizieren will, muss ich ihm sagen, wie groß die Nachricht ist, die gerade bei ihm ankommt. Dafür gibt es ein Segment. Das heißt, ich schicke, ich lese nichts. Wenn ich lese, dann Segmente, die mir der Server schickt - als Antwort auf meine Anfragen. Und bereits die erste muss die Grüße enthalten.
        
        Sorry, falls ich da auf der falschen Spur bin - eventuell versuchst du nochmal es mir zu erklären :)
        http://www.intergastro-service.de (mein erstes CMS :) )
        
        +6 replies
        
        rosti
        
        2011-05-10 21:15
        
        User since
        2011-03-19
        3193 Artikel
        BenutzerIn
        
        Hmm, also stat() ist ungeeigent so wie ich das jetzt sehe. Über das Protokoll zu HBCI habe ich nicht viel gefunden, nur soviel, dass ich konstatieren muss, dass es grottenschlecht designed ist: Es fehlen Längenangaben und die Trennung der Segmente ist zeichenorientiert. Selbst angehängte Binaries haben eine Längenangabe zwischen Klammeraffen als Zahl in Textform (Beispiel 10 Bytes: @10@). Das ist echt der Hammer, das OSI-Referenzmodell wird vergewaltigt, indem die Darstellungsschicht (Zeichen) in den Layer 4 (TCP) geschleppt wird; in diesen Layer gehören "Bytes" und keine "Zeichen", letztere gehören in den Layer 7.
        
        Tut mir echt leid, dass ich da nicht weiterhelfen kann. Bitte betrachte mein Klugschei?er-Gelaber als tröstende Worte ;)
        
        Viele Grüße,
        Rolf
        
        +5 replies
        
        pktm
        
        2011-05-10 21:29
        
        User since
        2003-08-07
        2921 Artikel
        BenutzerIn
        
        Kein Problem. Wie heißt es so schön: jeder Umweg verbessert die Ortskenntnis :)
        http://www.intergastro-service.de (mein erstes CMS :) )
        
        +4 replies
        
        rosti
        
        2011-05-11 07:42
        
        User since
        2011-03-19
        3193 Artikel
        BenutzerIn
        
        Das ist richtig ;)
        
        Vielleicht noch ein paar Worte zu Sockets. Ein S. ist ein Handle auf dem OSI-Layer 4 (TCP). In einem S. können Rohdaten übertragen werden, das sind Byte-Sequenzen. Betrachten wir das Net-Time-Protocol, da wird das gemacht:
        
        Ein Zeitserver hat auf Port 37 ein S. offen. Ein Client macht das S. (handle) auf und liest genau 4 Byte, 32 Bit. Es sind immer 4 Byte, auch wenn die Zahl, die Anzahl der Sekunden seit 1.1.1900 ständig wächst.
        
        Auf diese Art und Weise können natürlich auch ganz andere Byte-Sequenzen in Sockets übertragen werden. Sequenzen können unterteilt sein in "Sätze" bzw. Records. In Sachen HBCI ist von Segementen die Rede, dieser Begriff ist ein bischen irreführend.
        
        Freilich kann auch Text in ein Socket, das sind auch nur Bytes, nur diese Bytes sind eben auch lesbar.
        
        In Perl gibt es ein Modul, was komplexte Datenstrukturen in binary Sequenzen serialisiert: Storable.pm
        
        Gewöhnlich wird Storable.pm genutzt, um Daten in Dateien zu schreiben oder aus Dateien zu lesen. Storable.pm hat Methoden, die mit einem Handle umgehen können, und so kann mit Storable auch eine komplexe Datenstruktur in ein Socket geschrieben werden und am anderen Ende aus dem Socket auch wieder gelesen und unzerknittert wiederhergestellt werden. In diesem Fall ist aus dem Socket die gesamte Seuenz zu lesen.
        
        Andere Serialize-Algorithmen arbeiten mit Längenangaben oder mit Records, die eine konstante Länge haben. Der Phantasie zum Serialisieren sind nur Grenzen gesetzt hinsichtlich der Performance. In einem Socket braucht es keine Komma's zum Trennen der Records, die Strukturierung erfolg auf Byte-Ebene.
        
        Die Designer von HBCI haben das gründlich missverstanden und so erfordert die maschinelle Verarbeitung der "Segmente" einen unnötigen und unangemessenen Aufwand, es fehlen u.a. die Längenangaben. Wo es doch so einfach ist, eine Längenangabe in eine feste Anzahl an Bits zu packen.
        
        Viele Grüße,
        Rolf
        
        Zum Spielen, Socket-Server und Client untenstehend:
        
        Code (perl): (dl )
        
        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
        
        #!/usr/bin/perl ########################################################################### # Server, der an einem bestimmten Port lauscht ########################################################################### use strict; use IO::Socket qw(SOMAXCONN); my $port = 8787; my $server_sock = IO::Socket::INET->new( LocalPort => $port, Listen => SOMAXCONN, Proto => 'TCP', Reuse => 1, ) or die "Kann Socket nicht aufbauen"; print "Warte auf Daten an Port $port\n\n"; while(my $peer = $server_sock->accept){ my $data = <$peer>; print $data; print $peer qq(<policy-file-request/>); $peer->close; } #!/usr/bin/perl ########################################################################### # Einfacher Client, der in ein Socket schreibt ########################################################################### use strict; use IO::Socket; my $socket = new IO::Socket::INET ( PeerAddr => 'rolfrost', PeerPort => 8787, Proto => 'tcp' ) or die "Kein Socket bekommen!"; print $socket "123456789\n"; $socket->close;
        
        +3 replies
        
        pq
        
        2011-05-11 11:55
        
        User since
        2003-08-04
        12208 Artikel
        Admin1
        
        gibt es einen grund dafür, dass du ans ende deiner postings oft eine reihe von zeilen mit je einem leerzeichen anhängst? kriegen deine postings sonst klaustrophobie? oder macht dein browser da irgendwas komisches?
        Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
        lesen: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem
        
        rosti
        
        2011-05-11 12:00
        
        User since
        2011-03-19
        3193 Artikel
        BenutzerIn
        
        Oh, Space-padding. Es hat den Grund der Gewohnheit, sorry. Ich schreibe nicht gerne am Rand und mein c-Compiler tut nicht, wenn die main-Datei am } zuende ist. Vorschlag zur POST-Verarbeitung: unpack "A*", $post; da fliegt das alles raus ;)
        
        pktm
        
        2011-05-11 13:06
        
        User since
        2003-08-07
        2921 Artikel
        BenutzerIn
        
        Ja, ich habe mich auch schon gewundert, warum das Forum das nicht einfach abschneidet.
        http://www.intergastro-service.de (mein erstes CMS :) )

View all threads created 2011-05-09 16:11.