Sockets und das http Protokoll Verbindung fehlgeschlagen



  • Hi ich habe mir in den Artikeln aus dem Forum mal den Artikel Sockets und das http Protokoll reingetan. Mein Problem mit dem Programm was dadrin erklärt wird ist, dass es bei mir immer mit "Verbindung Fehlgeschlagen!" beendet. Ich vermute das es dadran liegt, dass in dem Netzwerk wo ich bin Browser nur über einen Proxy auf I-Net seiten kommen. Kann mir jemand erklären wie ich dieses Programm zum laufen bringe bzw wie ich es umschreibe das es ne Verbindung aufbaut.
    Vielen Dank
    Hier nochmal der Code:

    // Client.cpp : Defines the entry point for the console application.
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include<String>
    #include <time.h>
    #include <fstream>
    #include <stdexcept> // runtime_error
    #include <sstream>
    #ifdef linux
    #include <sys/socket.h> // socket(), connect()
    #include <arpa/inet.h> // sockaddr_in
    #include <netdb.h> // gethostbyname(), hostent
    #include <errno.h> // errno
    #else
    #include <winsock2.h>
    #endif
    
    std::runtime_error CreateSocketError()
    {
        std::ostringstream temp;
    #ifdef linux
        temp << "Socket-Fehler #" << errno << ": " << strerror(errno);
    #else
        int error = WSAGetLastError();
        temp << "Socket-Fehler #" << error;
        char* msg;
        if(FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                         NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                         reinterpret_cast<char*>(&msg), 0, NULL))
        {
            try
            {
                temp << ": " << msg;
                LocalFree(msg);
            }
            catch(...)
            {
                LocalFree(msg);
                throw;
            }
        }
    #endif
        return std::runtime_error(temp.str());
    }
    
    void SendAll(int socket, const char* const buf, const int size)
    {
        int bytesSent = 0; // Anzahl Bytes die wir bereits vom Buffer gesendet haben
        do
        {
            int result = send(socket, buf + bytesSent, size - bytesSent, 0);
            if(result < 0) // Wenn send einen Wert < 0 zurück gibt deutet dies auf einen Fehler hin.
            {
                throw CreateSocketError();
            }
            bytesSent += result;
        } while(bytesSent < size);
    }
    
    // Liest eine Zeile des Sockets in einen stringstream
    void GetLine(int socket, std::stringstream& line)
    {
        for(char c; recv(socket, &c, 1, 0) > 0; line << c)
        {
            if(c == '\n')
            {
                return;
            }
        }
        throw CreateSocketError();
    }
    
    // Entfernt das http:// vor dem URL
    void RemoveHttp(std::string& URL)
    {
        size_t pos = URL.find("http://");
        if(pos != std::string::npos)
        {
            URL.erase(0, 7);
        }
    }
    
    // Gibt die Dateiendung im URL zurück
    std::string GetFileEnding(std::string& URL)
    {
        using namespace std;
        size_t pos = URL.rfind(".");
        if(pos == string::npos)
        {
            return "";
        }
        URL.erase(0, pos);
        string ending = ".";
        // Algorithmus um Sachen wie ?index=home nicht zuzulassen
        for(string::iterator it = URL.begin() + 1; it != URL.end(); ++it)
        {
            if(isalpha(*it))
            {
                ending += *it;
            }
            else
            {
                break;
            }
        }
        return ending;
    }
    
    // Gibt den Hostnamen zurück und entfernt ihn aus der URL, sodass nur noch der Pfad übrigbleibt
    std::string RemoveHostname(std::string& URL)
    {
        size_t pos = URL.find("/");
        if(pos == std::string::npos)
        {
            std::string temp = URL;
            URL = "/";
            return temp;
        }
        std::string temp = URL.substr(0, pos);
        URL.erase(0, pos);
        return temp;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        using namespace std;
    
        cout << "URL: ";
        string URL;
        cin >> URL; // User gibt URL der Datei ein, die herruntergeladen werden soll
    
    #ifndef linux
        WSADATA w;
        if(int result = WSAStartup(MAKEWORD(2,2), &w) != 0)
        {
            cout << "Winsock 2 konnte nicht gestartet werden! Error #" << result << endl;
    		Sleep(3000);
            return 1;
        }
    #endif
    
        RemoveHttp(URL);
    
        string hostname = RemoveHostname(URL);
    
        hostent* phe = gethostbyname(hostname.c_str());
    
        if(phe == NULL)
        {
            cout << "Host konnte nicht aufgeloest werden!" << endl;
    		Sleep(3000);
            return 1;
        }
    
        if(phe->h_addrtype != AF_INET)
        {
            cout << "Ungueltiger Adresstyp!" << endl;
    		Sleep(3000);
            return 1;
        }
    
        if(phe->h_length != 4)
        {
            cout << "Ungueltiger IP-Typ!" << endl;
    		Sleep(3000);
            return 1;
        }
    
        int Socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if(Socket == -1)
        {
            cout << "Socket konnte nicht erstellt werden!" << endl;
    		Sleep(3000);
            return 1;
        }
    
        sockaddr_in service;
        service.sin_family = AF_INET;
        service.sin_port = htons(80); // Das HTTP-Protokoll benutzt Port 80
    
        char** p = phe->h_addr_list; // p mit erstem Listenelement initialisieren
        int result; // Ergebnis von connect
        do
        {
            if(*p == NULL) // Ende der Liste
            {
                cout << "Verbindung fehlgschlagen!" << endl;
    			Sleep(4000);
                return 1;
            }
    
            service.sin_addr.s_addr = *reinterpret_cast<unsigned long*>(*p);
            ++p;
            result = connect(Socket, reinterpret_cast<sockaddr*>(&service), sizeof(service));
        }
        while(result == -1);
    
        cout << "Verbindung erfolgreich!" << endl;
    
        string request = "GET ";
        request += URL;    // z.B. /faq/index.html
        request += " HTTP/1.1\n";
        request += "Host: " + hostname + "\nConnection: close\n\n";
    
        try
        {
            SendAll(Socket, request.c_str(), request.size());
    
            int code = 100; // 100 = Continue
            string Protokoll;
            stringstream firstLine; // Die erste Linie ist anders aufgebaut als der Rest
            while(code == 100)
            {
                GetLine(Socket, firstLine);
                firstLine >> Protokoll;
                firstLine >> code;
                if(code == 100)
                {
                    GetLine(Socket, firstLine); // Leere Zeile nach Continue ignorieren
                }
            }
            cout << "Protokoll: " << Protokoll << endl;
    
            if(code != 200)
            {
                firstLine.ignore(); // Leerzeichen nach dem Statuscode ignorieren
                string msg;
                getline(firstLine, msg);
                cout << "Error #" << code << " - " << msg << endl;
    			Sleep(3000);
                return 1;
            }
    
            bool chunked = false;
            const int noSizeGiven = -1;
            int size = noSizeGiven;
    
            while(true)
            {
                stringstream sstream;
                GetLine(Socket, sstream);
                if(sstream.str() == "\r") // Header zu Ende?
                {
                    break;
                }
                string left; // Das was links steht
                sstream >> left;
                sstream.ignore(); // ignoriert Leerzeichen
                if(left == "Content-Length:")
                {
                    sstream >> size;
                }
                if(left == "Transfer-Encoding:")
                {
                    string transferEncoding;
                    sstream >> transferEncoding;
                    if(transferEncoding == "chunked")
                    {
                        chunked = true;
                    }
                }
            }
    
            string filename = "download" + GetFileEnding(URL);
            cout << "Filename: " << filename << endl;
            fstream fout(filename.c_str(), ios::binary | ios::out);
            if(!fout)
            {
                cout << "Could Not Create File!" << endl;
    			Sleep(3000);
                return 1;
            }
            int recvSize = 0; // Empfangene Bytes insgesamt
            char buf[1024];
            int bytesRecv = -1; // Empfangene Bytes des letzten recv
    
            if(size != noSizeGiven) // Wenn die Größe über Content-length gegeben wurde
            {
                cout << "0%";
                while(recvSize < size)
                {
                    if((bytesRecv = recv(Socket, buf, sizeof(buf), 0)) <= 0)
                    {
                        throw CreateSocketError();
                    }
                    recvSize += bytesRecv;
                    fout.write(buf, bytesRecv);
                    cout << "\r" << recvSize * 100 / size << "%" << flush; // Mit \r springen wir an den Anfang der Zeile
                }
            }
            else
            {
                if(!chunked)
                {
                    cout << "Downloading... (Unknown Filesize)" << endl;
                    while(bytesRecv != 0) // Wenn recv 0 zurück gibt, wurde die Verbindung beendet
                    {
                        if((bytesRecv = recv(Socket, buf, sizeof(buf), 0)) < 0)
                        {
                            throw CreateSocketError();
                        }
                        fout.write(buf, bytesRecv);
                    }
                }
                else
                {
                    cout << "Downloading... (Chunked)" << endl;
                    while(true)
                    {
                        stringstream sstream;
                        GetLine(Socket, sstream);
                        int chunkSize = -1;
                        sstream >> hex >> chunkSize; // Größe des nächsten Parts einlesen
                        if(chunkSize <= 0)
                        {
                            break;
                        }
                        cout << "Downloading Part (" << chunkSize << " Bytes)... " << endl;
                        recvSize = 0; // Vor jeder Schleife wieder auf 0 setzen
                        while(recvSize < chunkSize)
                        {
                            int bytesToRecv = chunkSize - recvSize;
                            if((bytesRecv = recv(Socket, buf, bytesToRecv > sizeof(buf) ? sizeof(buf) : bytesToRecv, 0)) <= 0)
                            {
                                throw CreateSocketError();
                            }
                            recvSize += bytesRecv;
                            fout.write(buf, bytesRecv);
                            cout << "\r" << recvSize * 100 / chunkSize << "%" << flush;
                        }
                        cout << endl;
                        for(int i = 0; i < 2; ++i)
                        {
                            char temp;
                            recv(Socket, &temp, 1, 0);
                        }
                    }
                }
            }
            cout << endl << "Finished!" << endl;
        }
        catch(exception& e)
        {
            cout << endl;
            cerr << e.what() << endl;
        }
    #ifdef linux
        close(Socket); // Verbindung beenden
    #else
        closesocket(Socket); // Windows-Variante
    #endif
    	cout<<"Success\n";
    	Sleep(3000);
    	return 0;
    }
    

    Sleep commandos habe ich zu testzwecken eingbaut.


Anmelden zum Antworten