IP-Adresse

Jeffson

Hi,

Was ist der Unterschied zwischen:

addr.sin_addr=inet_addr("127.0.0.1");

und

struct sockaddr_in server;
unsigned long addr;
...
memset( &server, 0, sizeof (server));

addr = inet_addr("127.0.0.1");
memcpy( (char *)&server.sin_addr, &addr, sizeof(addr));

Kann mir einer bitte erklären, was im zweiten Code vor sich geht?

liebe grüße

Hallo, ich versuchs mal:

struct sockaddr_in server; // Struktur anlegen 
unsigned long addr;  // Deklaration

memset( &server, 0, sizeof (server)); // Alles was in der Struktur ist auf 0 setzen

addr = inet_addr("127.0.0.1");  // Les mal hier: http://msdn.microsoft.com/en-us/library/windows/desktop/ms738563(v=vs.85).aspx

memcpy( (char *)&server.sin_addr, &addr, sizeof(addr));  // Kopiere die Daten aus addr in die Struktur server.sin_addr  bzw. in Variable sin_addr aus der Struktur server

So würde ich es erklären.

Nochmal zu memset: http://www.cplusplus.com/reference/clibrary/cstring/memset/

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
char s[1];

  char str[] = "abc";
  memset (str,0,  sizeof(s) );

  // str = "abc"
  // char s = 1
  // Lösche von Anfang aus dem string alles um sizeof(s) Elemente in diesem Fall wird nur das a
  // gelöscht
  // 012 Elemente                        012 Elemente
  // abc  <-- Lösche a also kommt daraus: bc

   cout<<str[0]; // Gibt nichts aus
   cout<<str[1]; // Gibt b aus
   cout<<str[2]; // Gibt c aus

system("PAUSE");
}

Jeffson

Ich hätt noch ne kleine Frage: Weder bei send() noch bei recv() ist ja garantiert, dass alle Daten beim ersten Aufruf der Funktionen vollständig gesendet bzw. empfangen werden. Deswegen brauch ich für beide doch eine Schleife oder?

vg

ja

Jeffson

Ich hab jetzt einen kleinen HTTP-Client geschrieben. Doch wenn ich z. B. die index.html von google.de anfordere, so kommt die Fehlermeldung 302 (Redirect).Wie kann ich dieses Problem beheben?

lg

SG1

302 ist keine Fehlermeldung, sondern, wie Du schon selber sagst, ein Redirect. Und in diesem Redirect steht auch drin, wohin Du gehen sollst.

Jeffson

Nochmals zu diesem Codeabschnitt:

memcpy( (char *)&server.sin_addr, &addr, sizeof(addr))

Jede Dokuquelle schlägt eine andere Reihenfolge vor. Was ist jetzt nun richtig: Der obere Codeabschnitt oder das hier?:

memcpy( (char *)&server.sin_addr, &addr, sizeof(server.sin_addr))

könnt ihr mir da weiterhelfen?

Wenn du nur wüsstest, was du da tust...

Naja, machs doch einfach so, funktioniert genauso :

addr.sin_addr.s_addr = inet_addr("127.0.0.1");

Jeffson

Ja, aber so kann ich nicht dynamisch mich über den hostnamen zu einem Server verbinden.

Äh, wus?

Belli

Jeffson schrieb:

Ich hätt noch ne kleine Frage: Weder bei send() noch bei recv() ist ja garantiert, dass alle Daten beim ersten Aufruf der Funktionen vollständig gesendet bzw. empfangen werden. Deswegen brauch ich für beide doch eine Schleife oder?

Nein. Wenn Du blockierende Sockets verwendest, sendet send() alles oder nichts. Bei recv() brauchst Du eine Schleife.

Kann man Send auch nehmen um z.b. Dateien zu übertragen?

Funktioniert das wenn man versucht über Send eine 1GB Datei zu versenden?^^

Oder sollte man dann die Datei vielleicht in kleiner Teile aufsplitten und diese dann versenden?

Der aus dem Westen ...

Was sind den Dateien im Grunde? Doch auch nur Daten, die du versenden kannst. Insofern sollte es kein Problem sein, diese Daten wie alle anderen Daten, die du sonst auch sendest, zu senden.

Und wie schon gesagt, bei send wird alles oder nichts übertragen. Das macht es leicht für Programmierer, kleinere Daten zu versenden, aber wenn die Verbindung abbricht (Kabel nicht richtig drin, 'n Arschloch vom Provider oder ein Router gibt gerade auf und verschlingt dabei ein paar Pakete), war's das meines Wissens.

Eine 1 GB-Datei zu versenden ist ... sagen wir mal, wenn du deinen Provider hasst, kannst du so was natürlich machen. Aber zurück zur Frage: bei send versucht die Funktion, alles zu übertragen. Gibt es dabei einen Fehler, war's das.

SG1

Was hat das mit Provider hassen zu tun? Da macht doch jedes Filesharing-Programm mehr Traffic.

Aber was anderes spricht dagegen, eine 1GB-Datei mit einem einzigen Aufruf von send() zu verschicken: Da müsste man sie ja komplett im Arbeitsspeicher haben![1] Warum nicht einfach in 'ner Schleife die Datei lesen und jeweils den gelesenen Teil wieder mit send() verschicken? Da die Gegenseite eh recv() in 'ner Schleife aufrufen muss, ist es auf der Gegenseite exakt der gleiche Code.

[1] Ich wiess, das stimmt so nicht. Aber die Alternativen sind noch komplizierter.

So würde ich es jetzt glaub ich machen, das scheint mir erst mal am leichtesten zu sein. Aber gibt es da nicht auch eine fertige WIN-API Funktion die das erledigt? Ich weiss gerade nicht wie die heisst. -.-

1.Client: Sendet den Text: "FileUpload" an den Server
2.Client: Empfängt: "ok" Client ließt die größe der zu übertragenen Datei aus.
Und sendet die Größer der Datei an den Server.

3.Client: Empfängt: "ok" und ließt die Datei Byte für Byte aus jedes Byte wird einzelt übertragen.

1.Server: Empfängt den Text: "FileUpload" (Der Server weiss das der Client eine Datei übertragen möchte.)
2.Server: Ruft "ReceiveFile" Funktion auf.
3.Server: Sendet: "ok" und empfängt die Größe der Datei speichere die Größe der Datei in einer Variable.
(Die Dateigröße wird ja als string versendet, also string mit stringstream nochmal nach long umkonvertieren.)
Die WIN-API recv Funktion empfängt alle Bytes einzelt und schreibt diese in eine Datei (wobei dann kann ich es mir auch sparen einen Vector mit einer Größe von X anzulegen das spart doch resourcen).
Wenn die Datei so groß ist wie der Wert in der Variable(Variable welche die Dateigröße enthält)dann höre auf recv auszuführen.