Ich poste euch am besten den Code, der verrät euch wohl am meisten.

#define _WIN32_WINNT 0x500
#include <string>
#include <iostream>
#include <fstream>
#include "sockets.h"
using namespace std;

int main(void)
{
string get;
startWinsock(); //muss man aufrufen um "Netzwerksupport" zu bekommen
NetSocket sx;   //Objekt erstellen und...
sx.client_open("google.de",80);  

sx.send_message("GET http://www.google.de/intl/de_de/images/logo.gif HTTP/1.1\nHost: google.de\nConnection: close/\n\n");  //Request senden,muss immer mit 2 \n enden 

get = sx.receive_message();  //Serverrückgabe nach "get"

string::size_type loc = get.find( "GIF", 0 ); //Den Http-Header finden...

if( loc != string::npos )
{
    get.erase(0,loc);   //...und abschneiden
}

fstream file("C:\\outlay.gif",fstream::out | fstream::in | fstream::binary | fstream::trunc);
file.write(get.c_str(),strlen(get.c_str())); //
file.close();

cout << "\n\n";
system("PAUSE");
return 0;    
}

Jetzt noch die socket.h :

#ifdef _WIN32_WINNT
 #include <windows.h>
 #include <winsock2.h>
 #define SOCKADDR_IN SOCKADDR_IN
 #define SOCKADDR SOCKADDR
 #define HOSTENT HOSTENT
 #define FD_SET_DATA FD_SET
#else
 #include <sys/select.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>

 #define SOCKADDR_IN sockaddr_in
 #define SOCKADDR sockaddr
 #define HOSTENT hostent
 #define SOCKET_ERROR -1
 #define ADDR_ANY INADDR_ANY
 #define SOCKET int
 #define FD_SET_DATA fd_set
 #define INVALID_SOCKET -1
 #define closesocket close
#endif
#define MAX_SIZE 1024
using namespace std;

#ifdef _WIN32_WINNT

int startWinsock(void);
int startWinsock(void)
{
  WSADATA wsa;
  return WSAStartup(MAKEWORD(2,0),&wsa);
}

#endif

long getAddrFromString(char* ,SOCKADDR_IN* );
long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr)
{
  long rc;
  unsigned long ip;
  HOSTENT* he;

  if(hostnameOrIp==NULL || addr==NULL)
    return SOCKET_ERROR;

  ip=inet_addr(hostnameOrIp);

  if(ip!=INADDR_NONE)
  {
    addr->sin_addr.s_addr=ip;
    return 0;
  }
  else
  {
    he=gethostbyname(hostnameOrIp);
    if(he==NULL)
    {
      return SOCKET_ERROR;
    }
    else
    {
      memcpy(&(addr->sin_addr),he->h_addr_list[0],4);
    }
    return 0;

  }
}

/* Die Klasse NetSocket */

   class NetSocket
   {

      public:
         void NetSocket::client_open(char*,int);
         void NetSocket::send_message(char* );
         string NetSocket::receive_message(int);
         NetSocket::NetSocket(void);
         string error;
         int error_b;
         SOCKET s;
         SOCKET s1;

     private:
         FD_SET_DATA fdSet;
         long rc;
         SOCKADDR_IN addr;
         char buf[256];
  };    

/* ************************************************* */

NetSocket::NetSocket(void)
{

}

/* ************************************************* */

void NetSocket::send_message(char* message)
{
rc = send(s,message,strlen(message),0);
  if(rc==SOCKET_ERROR)
  {
    error_b = 1 ;
    error += "Could not send message!\n";
  }
}

/* ************************************************* */
string NetSocket::receive_message(int lenght = 0)    
{
error_b = 0;
int std =1,rc2;
string received;
timeval t;
t.tv_sec  = 1;
t.tv_usec = 0;

if(lenght == 0)
 lenght = 2000000;
else
  std = 0;

char * buf = new char[lenght];

 do{

  rc = recv(s,buf,sizeof(buf)-1,0);

  if(rc==0)
   {
    error_b = 2;
    break;  
   }

   if(rc==SOCKET_ERROR)
    {
     error_b = 1 ;
     error += "Recv failed!\n";
    }
    buf[rc]='\0';
    received += buf;

    if(std == 0)
     break;

    FD_ZERO(&fdSet); 
    FD_SET(s,&fdSet); 
    rc2=select(s+1,&fdSet,NULL,NULL,&t); 
    cout << "hallo" << endl;

}while(FD_ISSET(s,&fdSet) );    //&& rc != SOCKET_ERROR 

delete buf;
return received;    
}

/* ************************************************* */

void NetSocket::client_open(char* hostnameOrIp,int port)
{
 if(s)
  closesocket(s);
 s=socket(AF_INET,SOCK_STREAM,0);
  if(s==INVALID_SOCKET)
  {
    error_b = 1 ;
    error += "Could not create Socket!\n";
    return ;
  }

  memset(&addr,0,sizeof(SOCKADDR_IN)); 
  addr.sin_family=AF_INET;
  addr.sin_port=htons(port); 
  rc=getAddrFromString(hostnameOrIp,&addr);
  rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR));
  if(rc==SOCKET_ERROR)
  {
    error_b = 1 ;
    error += "Could not connect to server!\n";
  } 
}

/* ************************************************* */

Es kann sein das der Code an Stellen sehr schlecht programmiert/geschrieben ist dafür möchte ich mich entschuldigen bin noch Anfänger.

Ich möchte mich trozdem schonmal für eure Hilfe bedanken.

gruß twitch

class NetSocket
{
public:
    NetSocket() : m_socket(NULL), m_socket2(NULL) {} 

public:
    bool client_open(const std::string&, unsigned short); // Da das fehlschlagen kann ist hier Bool angebracht. nen port wird wohl eher nicht soo ne hohe Zahl sein ... und auch nicht im negativen Bereich ...
    bool send_message(const std::string&);
    std::string receive_message(int);

private:
    SOCKET m_socket;
    SOCKET m_socket2;
    FD_SET_DATA m_fdSet;
    SOCKADDR_IN m_addr;
};

// bsw. send_message
bool NetSocket::send_message(const std::string& message)
{
    return (send(s, message.c_str(), message.length(), 0) != SOCKET_ERROR)
}
// So ist das nen schöner kurzer Code ...

und dann sowas:

long getAddrFromString(char* ,SOCKADDR_IN* );
long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr)
{

das macht keinen Sinn ... das würde man nur machen, wenn da zwischen eine Funktion stehen würde die die Funktion schon kenne muss aber du die definition der Funktion erst an viel späterer stelle schreiben willst/kannst ...

fstream file("C:\\outlay.gif",fstream::out | fstream::in | fstream::binary | fstream::trunc);
file.write(get.c_str(),strlen(get.c_str())); //

nicht wirklich erfolg haben wird, da ein gif-bild nicht nur aus alphanumerischen zeichen besteht (was ich meine, "get" ist ein std::string, das verhalten bei steuerzeichen ist nicht unbedingt vorhersehbar, kann sein das er dafür missbraucht werden kann aber das hab ich noch nicht selber getestet)

ich hab was ähnliches gehabt, ich hab ne portweiterleitung gebaut (simples kopieren von socket a nach b) und dabei auch string verwendet, bei bildern isser immer ausgestiegen

dann hab ich einfach nen unsigned char array genomm und das blockweise umgepumpt.

versuch es doch mit einem memorystream btw. jag es doch dierekt in die datei ... schau dir aber mal spasseshalber an WAS in get landet, vielleicht wirste daraus schlau

und nochwas hinterher

string::size_type loc = get.find( "GIF", 0 ); //Den Http-Header finden...

if( loc != string::npos )
{
    get.erase(0,loc);   //...und abschneiden
}

schlag mich bitte nicht wenn ich jetzt was falsches sage, aber zeigt loc nicht auf den anfang von "GIF" ?? musst du beim schneiden das "GIF" nicht auch noch entfernen .... btw. woher weist du das hinter den erwünschten daten nicht noch irgendwelches zeug übertragen wird (hab den rest nicht ganz vertsanden, kann gut sein das einer der vorhergehenden befehle das eingrenzt)?

mfg

? Ich weiß gerade nicht die GIF Spezifaktion aber normal steht GIF wahrscheinlich am Anfang ... d.h. wäre das so schon ok weil er halt alles was davor steht nicht haben will ... warum auch immer ^^

Weil davor der HTTP-Header steht und der macht die ganze Datei kaputt deswegen muss der vorher weg.

was spricht eigentlich gegen rechtsklick bild speichern unter?

Ich finds immer toll, wenn es Menschen gibt die wissen wollen, wie man's selbst macht.

Greetz, Swordfish

file.write(get.c_str(),strlen(get.c_str())); //

Das funktioniert so nicht. Die Variable get ist ein std::string. Und ein std::string kann (im gegensatz zur Behauptung von Ceos ) sehr wohl mit Steuerzeichen umgehen. strlen allerdings nicht. Ein strlen(get.c_str()) liefert die Anzahl der Bytes bis zum ersten Null-Zeichen, welcher wahrscheinlich in deiner GIF-Datei vorkommt. Um die Länge des Strings zu bekommen, solltest Du get.size() verwenden.

Und noch ein Tip: Die http-Header werden von der Zeichenfolge "\r\n\r\n", also eine Leerzeile vom http-Body getrennt. Statt nach "GIF" zu suchen, solltest Du nach dieser Zeichenfolge suchen. Damit bist Du nicht auf GIF beschränkt.

Tntnet

(im gegensatz zur Behauptung von Ceos )

das nächste mal liesst du dir meinen satz genauer durch
DANKE

das erklärt aber nicht wieso dann bei mir der string nicht funktioniert hat, und ich habe sogar mit dem result von recv(); gearbeitet, mich also garnicht erst mit strlen oder size rumgeschlagen...
dennoch hat mir der string nach ein paar bytes schlicht und einfach die ausgabe verwehrt (und damit mein ich nciht die ausgabe auf dem bildschrim sondern das zeichenweise senden was ich irrtümlicherweise angetrebt hatte, das brach nach knapp 30 zeichen einfach mit zugriffsverletzung ab)
ich habs nicht weiter debuggt sondern einfach n char array angelegt

(was ich meine, "get" ist ein std::string, das verhalten bei steuerzeichen ist nicht unbedingt vorhersehbar, kann sein das er dafür missbraucht werden kann aber das hab ich noch nicht selber getestet)

Ich verstehe diesen Satz so, daß Du uns darüber in Kenntnis setzen willst, daß Du nicht weißt, ob Steuerzeichen im std::string ok sind. Zufällig weiß ich, daß das Verhalten eines std::strings bei Steuerzeichen vorhersebar ist. Nämlich Steuerzeichen inklusive Null-Byte sind im std::string ok. Du kannst beliebige Binärdaten inklusive GIF-Grafiken in einem std::string halten.

Wenn Du Probleme mit Steuerzeichen in einem std::string, dann liegt das nicht am std::string, sondern in der Art und Weise, wie Du damit umgehst. Wäre sicherlich hilfreich, wenn Du die Codesequenz posten könntest, wo Du probleme hattest.

Dennoch entschuldige ich mich, wenn Du Dich angegriffen gefühlt hast. Das war nicht meine Absicht.

Tntnet