Xin hat geschrieben:Kmitska hat geschrieben:EDIT: Wie kann ich "wget" selber schreiben?
Du schreibst doch einen Crawler... Du kannst Websites runterladen? Dann kannst Du auch andere Daten runterladen - das Protokoll ändert sich nicht.
Aber Du musst es halt mal gründlich lesen.
Danke Dir.
Also habe jetzt einiges raus bekommen, doch beim "Abfangen" habe ich Probleme.
In Header wird die Länge mitgeteilt:
Um das Bild abzufangen habe ich dies ausprobiert:
Code: Alles auswählen
int main()
{
Socket sock;
sock.create();
sock.connect("airtrake.square7.ch", 80);
sock.send("GET http://airtrake.square7.ch/webseite/community.PNG HTTP/1.1\r\n");
sock.send("Host: airtrake.square7.ch\r\n");
sock.send("\n");
string recv,img;
sock.recv(recv);
for(int n=0; n<=(30308/1024); n++){
sock.recv(recv);
img += recv;
}
ofstream file("image.png");
file << img;
return 1;
}
Doch beim Abspeichern kommt eine fehlerhafte Datei raus.
Wo mache ich falsch?
Und die Socket Klasse aus "C++ von A bis Z":
Header:
Code: Alles auswählen
#ifndef SOCKET_H_
#define SOCKET_H_
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <unistd.h>
using namespace std;
// Max. Anzahl Verbindungen
const int MAXCONNECTIONS = 5;
// Max. Anzahl an Daten die aufeinmal empfangen werden
const int MAXRECV = 1024;
// Die Klasse Socket
class Socket {
private:
// Socketnummer (Socket-Deskriptor)
int m_sock;
// Struktur sockaddr_in
sockaddr_in m_addr;
public:
// Konstruktor
Socket();
// virtueller Destruktor
virtual ~Socket();
// Socket erstellen - TCP
bool create();
// Socket erstellen - UDP
bool UDP_create();
bool bind( const int port );
bool listen() const;
bool accept( Socket& ) const;
bool connect ( const string host, const int port );
// Datenübertragung - TCP
bool send ( const string ) const;
int recv ( string& ) const;
// Datenübertragung - UDP
bool UDP_send( const string, const string,
const int port ) const;
int UDP_recv( string& ) const;
// Socket schließen
bool close() const;
// WSAcleanup()
void cleanup() const;
bool is_valid() const { return m_sock != -1; }
// für select()
int get_m_sock() const { return m_sock; }
void set_m_sock( int nr ) { m_sock = nr; }
};
// Exception-Klasse
class SockExcept {
private:
string except;
public:
SockExcept( string s ) : except( s ) {};
~SockExcept() {};
string get_SockExcept() { return except; }
};
#endif
Cpp:
Code: Alles auswählen
// socket.cpp
#include <cstdlib>
#include <iostream>
#include <cstring>
#include "socket.h"
using namespace std;
Socket::Socket() : m_sock(0) { }
Socket::~Socket() {
if ( is_valid() )
::close( m_sock );
}
bool Socket::create() {
m_sock = ::socket(AF_INET,SOCK_STREAM,0);
if (m_sock < 0) {
throw SockExcept("Fehler beim Anlegen eines Socket");
}
int y=1;
setsockopt( m_sock, SOL_SOCKET,
SO_REUSEADDR, &y, sizeof(int));
return true;
}
bool Socket::UDP_create() {
m_sock = ::socket(AF_INET,SOCK_DGRAM,0);
if (m_sock < 0) {
throw SockExcept("Fehler beim Anlegen eines Socket");
}
return true;
}
bool Socket::bind( const int port ) {
if ( ! is_valid() ) {
return false;
}
m_addr.sin_family = AF_INET;
m_addr.sin_addr.s_addr = INADDR_ANY;
m_addr.sin_port = htons ( port );
int bind_return = ::bind ( m_sock,
( struct sockaddr * ) &m_addr, sizeof ( m_addr ) );
if ( bind_return == -1 ) {
return false;
}
return true;
}
bool Socket::listen() const {
if ( ! is_valid() ) {
return false;
}
int listen_return = ::listen ( m_sock, MAXCONNECTIONS );
if ( listen_return == -1 ) {
return false;
}
return true;
}
bool Socket::accept ( Socket& new_socket ) const {
int addr_length = sizeof ( m_addr );
new_socket.m_sock = ::accept( m_sock,
( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );
if ( new_socket.m_sock <= 0 )
return false;
else
return true;
}
bool Socket::connect( const string host, const int port ) {
if ( ! is_valid() )
return false;
struct hostent *host_info;
unsigned long addr;
memset( &m_addr, 0, sizeof (m_addr));
if ((addr = inet_addr( host.c_str() )) != INADDR_NONE) {
memcpy( (char *)&m_addr.sin_addr,
&addr, sizeof(addr));
}
else {
host_info = gethostbyname( host.c_str() );
if (NULL == host_info) {
throw SockExcept("Unbekannter Server");
}
memcpy( (char *)&m_addr.sin_addr, host_info->h_addr,
host_info->h_length);
}
m_addr.sin_family = AF_INET;
m_addr.sin_port = htons( port );
int status = ::connect ( m_sock,
( sockaddr * ) &m_addr, sizeof ( m_addr ) );
if ( status == 0 )
return true;
else
return false;
}
bool Socket::send( const string s ) const {
int status = ::send ( m_sock, s.c_str(), s.size(), 0 );
if ( status == -1 ) {
return false;
}
else {
return true;
}
}
int Socket::recv ( string& s ) const {
char buf [ MAXRECV + 1 ];
s = "";
memset ( buf, 0, MAXRECV + 1 );
int status = ::recv ( m_sock, buf, MAXRECV, 0 );
if ( status > 0 || status != -1 ) {
s = buf;
return status;
}
else {
throw SockExcept("Fehler in Socket::recv");
return 0;
}
}
bool Socket::UDP_send( const string addr, const string s, const int port ) const {
struct sockaddr_in addr_sento;
struct hostent *h;
int rc;
h = gethostbyname(addr.c_str());
if (h == NULL) {
throw SockExcept("Unbekannter Host?");
}
addr_sento.sin_family = h->h_addrtype;
memcpy ( (char *) &addr_sento.sin_addr.s_addr,
h->h_addr_list[0], h->h_length);
addr_sento.sin_port = htons (port);
rc = sendto( m_sock, s.c_str(), s.size(), 0,
(struct sockaddr *) &addr_sento,
sizeof (addr_sento));
if (rc == -1) {
throw SockExcept(
"Konnte Daten nicht senden - sendto()");
}
return true;
}
int Socket::UDP_recv( string& s ) const {
struct sockaddr_in addr_recvfrom;
int len, n;
char buf [ MAXRECV + 1 ];
s = "";
memset ( buf, 0, MAXRECV + 1 );
len = sizeof (addr_recvfrom);
n = recvfrom ( m_sock, buf, MAXRECV, 0,
(struct sockaddr *) &addr_recvfrom,
( socklen_t * )&len );
if (n == -1){
throw SockExcept("Fehler bei recvfrom()");
return 0;
}
else {
s = buf;
return n;
}
}
void Socket::cleanup() const { }
bool Socket::close() const {
::close(m_sock);
cleanup();
return true;
}
Danke im Voraus.
