IRC-Log: Netzwerkprotokolle

[Chewie]

Hier das Chatlog von heute abend:

Zitat:

[20:18] <[DP]Chewie> OK, ich würd sagen, wir fangen an
[20:19] <[DP]Weber> juhu
[20:19] * Luckie slaps Luckie around a bit with a TCL powered popup
[20:19] <Luckie> Aua.
[20:19] <[DP]flomei> yeah. get this party started
[20:19] <[DP]flomei> Wie hast du das gemacht Luckie?
[20:19] <[DP]flomei> anderer irc client als mirc oder was?
[20:19] <[DP]Chewie> lehnen Sie sich zurück, entspannen Sie sich und legen Sie ihre Sicherheitsgurte an. Wie heben ab
[20:19] * Sanchez0815 slaps Sanchez0815 around a bit with Tux, the Linux Penguin
[20:19] <Luckie> XiRCON
[20:19] <[DP]Chewie> und keine Schläge mehr!
[20:19] <[DP]Weber> ich habe angst vorm fliegen
[20:20] <[DP]Chewie> Heute gehts also darum, wie Daten von einem Rechner über ein Netzwerk an einen anderen geschickt werden
[20:20] <[DP]Chewie> Genauer gesagt, wie der Datentransfer im einzelnen abläuft
[20:20] <Mirilin[dp]> mom. wer macht den log???
[20:20] * MattzeW has joined #Delphi-Praxis
[20:20] <[DP]flomei> ich logge mit. aber wer anders muss auch noch
[20:20] <MattzeW> Hallo :hi:
[20:21] <[DP]Weber> hi
[20:21] <Mirilin[dp]> hi mattzeW
[20:21] <Luckie> Ich habe es bei meien Client noch nicht rausgefunden, wie man mit logged.
[20:21] <[DP]Chewie> ich dachte eigentlich, ich mache einen. Ich kann ihn nur nicht finden
[20:22] <[DP]flomei> welchen client hast du chewie?
[20:22] <[DP]Weber> das ist vorbereitung
[20:22] <[DP]Chewie> aber Logging ist eingestellt, also wirds (hoffentllich) auch gehen
[20:22] <[DP]Chewie> Ready to go?
[20:22] <[DP]flomei> ja
[20:22] <[DP]Weber> ja
[20:22] <Sanchez0815> ja
[20:22] <Luckie> Sorry. Big daddy will ins Internet. Ich muß. Bis später dann.
[20:23] * Luckie has quit IRC (Quit: Leaving)
[20:23] <[DP]Chewie> Dabei wird die richtige Übertragung sichergestellt durch eine Reihe von Protokollen, die in verschiedenen Schichten eingeteilt sind
[20:23] <[DP]Chewie> Die Aufgaben jeder schicht sind genau definiert
[20:24] <[DP]Chewie> Insgesamt gibt es 7 Schichten
[20:24] <[DP]flomei> ja
[20:24] <[DP]Chewie> Wenn ein rechner Daten versenden will, durchlaufen die Daten die Protokolle dieser 7 Schichten, bevor sie versendet werrden
[20:24] <[DP]Chewie> soweit klar?
[20:24] <[DP]flomei> ja
[20:24] <[DP]Weber> ja
[20:24] <[DP]Chewie> die andern?
[20:24] <Sanchez0815> klar
[20:24] <MattzeW> SDicher doch
[20:24] <[DP]Chewie> OK
[20:25] <Woody4U> kaut ihr jetzt hier das OSI model durch?
[20:25] <Mirilin[dp]> ja
[20:25] <[DP]Weber> bestimmt
[20:25] <[DP]Chewie> ich kaus nicht durch, aber ich schneids kurz an
[20:25] <[DP]Chewie> Wie Woody schon bemerkt hat, nennt man das ganze Modell das Schichtmodell
[20:26] <[DP]Chewie> die unteren Schichten nennt man die Netzwerkschicht, die oberen die Anwendungsschicht
[20:26] <[DP]Chewie> Die erste Ebene ist für die tatsächliche Übertragung der Daten zuständig
[20:26] <[DP]Chewie> sie heißt "Physical Layer", also physikalische Schicht
[20:28] <[DP]Chewie> die zweite Schicht, die "Sicherungsschicht", sorgt für eine fehlerfreie Übertragung und spaltet die Daten in Frames auf
[20:28] <[DP]Chewie> die dritte Schicht ist die Vermittlungsschicht
[20:28] * SL has joined #Delphi-Praxis
[20:29] * onlinehome has joined #Delphi-Praxis
[20:29] <[DP]Chewie> Sie ist für die Vermittlung der Daten zuständig, also vor allem für die Wegfindung der Pakete durch ein Netz
[20:29] <SL> Huhu...
[20:29] <[DP]Chewie> das ganze nennt sich dann Routing.
[20:29] <Mirilin[dp]> hi zusammen
[20:29] <SL> Hats hier schon angefangen?
[20:29] <MattzeW> ja
[20:29] <SL> dann geh ich wieder
[20:29] <[DP]Chewie> ne, bleib doch da
[20:29] <MattzeW> tschüß
[20:29] <[DP]Chewie> Soweit verstanden (keine Angst, ich werd es später nochmal verdeutlichen)
[20:30] <SL> Das erste mal seitdem es das hier gibt das vor 20.30Uhr angefangen wurde, das ist jetzt blöd
[20:30] <[DP]Chewie> ?
[20:30] <[DP]flomei> ja. habs verstanden
[20:30] <Sanchez0815> alles verstanden
[20:30] <[DP]Weber> ich auch
[20:30] <MattzeW> ok verstanden
[20:30] <[DP]Chewie> OK. Wenn ihr Fragen habt, ruft ruhig dazwischen
[20:31] <SL> <-- Frage hat
[20:31] <[DP]Chewie> Also, wir waren bei der Vermittlungsschicht. Der bekannteste Vertreter hier ist IP
[20:31] <[DP]Chewie> Ja *mit dem Zeigestockj auf SL zeig"
[20:31] <SL> Wer auch immer der Chef ist, könntest Du nochmal von vorne anfangen?
[20:32] <[DP]Chewie> wart ma
[20:32] <[DP]Weber> bitte nicht nochmal von vorn
[20:32] <[DP]Weber> *heul*
[20:32] <[DP]Weber> kannst doch den log lesen
[20:32] <[DP]Weber> viel hast du nicht verpasst
[20:33] * Disconnected
[20:33] * /join: not connected to server
Session Close: Sun Sep 07 20:33:48 2003

Session Start: Sun Sep 07 20:33:52 2003
Session Ident: #Delphi-Praxis
[20:33] * Now talking in #Delphi-Praxis
[20:33] * Topic is 'DP Themenabend: Netzwerk'
[20:33] * Set by Woody4U on Sun Sep 07 20:15:12
[20:33] <[DP]flomei> na also.
[20:33] <[DP]Chewie> verdammt
[20:34] <[DP]flomei> du redest zuviel...
[20:34] <[DP]Chewie> ich weiß
[20:34] <[DP]Chewie> na ja, wo waren wir?
[20:34] <MattzeW> bei der 3. Schicht
[20:34] <[DP]Chewie> OK, nach der Vermittlungsschicht kommt die Transportschicht
[20:34] <[DP]Chewie> hier werden zwei Typen von Protokollen unterschieden:
[20:35] <[DP]Chewie> verbindungslose und -orientierte Protokolle.
[20:35] <MattzeW> tcp/udp
[20:35] <Woody4U> also eher udp/tdp
[20:35] <SL> Jungs und Mädels, macht es gut!
[20:35] <SL> :dp:
[20:35] <[DP]Chewie> Verbindungslose Protokolle sind unsicherer, da keine fehlerfreie Übertragung gewährleistet wird, aber dafür schneller
[20:35] <SL> :hi:
[20:35] <[DP]Weber> thüss
[20:35] <SL> Tschööö...
[20:35] <[DP]Chewie> bekanntestes Beispiel ist UDP
[20:35] * SL has quit IRC (Quit: Leaving)
[20:36] <Mirilin[dp]> hi sl
[20:36] <[DP]Chewie> Verbindungsorientierte Protokolle dagegene überprüfen, ob Daten richtig angekommmen sind. Dafür sind sie langsamewr
[20:37] <[DP]Chewie> die 4. Schicht ist die oberste der Netzwerkschichten
[20:37] <onlinehome> bye
[20:37] <[DP]Chewie> jetzt folgen die 3 Anwendungsschichten
[20:37] * onlinehome has quit IRC (Quit: Trillian (http://www.ceruleanstudios.com))
[20:37] <[DP]Chewie> die drei Schichten heißen: Sitzungsschicht, Darstellungsschicht und Anwendungsschicht
[20:38] <[DP]flomei> erklärst du noch welche schicht genau was macht?
[20:38] <[DP]Chewie> die Sitzungsschicht verwaltet die Verbindungen auf einem Rechner, die Darstellungsschicht sorgt dafür, dass alle Datentypen richtiog interpretiert werden
[20:38] <[DP]flomei> Anwendungsschicht is wahrscheinlich das Programm die Schnittstelle zum Benutzer aber die anderen beiden? was machen die?
[20:38] <[DP]flomei> ach so
[20:39] <[DP]flomei> anwendungsschicht = Programm?
[20:39] <[DP]Chewie> zum Beispiel: Daten sollen zwischen einem x86-rechner und irgeneinem anderen System ausgetauscht werden, bei dem die höherwertigen Bytes am Anfang stehen
[20:40] <[DP]Chewie> die Darstellungsschiocht sorgt für die identische Kodierung der Daten
[20:40] <Woody4U> also einem mac z.b.
[20:40] <[DP]Chewie> die Anwendungsschicht schließlich ist die direkte Schnittstelle zur Anwendung
[20:40] <[DP]flomei> aha
[20:41] <[DP]flomei> sowas wie die Komponente?
[20:41] <[DP]Chewie> zum Beispiel ist FTP das Protokoll der Anwendungsschicht bei einem FTP-Client
[20:41] <[DP]flomei> ach so
[20:41] <[DP]Chewie> oder Telnet bei einem Telnet-Client
[20:41] <[DP]Chewie> ist alles sehr theoretisch, aber wichtig, um zu verstehen, welche Schritte ein String durchläufg, bbevor er versendet wird
[20:42] <[DP]Chewie> so, damit man diesen Wulst besser veersteht, hier ein "Beispiel aus der Praxis"
[20:42] <[DP]Chewie> man kann sich das ganze etwa so vorstellen:
[20:43] <MattzeW> bye
[20:43] <[DP]Chewie> in einer Firma schreibt der Chef einen Brief, diesen leitet er weiter an seinen Sekretär zum Versand
[20:43] <[DP]Weber> bye
[20:43] * MattzeW has quit IRC (Read error: EOF from client)
[20:43] <[DP]Chewie> der Sekretär fügt dem Brief den Briefkopf der Firma hinzu und packt ihn ein
[20:44] <[DP]Chewie> ein anderer Mitarbeiter bringt den Breif zur Post und klebt die Marke drauf. Anschließend wird der Brief von der Past per LKW zum Fllugplatz gebracht,
[20:44] <[DP]Weber> na gut werde dann mal gehen, werde mir aber das log angucken
[20:44] <[DP]Weber> bye
[20:45] <Mirilin[dp]> bye
[20:45] <[DP]Weber> UCcu 8)
[20:45] <Woody4U> und dann weider zurück weil der empfänger in der gleich stadt ist
[20:45] <Woody4U> *gg*
[20:45] <Sanchez0815> bye
[20:45] <[DP]Chewie> usw.
[20:45] * [DP]Weber has quit IRC (Quit)
[20:46] <[DP]Chewie> wenn der Brief an der Empfängerfirma ankommt, wird er zuerst an die entsprechende Abteilung geschickt.
[20:46] <[DP]Chewie> dort wird der von einem Mitarbeiter an seinen Chef weitergeleitet
[20:46] <[DP]flomei> der Chef liest ihn...
[20:46] <[DP]Chewie> worauf ich hinaus will: beim Versand werden die Rohdaten (Text des Briefes) von Schicht zu Schicht verpackt
[20:47] <[DP]Chewie> erst Brief, dann Marke, später noch im Sammelcontainer im LKW
[20:47] <[DP]Chewie> und beim Empfänger in eben der Reihenfolge entpackt
[20:47] <[DP]Chewie> und genauso geht das mit den Netzwerkprotokollenn
[20:48] <[DP]Chewie> zuerst werden die Headerdaten des 7. Protokolls zu den Rohdaten hinzugefügt, dann die des 6. usw.
[20:48] <[DP]Chewie> und beim Empfanngen in der umgekehrrten Reihenfolge entpackt.
[20:48] <[DP]flomei> aha
[20:48] <[DP]Chewie> Soweit verstanden?
[20:48] <[DP]flomei> das war doch mal ein leicht verständliches Beispiel
[20:48] <[DP]Chewie> war das ironisch oder ehrlich gemeint??
[20:48] <Mirilin[dp]> ehrlich
[20:49] <[DP]Chewie> na dann ;-)
[20:49] <Sanchez0815> klar
[20:49] <[DP]flomei> das war ehrlich!
[20:49] <[DP]Chewie> Also, was wir gesehen haben, ist dass jedes Protokoll nur mit seinem benachbarten kommmunizieren kann
[20:50] <[DP]Chewie> klar, ich kann ja auch nicht zur Post gehen mit einem Zettel. Ich brauche erst einen Briefumschlag und eine Marke
[20:50] <[DP]flomei> d.h. der chef kann den brief nicht selber wegbringen weil der kopf fehlt usw
[20:50] <[DP]flomei> mist nun war er schneller
[20:50] <[DP]Chewie> genau so
[20:51] <[DP]Chewie> Wenn wir also eine Website aufrufen, wird zunächst an den Server der Befehl /GET <Adresse> geschickt
[20:51] <[DP]Chewie> im HTTP-Header werden einige Daten hinzugefügt, dann kommen TCP-Header, IP-Header usw.
[20:52] <[DP]Chewie> Und genau so gehts jetzt weiter, mit TCP, IP und UDP
[20:52] <[DP]Chewie> mal schauen, wie das hier aussieht
[20:52] <[DP]Chewie> 0 15-16 31
[20:52] <[DP]Chewie> +-----+-----+-----------+-----------------------+ \
[20:52] <[DP]Chewie> | Ver | IHL | TOS | Total Length | \
[20:52] <[DP]Chewie> | (4) | (4) | (8) | (16 ) | |
[20:52] <[DP]Chewie> +-----+-----+-----------+--------+--------------+ |
[20:52] <[DP]Chewie> | Identification | Flags | Frag Offset | |
[20:52] <[DP]Chewie> | (16) | (3) | (13) | |
[20:52] <[DP]Chewie> +-----------+-----------+--------+--------------+ |
[20:52] <[DP]Chewie> | TTL | Protocol | Header Checksum | 20 Bytes
[20:52] <[DP]Chewie> | (8) | (8) | (16) | |
[20:52] <[DP]Chewie> +-----------+-----------+-----------------------+ |
[20:52] <[DP]Chewie> | Source Ip Address | |
[20:52] <[DP]Chewie> | (32) | |
[20:52] <[DP]Chewie> +-----------------------------------------------+ |
[20:52] <[DP]Chewie> | Destination Ip Address | |
[20:52] <[DP]Chewie> | (32) | /
[20:52] <[DP]Chewie> +-----------------------------------------------+ /
[20:52] * Disconnected
Session Close: Sun Sep 07 20:52:34 2003

Session Start: Sun Sep 07 20:52:36 2003
Session Ident: #Delphi-Praxis
[20:52] * Now talking in #Delphi-Praxis
[20:52] * Topic is 'DP Themenabend: Netzwerk'
[20:52] * Set by Woody4U on Sun Sep 07 20:15:12
[20:52] <[DP]Chewie> lol
[20:52] <[DP]flomei> lol
[20:52] <[DP]Chewie> das nächste Mal in zwei Teilen ;-)
[20:53] <[DP]Chewie> 0 15-16 31
[20:53] <[DP]Chewie> +-----+-----+-----------+-----------------------+ \
[20:53] <[DP]Chewie> | Ver | IHL | TOS | Total Length | \
[20:53] <[DP]Chewie> | (4) | (4) | (8) | (16 ) | |
[20:53] <[DP]Chewie> +-----+-----+-----------+--------+--------------+ |
[20:53] <[DP]Chewie> | Identification | Flags | Frag Offset | |
[20:53] <[DP]Chewie> | (16) | (3) | (13) | |
[20:53] <[DP]Chewie> +-----------+-----------+--------+--------------+ |
[20:53] <[DP]Chewie> | TTL | Protocol | Header Checksum | 20 Bytes
[20:53] <[DP]Chewie> | (8) | (8) | (16) | |
[20:53] <[DP]Chewie> +-----------+-----------+-----------------------+ |
[20:53] <[DP]Chewie> | Source Ip Address | |
[20:53] <[DP]Chewie> | (32) | |
[20:53] <[DP]Chewie> +-----------------------------------------------+ |
[20:53] <[DP]Chewie> | Destination Ip Address | |
[20:53] <[DP]Chewie> | (32) | /
[20:53] <[DP]Chewie> +-----------------------------------------------+ /
[20:53] <[DP]Chewie> jo, geht doch
[20:53] <[DP]Chewie> also, dieser Wulst ist der IP-Header und ist Bestandteil jedes IP-Paketes
[20:53] <[DP]flomei> aha
[20:54] <[DP]Chewie> die Zahlen in Klammern sinnd die Bitgrößen, der ganze Paketheader ist 20 Byte groß
[20:54] <[DP]Chewie> allerdings gibt es noch optional Optionen am Ende des Headers. Deswegen gibt es das Feld IHL - Internet Header Length
[20:55] <[DP]Chewie> gibt die Größe des Headers an
[20:55] <[DP]Chewie> wollt ihr wissen, was die einzelnen Felder alle bedeuten?
[20:55] <Mirilin[dp]> jo
[20:56] <[DP]Chewie> sicher? Kann ein bisschen dauern, sind ja immerhin 12
[20:56] <[DP]flomei> ich denke damit werden daten übertragen. client und server ip. typ des verwendeten protokolls
[20:56] <Sanchez0815> Ver = Version?
[20:56] <[DP]flomei> und noch mehr zeug
[20:56] <[DP]Chewie> source ip und destination ip
[20:56] <Mirilin[dp]> @chewie, lass es sonst
[20:56] <[DP]Chewie> dürften klar sein
[20:56] <Sanchez0815> TTL = Time To Life
[20:56] <[DP]Chewie> Protocol ist der Typ des verwendeten Prokolls derr 4. Schicht
[20:57] <[DP]Chewie> Kleine Zwiwchenfrage: welche Protokolle kommen hier in Frage?
[20:57] <[DP]flomei> tcp und ftp???
[20:57] <[DP]flomei> oder so???
[20:57] <[DP]Chewie> tcp ja, ftp ist Anwendungsshicht
[20:57] <Sanchez0815> udp und tcp
[20:57] <[DP]flomei> hm
[20:58] <[DP]Chewie> bingo
[20:58] <[DP]Chewie> udp udn tcp werden am häufigsten verwendet
[20:58] <Sanchez0815> :-)
[20:58] <[DP]flomei> wieder was gelernt
[20:58] <[DP]Chewie> daneben noch ICMP recht häufig, das wird u.a. zum Pingen gebraucht
[20:58] <[DP]Chewie> oder für Tracerouting
[20:59] <[DP]flomei> aha
[21:00] <[DP]Chewie> OK, der IP-Header kodiert die Daten also so, dass sie einen bestimmten Rechner erreichen. Doch da fehlt doch noch was, nicht? Schließlich muss ja der empfangene Rechner wissen, ob das Datenpaket jetzt für den Browser ist oder für den FTP-Client
[21:00] <[DP]Chewie> Da kommt die Transportschicht mit den Ports ins Spiel
[21:00] <[DP]flomei> werden die mit in den header geschrieben?!
[21:00] <[DP]Chewie> der TCP-Header sieht so aus:
[21:01] <[DP]Chewie> 0 15-16 31
[21:01] <[DP]Chewie> +-----------------------+-----------------------+ \
[21:01] <[DP]Chewie> | Source Port | Destination Port | \
[21:01] <[DP]Chewie> | (16b) | (16b) | |
[21:01] <[DP]Chewie> +-----------------------+-----------------------+ |
[21:01] <[DP]Chewie> | Sequence Number | |
[21:01] <[DP]Chewie> | (32b) | |
[21:01] <[DP]Chewie> +-----------------------------------------------+ |
[21:01] <[DP]Chewie> | Acknowledgement | |
[21:01] <[DP]Chewie> | (32b) | |
[21:01] <[DP]Chewie> +-------+------+--------+-----------------------+ 20 Bytes
[21:01] <[DP]Chewie> | D_Off | Res | Flags | Windows | |
[21:01] <[DP]Chewie> | (4b) | (6b) | (6b) | (16b) | |
[21:01] <[DP]Chewie> +-------+------+--------+-----------------------+ |
[21:01] <[DP]Chewie> | Checksum | Urgent Pointer | |
[21:01] <[DP]Chewie> | (16b) | (16b) | |
[21:01] <[DP]Chewie> +-----------------------+------------+----------+ |
[21:01] <[DP]Chewie> | Options | Padding | |
[21:01] <[DP]Chewie> | (24b) | (8b) | /
[21:01] <[DP]Chewie> +------------------------------------+----------+ /
[21:01] <[DP]Chewie> nein, die kommen in diesen extra Header
[21:01] <[DP]Chewie> grob gesagt: jede Schicht hat ihren eigenen Header
[21:01] <[DP]Chewie> hier ist vor allem Source und Destination Port wichtig
[21:02] <[DP]Chewie> daneben noch Sequence Number und Acknowledgement
[21:02] <[DP]Chewie> die sind für den sicheren Transport erforderlich
[21:02] <[DP]flomei> verstehe ich. source port um zu sehen von wem das kam und destination port um zu sehen wo es hin soll
[21:02] <[DP]Chewie> richtig
[21:02] <[DP]flomei> gut
[21:03] <[DP]Chewie> und die Prüfung funktioniert folgendermaßen: ich schick dir ein Paket. Bekomst du es, schickst du mir die seqzuence number zurück
[21:04] <[DP]Chewie> dann weiß, es ist angekommen
[21:04] <[DP]Chewie> bekomm ich innerhalb von einer bestimmten Zeit nix zurück, schick ich es nochmal
[21:04] <[DP]Chewie> so verhindere ich, dass Pakete verloren gehen.
[21:04] <[DP]Chewie> Klar soweit?
[21:04] <Sanchez0815> klar
[21:04] <[DP]Chewie> Noch andre Fragen?
[21:05] <Sanchez0815> noch nicht
[21:05] <[DP]flomei> klar
[21:05] <[DP]Chewie> OK, im Gegensatz zu TCP ist UDP sehr simpel aufgebaut. Der Header sieht so aus:
[21:05] <[DP]Chewie> 0 15-16 31
[21:05] <[DP]Chewie> +-----------------------+-----------------------+
[21:05] <[DP]Chewie> | Source Port | Destination Port |
[21:05] <[DP]Chewie> | (16 b) | (16 b) |
[21:05] <[DP]Chewie> +-----------------------+-----------------------+
[21:05] <[DP]Chewie> | Length | Checksum |
[21:05] <[DP]Chewie> | (16 b) | (16 b) |
[21:05] <[DP]Chewie> +-----------------------+-----------------------+
[21:05] <[DP]flomei> aha
[21:06] <[DP]Chewie> also nur das nötigste: die beiden Ports, eine Prüfsumme und die Anzahl der Nutzdaten
[21:06] <[DP]Chewie> sonst nix
[21:06] <[DP]flomei> bei UDP geht es doch auch hauptsächlich darum mitzuteilen auf welchem port z.B. kommuniziert wird
[21:06] <[DP]flomei> und die IP eines Servers
[21:07] <[DP]Chewie> was man mit UDP alles macht, weiß ich nicht, aber grundsätzlich kann man damit alles machen, was man mit TCP machen kann
[21:07] <[DP]Chewie> es kommt immer drauf an, was man will: sichere oder schnele
[21:07] <[DP]Chewie> Übertragung
[21:07] <[DP]Chewie> UDP ist schnell, TCP sicher
[21:07] <[DP]Chewie> TrivialFTP benutzt z.B. UDP
[21:07] <[DP]Chewie> FTP oder HTTP benutzen TCP
[21:08] <Mirilin[dp]> alles klar soweit...
[21:09] <[DP]Chewie> OK, ich denke, hier können wir das Thema der Protokolle abschließen und uns der Implemntierung widmen
[21:09] <[DP]Chewie> oder sind noch Fragen über die Protokolle da?
[21:09] <Sanchez0815> nö, keine Fragen
[21:09] <[DP]Chewie> ich weiß, dass das hier nur ein sehr kurzer Abriss war, aber das ganze Thema ist sehr umfangreich
[21:10] <[DP]Chewie> sonst wer?
[21:10] <[DP]flomei> keine fragen. wer noch welche hat kann sich ja auch so mal informieren
[21:10] <[DP]Chewie> Also gut. Die Kommunikation zwischen zwei Rechner erfolgt mittels Sockets
[21:11] <[DP]flomei> ja
[21:11] <[DP]Chewie> ein Socket ist im wesentlichen die Verbindung von IP-Adresse und Port
[21:11] <[DP]Chewie> Dabei gibt es zwei Sachen, die Sockets tun können: schreiben und horchen
[21:12] <[DP]Chewie> ein schreibender Socket heißt auch ClientSocket, ein horchender ist ein ServerSocket
[21:12] <[DP]Chewie> ihr kennt die bestimmt schon als Komponenten in Delphi
[21:12] <[DP]flomei> Die WinSockets
[21:13] <[DP]Chewie> Das sind Kapselungen von Windows Sockets Funktionen. Ich werde gleich erkllären was das ist
[21:13] <[DP]Chewie> wir werden im übrigen heute ohne Socket-Komponenten auskommen
[21:13] <[DP]Chewie> wir werden die Socket-API direkt benutzen
[21:14] <[DP]flomei> aha
[21:14] <[DP]Chewie> aber keine Angst, das hört sich schwerer an, als es ist
[21:14] <[DP]flomei> NonWinSock
[21:14] <[DP]Chewie> nein, WinSock schon
[21:14] <Mirilin[dp]> zwischenfrage, wie lang geht das heute noch`?
[21:14] <[DP]Chewie> Sockets wurden für UNIX entwickelt als Weg zur Netzwerkkommunikation und Berkeley Sockets genannt
[21:15] <[DP]flomei> aha
[21:15] <[DP]flomei> Berkley macht Angelsachen... *g*
[21:15] <[DP]Chewie> nicht mehr arg lange, das wesentliche sollte in 15 Minuten fertig sein
[21:15] <Mirilin[dp]> oki
[21:16] <[DP]Chewie> Und MS hat diese Sockets in ihr Betriebsystem mit leichten Modifikationen integriert
[21:16] <[DP]Chewie> dort heißen sie Windows Sockets
[21:16] <[DP]Chewie> die Änderungen sind aber hauptsächlich abwärrtskompatibel geschehen, d.h. es kamen neue Funktionen dazu, die alten wurden aber weitgehend erhalten
[21:17] <[DP]flomei> sie wurden wahrscheinlich nur fenster-sicher gemacht
[21:17] <[DP]Chewie> nein, mit Fenstern hat das wenig zu tun
[21:17] <[DP]Chewie> die Funktionen, die UNIX nicht kennt, haben das Präfix WSA
[21:17] <[DP]flomei> hm...
[21:17] <[DP]flomei> schon gut
[21:17] <[DP]Chewie> inwiefern die übrigen Funktionen geändert wurden, weiß ich nicht genau
[21:18] <[DP]Chewie> OK, jetzt wäre der Zeitpunkt, Delphi zu starten
[21:19] <[DP]flomei> läuft!
[21:19] <[DP]Chewie> Gut
[21:19] <[DP]Chewie> Ihr braucht zunächst die Unit WinSock einbinden
[21:19] * [DP]flomei is ready to rumble
[21:19] <[DP]Chewie> also uses ..., Winsock;
[21:19] <[DP]flomei> jo
[21:19] <[DP]Chewie> und nun werden wir einen einfachen Portscanner basteln
[21:20] <[DP]flomei> alles klar
[21:20] <Mirilin[dp]> wie geht das :-)
[21:20] <[DP]flomei> ich würde probieren immer den localhost mit nem port zu verbinden
[21:21] <[DP]Chewie> am besten ihr zieht einen Button auf euer Formular und bearbietet die Click-Routine
[21:21] <[DP]flomei> und dabei alle ports durchgehen
[21:21] <[DP]Chewie> dann sehen wir weiter
[21:21] <[DP]Chewie> genau, einfach ne Schleife, die sich mit jedem Port verbinden will
[21:21] <[DP]Chewie> doch wir müssen unsere Sockets erstmal initialisieren
[21:22] <[DP]Chewie> bevor ihr irgendwas mit den WinSockets machen könnt, müsst ihr erstmal Windows mitteilen, welche Version der Windows-Sockets ihr benötigt
[21:22] <[DP]flomei> ja
[21:22] <[DP]Chewie> das machen wir mit WSAStartup()
[21:22] <[DP]flomei> an welcher stelle platzieren wir das? im OnCreate???
[21:23] <[DP]Chewie> am besten
[21:23] <[DP]Chewie> es muss nur einmal ausgeführt werden
[21:23] <[DP]Chewie> also, diese Funktion braucht zwei Parameter: zunächst die benötigte Version
[21:23] <[DP]Chewie> uns reicht Version 1.1, die ab Win95 dabei ist.
[21:24] <[DP]Chewie> Und als zweiten Parameter übergeben wir ein Record, das wir zwar nicht brauchen, aber die Funktion
[21:24] <[DP]flomei> HowTo?
[21:24] <[DP]Chewie> also das ganze sieht dann so aus:
[21:24] <[DP]Chewie> procedure TForm1.FormCreate(Sender: TObject);
[21:24] <[DP]Chewie> var
[21:24] <[DP]Chewie> WSAData: TWSAData;
[21:24] <[DP]Chewie> begin
[21:24] <[DP]Chewie> WSAStartup($11, WSAData);
[21:24] <[DP]Chewie> end;
[21:25] <[DP]Chewie> $11 bedeutet Version 1.1
[21:25] <[DP]Chewie> Wir könnten auch schreiben:
[21:25] <[DP]Chewie> WSAStartup(MakeWord(1, 1), WSAData);
[21:26] <[DP]Chewie> Und weil wir ordentlich sind, räumen wir am Ende auch wieder auf. Fügt also ins OnDestroy-Ereignis einen Aufruf von WSACleanup hinzu
[21:26] <[DP]Chewie> Ohne Parameter
[21:26] <[DP]Chewie> also WSACleanup;
[21:26] <[DP]Chewie> Soweit klar?
[21:27] <Sanchez0815> klar
[21:27] <Mirilin[dp]> jo
[21:27] <[DP]flomei> ja. hab das mit nem beenden button dann auch noch im OnClose gemacht
[21:27] <[DP]Chewie> OK
[21:27] <[DP]Chewie> nun bearbeiten wir unsere ButtonClick-Prozedur
[21:28] <[DP]flomei> hau rein
[21:28] <[DP]Chewie> zuerst brauchen wir eine Varaible vom Typ TSocket
[21:29] <[DP]Chewie> damit weisen wir unserem Programm einen Socket zu
[21:29] <[DP]Chewie> Folgender Aufruf:
[21:29] <[DP]Chewie> var
[21:29] <[DP]Chewie> s: TSocket;
[21:29] <[DP]Chewie> begin
[21:29] <[DP]Chewie> s := socket(AF_INET, SOCK_STREAM, 0);
[21:29] <[DP]Chewie> AF_INET heißt, dass wir die Adressfamilie Internet wollen
[21:29] <[DP]Chewie> also IP-Protokoll und nicht IPX oder sowas
[21:30] <[DP]flomei> aha
[21:30] <[DP]Chewie> SOCK_STREAM bedeutet TCP. Wollten wir UDP, müssten wir SOCK_DGRAM nehmen
[21:30] <[DP]flomei> kann man das nachlesen?
[21:30] <[DP]flomei> wenn ja, wo?
[21:30] <[DP]Chewie> im PSDK unter Windows Sockets oder im MSDN
[21:31] <Mirilin[dp]> wer häts gedacht :-)
[21:31] <[DP]Chewie> Geh mal auf http://msdn.microsoft.com/library/ und such dort nach socket
[21:31] * [DP]BungeeBug has joined #Delphi-Praxis
[21:32] <[DP]BungeeBug> hi all
[21:32] <Mirilin[dp]> SOCKET socket(
[21:32] <Mirilin[dp]> int af,
[21:32] <Mirilin[dp]> int type,
[21:32] <Mirilin[dp]> int protocol
[21:32] <Mirilin[dp]> );
[21:32] <Mirilin[dp]> hi bungeebug
[21:32] <[DP]Chewie> OK
[21:32] <Sanchez0815> hi
[21:32] <[DP]Chewie> nun können wir unseren Socket mit einem anderen verbinden
[21:32] <[DP]Chewie> doch wir müssen erst noch den Port und die Adresse des Zielrechners angeben
[21:32] <[DP]flomei> aha
[21:33] <[DP]Chewie> der Einfachkeit halber checken wir jetzt nur unseren lokalen Rechner ab
[21:33] <[DP]flomei> ja. kann man dann ja erweitern
[21:33] <[DP]Chewie> wir brauchen eine Variable vom Typ SockAddrIn: SockAddr_In;
[21:34] <[DP]Chewie> Also SockAddrIn nenn ich die Variable, SockAddr_In ist der Typ
[21:34] <[DP]Chewie> der sieht so aus:
[21:34] <[DP]Chewie> sockaddr_in = record
[21:34] <[DP]Chewie> case Integer of
[21:34] <[DP]Chewie> 0: (sin_family: u_short;
[21:34] <[DP]Chewie> sin_port: u_short;
[21:34] <[DP]Chewie> sin_addr: TInAddr;
[21:34] <[DP]Chewie> sin_zero: array[0..7] of Char);
[21:34] <[DP]Chewie> 1: (sa_family: u_short;
[21:34] <[DP]Chewie> sa_data: array[0..13] of Char)
[21:34] <[DP]Chewie> end;
[21:35] <[DP]Chewie> wer noch nicht mit varianten Records gearbeitet hatm,
[21:35] <[DP]Chewie> der möge sich den Record so vorstellen:
[21:35] <[DP]flomei> kommt das alles in die ButtonClick Prozedur?
[21:36] <[DP]Chewie> sockaddr_in = record
[21:36] <[DP]Chewie> sin_family: u_short;
[21:36] <[DP]Chewie> sin_port: u_short;
[21:36] <[DP]Chewie> sin_addr: TInAddr;
[21:36] <[DP]Chewie> sin_zero: array[0..7] of Char);
[21:36] <[DP]Chewie> end;
[21:36] <[DP]Chewie> so sieht der Record aus
[21:36] <[DP]Chewie> die Buttonclick-Prozedur sieht bisher nur so aus:
[21:36] <[DP]Chewie> procedure TForm1.Button1Click(Sender: TObject);
[21:36] <[DP]Chewie> var
[21:36] <[DP]Chewie> s: TSocket;
[21:36] <[DP]Chewie> SockAddr: SockAddr_In;
[21:36] <[DP]Chewie> begin
[21:36] <[DP]Chewie> s := socket(AF_INET, SOCK_STREAM, 0);
[21:37] <[DP]flomei> ja
[21:37] <[DP]Chewie> jetzt weißen wir SockAddr die Adresse und den Port zu
[21:38] <[DP]Chewie> d.h. den Port erst in der Schleife
[21:38] <[DP]Chewie> SockAddr.sin_family := AF_INET;
[21:38] <[DP]Chewie> SockAddr.sin_addr.S_addr := inet_addr('127.0.0.1');
[21:38] <[DP]Chewie> erste Zeile sagt nochmal, dass wir die Internet-Adressfamilie benutzen
[21:39] <[DP]Chewie> zwiete Zeile setzt die Internet-Adresse auf 127.0.0.1
[21:39] <[DP]Chewie> Die Funktion inet_addr erzeugt aus dem String '127.0.0.1' eine 32Bit-Zahl
[21:39] <[DP]Chewie> soweit klar?
[21:40] <Mirilin[dp]> jo
[21:40] <[DP]flomei> SockAddrIn muss man schreiben oder?
[21:40] <[DP]Chewie> ??
[21:40] <[DP]Chewie> du brauchst eine Variable vom Typ SockAddr_In
[21:40] <[DP]flomei> ja
[21:41] <[DP]Chewie> wie du sie nennst, iss wurscht
[21:41] <[DP]flomei> die hab ich
[21:41] <Sanchez0815> ja
[21:41] <[DP]flomei> mom
[21:41] <[DP]flomei> var
[21:41] <[DP]flomei> s: TSocket;
[21:41] <[DP]Chewie> wichtig: der Member sin_addr des Records ist vom Typ TInAddr
[21:41] <[DP]flomei> SockAddrIn: SockAddr_In;
[21:41] <[DP]flomei> begin
[21:41] <[DP]flomei> s := socket(AF_INET, SOCK_STREAM, 0);
[21:41] <[DP]Chewie> und das ist wiederum ein Record
[21:41] * MHa has joined #Delphi-Praxis
[21:41] <[DP]flomei> SockAddrIn.sin_family := AF_INET;
[21:41] <[DP]flomei> SockAddrIn.sin_addr.S_addr := inet_addr('127.0.0.1')
[21:42] <Mirilin[dp]> hi mha
[21:42] <[DP]Chewie> bingo
[21:42] <[DP]flomei> ja. das geht auch
[21:42] <[DP]Chewie> so stimmt es. Haben das die andern auch etwa so?
[21:42] <[DP]flomei> so eine Win32 Zahl sieht übrigens so aus: 2130706433
[21:42] <[DP]flomei> was erwartet inet_addr() für einen typ?
[21:42] <Mirilin[dp]> jo
[21:42] <[DP]flomei> integer???
[21:42] <[DP]flomei> oder was?
[21:42] <[DP]Chewie> einen PChar
[21:43] <[DP]flomei> hm.
[21:43] <[DP]Chewie> den wandelt er in einen Integer um
[21:43] <[DP]flomei> ich hab nämlich das IPAdressEdit von den Jedis hier
[21:43] <[DP]flomei> damit könnte man das doch schön machen
[21:43] <Mirilin[dp]> @flomei, maus über funktion halten, und tooltip lesen
[21:43] <[DP]Chewie> wenn du damit schon die Adresse als Integer hast, kannst du dir den Aufruf von inet_addr sparen
[21:44] <[DP]flomei> naja. ich werd mal gucken
[21:45] <[DP]Chewie> verstanden? 127.0.0.1 entspricht der Zahl $7F000001
[21:45] <[DP]flomei> machen wir weiter
[21:45] <[DP]Chewie> OK, nun bleibt eigentlich nix weiteres zu tun, als in einer Schleife zu allen Ports eine Verbindung aufzubauen
[21:46] <[DP]flomei> dann sagst du uns jetzt wie wir das an einen Port adressieren?
[21:47] <[DP]Chewie> ja
[21:47] <[DP]flomei> alles klar
[21:47] <[DP]Chewie> wir brauchen dazu nochmal den Record SockAddr bzw. SockAddrIn
[21:48] <[DP]Chewie> da gibts noch den Member sin_port das ist unser Port
[21:48] <[DP]Chewie> dem Member weisen wir unsere Schleifenvariable zu
[21:48] <[DP]flomei> wir haben noch gar keine schleife oder?
[21:49] <[DP]Chewie> die Schleife geht z.B. von 1 bis 65535. Das ist der Bereich der gültigenn Ports
[21:49] <[DP]Chewie> nein, noch nicht
[21:49] <[DP]Chewie> bevor wir die machen, setzen wir erst noch eine Listbox auf die Form, in der wir die offenen Ports anzeigen
[21:50] * MHa has quit IRC (Quit: Leaving)
[21:51] <[DP]Chewie> unsere Schleife sieht dann z.B. so aus:
[21:51] <[DP]Chewie> for i := 1 to 65535 do
[21:51] <[DP]Chewie> begin
[21:51] <[DP]Chewie> SockAddr.sin_port := htons(i);
[21:51] <[DP]Chewie> if connect(s, SockAddr, Sizeof(SockAddr)) <> SOCKET_ERROR then ListBox1.Items.Add('Port ' + InttoStr(i) + ' offen')
[21:51] <[DP]Chewie> else ListBox1.Items.Add('Port ' + InttoStr(i) + ' geschlossen');
[21:51] <[DP]Chewie> Application.ProcessMessages;
[21:51] <[DP]Chewie> end;
[21:52] <[DP]Chewie> in die Listbox wird dann eingetragen, ob der Port offen ist oder nicht
[21:52] <[DP]Chewie> mit connect() stellen wir eine Verbindung her
[21:53] <[DP]Chewie> Parameter: s für den Socket
[21:53] <[DP]Chewie> SockAddr für Adresse und Port und als dritter die Größe des SockAddr-Records
[21:53] <[DP]Chewie> soweit klar?
[21:54] <[DP]flomei> moment noch
[21:55] <Mirilin[dp]> jo
[21:56] <[DP]Chewie> Jetzt fehlt noch ein Aufruf von CloseSocket(s); nach der Schleife
[21:56] <[DP]Chewie> um dem System zu sagen, dass wir den Socket nicht mehr brauchen
[21:57] <[DP]Chewie> jetzt haben wir nen einfachen, langsamen, aber (hoffentlich) funktionierenden Portscanner
[21:57] <[DP]flomei> es geht.
[21:57] <Mirilin[dp]> jo
[21:57] <Mirilin[dp]> ist noch schnell
[21:57] <[DP]flomei> Port 1 geschlossen.
[21:58] <[DP]flomei> Port 2 geschlossen
[21:58] <[DP]flomei> usw...
[21:58] <[DP]Chewie> normalerweise geht das mit vielen Threads gleichzeitig, aber so funktinierts auch
[21:59] <[DP]Chewie> noch eine Sache: ist euch aufgea+
[21:59] <[DP]Chewie> aufgefallen, dass ich htons(i) geschrieben hab und nicht einfach nur i?
[21:59] <Mirilin[dp]> ja
[21:59] <Sanchez0815> ja, warum?
[21:59] * Garner has joined #Delphi-Praxis
[21:59] <[DP]flomei> ja
[21:59] <Garner> Huhu...
[21:59] <Mirilin[dp]> hi garner
[21:59] <Sanchez0815> hi garner
[21:59] <Mirilin[dp]> hast den anfang verpasst
[22:00] <Garner> ^^
[22:00] <Garner> Hallöchen Jungs *winkt hastig*
[22:00] <[DP]Chewie> probiert mal aus, nur i zu schreiben ;-)
[22:00] <Garner> Ich?
[22:00] <Mirilin[dp]> i
[22:00] <Garner> i
[22:00] <[DP]Chewie> dabei passiert folgendes: i ist ein Word-Wert, also zwei Byte groß
[22:00] <Garner> Hmm... Und jetzt?
[22:00] <[DP]Chewie> nicht hier, im Quelltext *g*
[22:01] <Garner> =)
[22:01] <Garner> Welchen Quelltext? *in die runde schaut*
[22:01] <[DP]flomei> es passiert etwas sehr seltsames: Er scannt erst mal ganz langsam und dann wird er ganz schnell. warum?
[22:01] <Mirilin[dp]> @chewie in echt :-)
[22:01] <[DP]Chewie> OK, ich erklär euch den Unterschied:
[22:01] <[DP]flomei> @Garner: Den den wir hier geschrieben haben
[22:02] <Garner> Ich dachte es gibt nur Theorie? Warum auf einmal programmieren? Warum sagt das keiner vorher?
[22:02] <Mirilin[dp]> @garner, ein ganz kleiner portscanner
[22:02] <[DP]flomei> kommst du aus der DP?
[22:02] <[DP]Chewie> was ich hier mache, ist die ByteOrder von der Port-Variablen umzukehren
[22:02] <Garner> @Mirilin Was heisst den ein kleiner?
[22:02] <Mirilin[dp]> 20cm
[22:03] <Mirilin[dp]> ca 1 din a4 seite
[22:03] <Garner> ^^
[22:03] <[DP]Chewie> in der HostOrder fängt ein Word-Wert mit dem niederwertigeren Byte an, die Socket-Funktion braucht allerdings das höherwertigere Byte am Anfang
[22:03] <Garner> War Woody letztes mal schon da?
[22:04] <Mirilin[dp]> ka
[22:04] <[DP]Chewie> mit dieser Funktion tu ich das: htons = Host to Network Short
[22:04] <[DP]Chewie> also Host Order wandle ich in Network Order um
[22:04] <[DP]flomei> @Chewie: Warum scannt der denn später ganz schnell?
[22:04] <[DP]Chewie> Keine Ahnung, ich weiß es nicht
[22:04] * [DP]BungeeBug has quit IRC (Read error: EOF from client)
[22:05] <[DP]Chewie> das war bei mir aber auch
[22:05] <[DP]flomei> hm... seltsam
[22:05] <[DP]flomei> ich mach erst mal nen bisschen weiter
[22:05] <[DP]flomei> mit range und so
[22:06] <Garner> <-- fragt sich warum Chewie so streng ist! *unschuldig schaut*
[22:06] <Garner> *und hundeblick aufsetz*
[22:06] <[DP]Chewie> kannst dir ja mal Assarbards oder Hagens Scanner ansehen, die machen das gleiche. Nur mit mehreren Threads
[22:06] <[DP]Chewie> @Garner: Streng? Wieso denn das?
[22:06] <[DP]flomei> aha
[22:06] <[DP]flomei> ich glaub das mach ich.
[22:06] <[DP]flomei> nachher.
[22:06] <[DP]flomei> was machst du denn noch`?
[22:07] <Mirilin[dp]> könnt mich jemand beim namen nennen, damit die musik wieder läuft?
[22:07] <[DP]Chewie> Wenn ihr keine Fragenn mehr habt, dann wars das jetzt
[22:07] <[DP]flomei> Mirilin?
[22:07] <Garner> @Mirilin War das nicht Tobias?
[22:07] <Mirilin[dp]> danke chewie für das tutorial
[22:07] <[DP]flomei> Tausend Dank!
[22:07] <Mirilin[dp]> geht beides, merci
[22:07] <[DP]flomei> An wen geht das Log?
[22:07] <[DP]Chewie> Also, ich hoffe, ich hab euch etwas näherbringen können, wie Datenkommnikation funktioniert
[22:07] <Mirilin[dp]> jo
[22:07] <Mirilin[dp]> war wunderbar
[22:07] <[DP]Chewie> @Flomei: Poste es ins Board
[22:08] <[DP]Chewie> unter Tutorials und Kruse
[22:08] <[DP]flomei> alles klar
[22:08] <[DP]flomei> jo
[22:08] <[DP]flomei> vielleicht mach ich das gleich noch
[22:08] <[DP]Chewie> wie gesagt, wenn ihr noch Fragen habt, dann fragt ruhig

[Guenni]

es wäre nett, wenn jemand mal den kompletten source code posten könnte.
hab mir das chatlog ein paar mal durchgelesen, aber mein scanner klappt immernoch nicht

vielen vielen dank.

Guenni

[flomei]

Herzlich Willkommen in der Delphi-PRAXIS Guenni!

Ich werde bald mal meinen Scanner hochladen. Der ist auf Grundlage des Tutorials entstanden aber ich habe ihn noch ein bisschen umgebaut und so...

MfG Florian

[Guenni]

/ ot
Bin schon einige Zeit Silent Reader, blos jetzt bei dem Thema hab ich meine erste Frage
ot /

ich hoffe dein programm wird nicht so lange auf sich warten lassen

mfg
günni

[flomei]

Na dann will ich dich nicht enttäuschen und lade es mal einfach so hoch. Ist halt nach dem Tutorial programmiert und dann ein bisschen komfortabler gemacht worden (wer will schon IMMER full-range suchen )
Hoffe du kannst was lernen.

MfG Florian

P.S.: Ist ein selbstextrahierendes Verzeichnis...

P.P.S.: Ist noch nicht fertig, kann aber gerne von jedem weiterprogrammiert werden! OS rulez!

[EDIT] Aktualisierte, berichtigte Version hochgeladen! [/EDIT]

[Chewie]

Zwei Fehlerchen:

1. Du rufst WSACleanup() sowohl im Destroy- als auch im Close-Ereignis der Form auf. Ist nicht schlimm, aber unnötig.

2. und ungleich schlimmer. Du schreibst:
SockAddrIn.sin_addr.S_addr := inet_addr(PChar(EditScanPorts)); Das heißt du übergibst einen Pointer auf den Pointer, der auf das Editfeld zeigt. AUTSCH! Du musst einen Zeiger auf EditScanPorts.Text übergeben

[flomei]

Zitat von Chewie:

2. und ungleich schlimmer. Du schreibst:
SockAddrIn.sin_addr.S_addr := inet_addr(PChar(EditScanPorts)); Das heißt du übergibst einen Pointer auf den Pointer, der auf das Editfeld zeigt. AUTSCH! Du musst einen Zeiger auf EditScanPorts.Text übergeben

Weisst du wer mir das gesagt hat??? Du! Und äh... Mit Pointern kenne ich mich überhaupt nich aus... ...Was wolltest du mir jetzt sagen?

MfG Florian

[Chewie]

Ich hab sowieso nen klein bisschen Mist gelabert.
Du übergibst keinen Pointer auf den Pointer, aber trotzdem...
Also:
Du schreibst:
SockAddrIn.sin_addr.S_addr := inet_addr(PChar(EditScanPorts)); Was passiert hier? EditScanPorts ist vom Typ TEdit und somit ein Zeiger auf die Adresse, an der das Objekt im Speicher steht. inet_addr kann damit natürlich nichts anfangen, es braucht die Adresse, an der der String mit der IP-Adresse anfängt. Das wäre EditScanPorts.Text.
Verstanden?

[flomei]

Ja ich glaube... Mal sehen ob es dann endlich richtig läuft...

MfG Florian

[EDIT] Neue Version etwas weiter oben gepostet... [/EDIT]