add *

main.cpp

@@ -2,12 +2,9 @@
 #include "programManager.h"
 
 
-#include "pageManager.h"
-
 int main(int argc, char *argv[])
 {
     ProgramManager mainProgram;
-
     Settings settings = manageParameter(argc, argv);
     return mainProgram.start(settings);
 }

pageManager.cpp

@@ -11,6 +11,11 @@ PageManager::~PageManager()
     ///remove(cookieFilePath.c_str());
 }
 
+void PageManager::setProxy(std::string ip, std::string port)
+{
+    this->sock5Proxy = "socks5://" + ip + ":" + port;
+}
+
 size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
 {
     //Function für CURL
@@ -41,6 +46,7 @@ Reply PageManager::getServerRequest(std::string Url, bool useCookies, std::strin
     curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);     //follows redirection
     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);  // Funktion zum Speichern des outputs in einem string
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);     //Legt die Variable readbuffer fest
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0");
     if(useCookies)
         curl_easy_setopt(curl, CURLOPT_COOKIEFILE, cookieFilePath.c_str());
     if(data != "")
@@ -50,7 +56,9 @@ Reply PageManager::getServerRequest(std::string Url, bool useCookies, std::strin
 
 
     /* Perform the request, res will get the return code */
-    res = curl_easy_perform(curl);     std::cout << "\33[2K\r";
+    res = curl_easy_perform(curl);
+    std::cout << "\33[2K\r";
+    std::cout.flush();
 
     if(res != CURLE_OK) {
         perror((std::string("Error: curl_easy_perform() failed: ") + curl_easy_strerror(res)).c_str());
@@ -86,6 +94,8 @@ int PageManager::login(Account account)
     else if (html.find("Ein Account mit dieser E-Mail Adresse wurde nicht gefunden.") != std::string::npos)
         std::cout << "Error: Login failed: Ein Account mit dieser E-Mail Adresse wurde nicht gefunden." << std::endl
                   << "  Email: '" << account.Email << "' Passwort: '" << account.Password << "'" << std::endl;
+    else if(html == "-1")
+        return -1;
     else
         std::cout << "Error: Login failed: Keine Weiterleitung bei Login." << std::endl
                   << "  Email: '" << account.Email << "' Passwort: '" << account.Password << "'" << std::endl;
@@ -109,7 +119,10 @@ std::string PageManager::checkName(std::string Name)
     } else if (html.find("404 - Seite nicht gefunden") != std::string::npos) {
         std::cout << "Ungültiger Name: " << Name << std::endl;
         return "-1";
-    } else {
+    } else if (html == "-1") {
+        return "-1";
+    }
+    else {
         return name;
     }
 }
@@ -140,6 +153,8 @@ std::string PageManager::getLinks(std::string HTML)
     size_t pos2;
 
     while (getline(iStrStream, line).good()) {
+        if(line == "")
+            break;
         pos=line.find("data-lang-key=");
         if(pos == std::string::npos) {
             std::cout << "Error: Konnte Position von \"data-lang-key=\" nicht finden." << std::endl;
@@ -196,6 +211,8 @@ std::string PageManager::getLinks(std::string HTML)
 
 std::string PageManager::replace(std::string str, std::string substr1, std::string substr2)
 {
+    if(substr1 == "")
+        return str;
     size_t index = 0;
     for (index = str.find(substr1, index); index != std::string::npos; index = str.find(substr1, index + strlen(substr1.c_str())) )
         str.replace(index, strlen(substr1.c_str()), substr2);
@@ -223,6 +240,21 @@ std::string PageManager::grep(std::string text, std::string substring)
 
 }
 
+int PageManager::writeToFile(std::string path, std::string text)
+{
+    if(path == "")
+        return 0;
+    std::ofstream of;
+    of.open(path, std::ios::out | std::ios::app);
+    if(!of.is_open()) {
+        perror("Konnte output Datei nicht öffnen");
+        return -1;
+    }
+    of << text << std::endl;
+    of.close();
+    return 0;
+}
+
 std::string PageManager::chooseHosterLink(std::string HosterList, std::string Hoster_with_Highst_Priority_at_First, std::string languages_with_highst_priority_at_first)
 {
     std::istringstream SListLang  ( replace( languages_with_highst_priority_at_first, ",", "\n") + "\n" );

pageManager.h

@@ -4,6 +4,7 @@
 #include <iostream>
 #include <curl/curl.h>
 #include <string.h>
+//#include <../../../../../home/markus/Downloads/Curl/include/curl/curl.h>
 #include <sstream>
 
 #include "accountManager.h"
@@ -23,6 +24,9 @@ public:
     PageManager(std::string sock5Proxy = "socks5://127.0.0.1:9150", std::string cookieFilePath = "/tmp/S_New4_cookies");
     ~PageManager();
 
+    void setProxy(std::string ip, std::string port);
+
+
     Reply getServerRequest(std::string Url, bool useCookies = false, std::string data = "", bool generateCookieFile = false);
     int login(Account account);
     std::string getUrlAfterRedirect(std::string Url);
@@ -33,6 +37,7 @@ public:
     std::string replace(std::string str, std::string substr1, std::string substr2);
     int counterContains(std::string text, std::string substring_with_prozent_i_for_number, int starte_mit_dieser_Zahl = 1);
     std::string grep(std::string text, std::string substring);
+    int writeToFile(std::string path, std::string text);
 
     const std::string UrlPraefix = "https://s.to/serie/stream/";
 private:

parameterManager.cpp

@@ -3,13 +3,681 @@
 Settings manageParameter(int argc, char **argv)
 {
     Settings settings;
+
+    if(argc < 2) {
+        std::cout << "Keine Optionen angegeben." << std::endl;
+        std::cout << "Aufruf: " << getProgramName(argv[0]) << " [Unteroption] [PARAMETER]" << std::endl;
+        std::cout << "„" << getProgramName(argv[0]) << " (Unteroption) --help“ liefert weitere Informationen." << std::endl;
+        settings.modus = Modus::EXIT;
+        return settings;
+    }
+
+    if(strcmp(argv[1], "--help") == 0) {
+        argv[1][0] = '\0';
+        unterOption_help(&settings, argv[0]);
+        return settings;
+
+    } else if (strcmp(argv[1], "default") == 0) {
+        argv[1][0] = '\0';
+        unterOption_default(&settings, argc, argv);
+        return settings;
+
+    } else if (strcmp(argv[1], "url") == 0) {
+        argv[1][0] = '\0';
+        unterOption_url(&settings, argc, argv);
+        return settings;
+
+    } else if (strcmp(argv[1], "--version") == 0) {
+        std::cout << "Version 0.1.0" << std::endl;
+        settings.modus = Modus::EXIT;
+        return settings;
+    } else {
+        std::cout << "Unbekannte Unteroption: '" << argv[1] << "'" << std::endl;
+        std::cout << "Aufruf: " << getProgramName(argv[0]) << " [Unteroption] [PARAMETER]" << std::endl;
+        std::cout << "„" << getProgramName(argv[0]) << " (Unteroption) --help“ liefert weitere Informationen." << std::endl;
+        settings.modus = Modus::EXIT;
+        return settings;
+    }
+
+
+
+
+
     if(argc < 2) {
         std::cout << " => Kein Name angegeben" << std::endl;
         settings.modus = Modus::EXIT;
         return settings;
     }
+
     settings.name = argv[1];
 
+    const option long_opts[] = {
+        {"name", required_argument, nullptr, 'n'},
+        {"output-file", required_argument, nullptr, 'o'},
+        {"genau", required_argument, nullptr, 'g'},
+        {"ip", required_argument, nullptr, 'i'},
+        {"port", required_argument, nullptr, 'p'},
+        {"episode", required_argument, nullptr, 'e'},
+        {"end-episode", required_argument, nullptr, 'E'},
+        {"season", required_argument, nullptr, 's'},
+        {"end-season", required_argument, nullptr, 'S'},
+        {"depth", required_argument, nullptr, 'D'},
+        {"check-path", required_argument, nullptr, 'c'},
+        {"muster", required_argument, nullptr, 'm'},
+        {"infos", required_argument, nullptr, 'y'},
+        {"list", required_argument, nullptr, 'l'},
+        {"file", required_argument, nullptr, 'f'},
+        {"search", required_argument, nullptr, 'b'},
+        {"limit-dir", required_argument, nullptr, 'L'},
+        {"languages", required_argument, nullptr, 't'},
 
-    return settings;
+        {"only-one", no_argument, nullptr, 'd'},
+        {"window", no_argument, nullptr, 'w'},
+        {"hide", no_argument, nullptr, 'h'},
+        {"remove-number", no_argument, nullptr, 'H'},
+        {"no-color", no_argument, nullptr, 'C'},
+        {"version", no_argument, nullptr, 'v'},
+        {"v-check", no_argument, nullptr, 'V'},
+        {"help", no_argument, nullptr, 'M'},
+
+        {nullptr, no_argument, nullptr, 0}
+
+    };
+
+/*
+
+    int c = 0;
+    while( ( c = getopt_long (argc, argv, "n:o:g:i:p:e:E:s:S:D:c:m:y:l:f:b:L:t:dwhHCvVM", long_opts, nullptr) ) != -1 ) {
+        switch(c) {
+            case 'n':
+                //Name der Serie
+                if(optarg) {
+                    settings.name=optarg;
+                    if(settings.name.find("/") != std::string::npos  || settings.name.find("@")  != std::string::npos || settings.name == "" ) {
+                        std::cout << " => Error: -n: Invalid Name: \"" << settings.Name.toStdString() << "\"." << std::endl;
+                        se;
+                    }
+                }
+                break;
+            case 'o':
+                //Path zu Outputfile
+                if(optarg)
+                    settings.OutputFile= optarg;
+                break;
+            case 'g':
+                //Genaue Hoster
+
+                if(optarg) {
+                    if(!hasRevomedDefauldHoster) {
+                        settings.GenaueHoster.clear();
+                        hasRevomedDefauldHoster=true;
+                    }
+                    settings.GenaueHoster+= QString(optarg).replace("\n",",") + QString(",");
+                }
+                break;
+            case 'i':
+                //Ip Addresse for own Proxy settings
+                if(optarg)
+                    settings.Proxy_IP= optarg;
+                settings.Proxy_IP.replace("localhost","127.0.0.1");
+                if(!settings.Proxy_IP.contains(".")) {
+                    std::cout << " => Error: -i: Invalid Ip Addresse: \"" << settings.Proxy_IP.toStdString() << "\"." << std::endl;
+                    return 38;
+                }
+                break;
+            case 'p':
+                //Port for own Proxy settings
+                if(optarg) {
+                    settings.Proxy_Port= QString(optarg);
+                    char* p;
+                    strtol(settings.Proxy_Port.toStdString().c_str(), &p, 10);
+                    if (*p) {
+                        std::cout << "\33[2K\r" << " => Error: -p: Invalid Port: "<< settings.Proxy_Port.toStdString() << " ist keine Zahl." << std::endl;
+                        return 75;
+                    } else if(settings.Proxy_Port.toInt() < 0) {
+                        std::cout << "\33[2K\r" << " => Error: -p: Port ist negativ: \"" << settings.Proxy_Port.toStdString() << "\"." << std::endl;
+                        return 79;
+                    }
+                }
+                break;
+            case 'w':
+                //Shows the MainWindow
+                settings.show=true;
+                break;
+            case 'h':
+                //Verbirgt ein Paar Infos(auch die redirect Links)
+                settings.hide=true;
+                break;
+            case 'e':
+                //Startet mit dieser Episode
+                if(optarg) {
+                    char* p;
+                    long L = strtol(optarg, &p, 10);
+                    settings.StarteMitDieserFolge=static_cast<int>(L);
+
+                    if (*p) {
+                        std::cout << " => Error: -e: Starterfolge ist keine Zahl: \"" << optarg << "\"." << std::endl;
+                        return 56;
+                    } else if(settings.StarteMitDieserFolge==0) {
+                        std::cout << " => Error: -e: Starterfolge ist 0." << std::endl;
+                        return 78;
+                    } else if(settings.StarteMitDieserFolge < 0) {
+                        std::cout << " => Error: -e: Starterfolge ist negativ: \"" << settings.StarteMitDieserFolge << "\"."<< std::endl;
+                        return 91;
+                    }
+
+                }
+                break;
+            case 's':
+                //Startet mit dieser Staffel
+
+                if(optarg) {
+                    char* p;
+                    long L = strtol(optarg, &p, 10);
+                    settings.StarteMitDieserStaffel=static_cast<int>(L);
+
+                    if (*p) {
+                        std::cout << " => Error: -s: Starterstaffel ist keine Zahl: \"" << optarg << "\"." << std::endl;
+                        return 57;
+                    } else if(settings.StarteMitDieserStaffel==0) {
+                        std::cout << " => Error: -s: Starterstaffel ist 0." << std::endl;
+                        return 79;
+                    } else if(settings.StarteMitDieserStaffel < 0) {
+                        std::cout << " => Error: -s: Starterstaffel ist negativ: \"" << settings.StarteMitDieserStaffel << "\"." << std::endl;
+                        return 92;
+                    }
+
+                }
+                break;
+            case 'E':
+                //Stop mit dieser Folge
+
+                if(optarg) {
+                    char* p;
+                    long L = strtol(optarg, &p, 10);
+                    settings.StopNachFolge=static_cast<int>(L);
+
+                    if (*p) {
+                        std::cout << " => Error: -E: Folge zum Stoppen ist keine Zahl: \"" << optarg << "\"." << std::endl;
+                        return 58;
+                    } else if(settings.StopNachFolge <= 0) {
+                        std::cout << " => Warnung: -E: Unmögliche Folge zum Stoppen: \"" << settings.StopNachFolge << "\"." << std::endl;
+                    }
+
+                }
+                break;
+            case 'S':
+                //Stopt mit dieser Staffel
+
+                if(optarg) {
+                    char* p;
+                    long L = strtol(optarg, &p, 10);
+                    settings.StopNachStaffel=static_cast<int>(L);
+
+                    if (*p ) {
+                        std::cout << " => Error: -S: Staffel zum Stoppen ist keine Zahl: \"" << optarg << "\"." << std::endl;
+                        return 59;
+                    } else if(settings.StopNachStaffel <= 0) {
+                        std::cout << " => Warnung: -S: Unmögliche Staffel zum Stoppen: \"" << settings.StopNachStaffel << "\"."<< std::endl;
+                    }
+                }
+                break;
+            case 'd':
+                //Macht nur 1nen genuaen Hoster pro Folge
+                settings.OnlyOneHoster=true;
+                break;
+            case 'f':
+                //Nimmt die Redirect Links von Parameter oder dem Path zu TextFile
+                //UseFile=true;
+                if(optarg)
+                    settings.PathToFile=optarg;
+                break;
+            case 'c':
+                //Überprüft ob die Folge schon in dem Path exestiert
+                if(optarg) {
+                    settings.CheckDir = optarg;
+                }
+                    settings.use_default_with_check=true;
+                break;
+            case 'm':
+                //Muster für das überprüfen ob ide Folge schon exestiert
+                if(optarg) {
+                    if(std::string(optarg) == "all") {
+                        settings.Muster="S#Staffel#E#Folge#";
+                        break;
+                    }
+                    settings.Muster = optarg;
+                }
+                break;
+            case 'l':
+                //Listet alle Fehlenden Folgen in diesem Pfad auf
+                if(optarg) {
+                    settings.CheckDir = optarg;
+                }
+                settings.use_checkmissing=true;
+                break;
+            case 'y':
+                //Listet alle Staffel und deren Folgenanzahl einer Staffel auf
+                settings.ShowSeans=true;
+                if(optarg) {
+                    settings.Name=optarg;
+                    if(settings.Name.contains("/")  || settings.Name.contains("@") || settings.Name.toStdString() == "") {
+                        std::cout << " => Error: -y: Invalid Name: \"" << settings.Name.toStdString() << "\"." << std::endl;
+                        return 2;
+                    }
+                }
+
+                break;
+            case 'b':
+                settings.SearchWindow=true;
+                if(optarg) {
+                    settings.Name=optarg;
+                    if(settings.Name.contains("/")  || settings.Name.contains("@") || settings.Name.toStdString() == "" ) {
+                        std::cout << " => Error: -b: Invalid Name: \"" << settings.Name.toStdString() << "\"." << std::endl;
+                        return 2;
+                    }
+                }
+                break;
+
+            case 'L':
+                if(optarg) {
+                    char* p;
+                    long L = strtol(optarg, &p, 10);
+                    settings.maxdir=static_cast<int>(L);
+
+                    if (*p) {
+                        std::cout << " => Error: -L: Maximale Anzahl zu durchsuchende Ordner ist keine Zahl: \"" << optarg << "\"." << std::endl;
+                        return 56;
+                    } else if(settings.maxdir==0) {
+                        std::cout << " => Error: -L: Maximale Anzahl zu durchsuchende Ordner ist 0." << std::endl;
+                        return 78;
+                    } else if(settings.maxdir < 0) {
+                        std::cout << " => Error: -L: Maximale Anzahl zu durchsuchende Ordner ist negativ: \"" << settings.StarteMitDieserFolge << "\"."<< std::endl;
+                        return 91;
+                    }
+
+                }
+                break;
+
+            case 'v':
+                std::cout << " => Version: " << Version.toStdString() << std::endl;
+                return 0;
+            case 'D':
+
+                if(optarg) {
+                    char* p;
+                    long L = strtol(optarg, &p, 10);
+                    settings.Searchdepth=static_cast<int>(L);
+
+                    if (*p ) {
+                        std::cout << " => Error: Suchtiefe ist keine Zahl: \"" << optarg << "\"." << std::endl;
+                        return 29;
+                    } else if(settings.Searchdepth <= 0) {
+                        std::cout << " => Error: Suchtiefe ist kleiner gleich 0: \"" << settings.Searchdepth << "\"." << std::endl;
+                        return 96;
+                    }
+
+                }
+                break;
+            case 'V':
+                settings.CheckVersion=true;
+                break;
+            case 'C':
+                settings.Color=false;
+                break;
+            case 'H':
+                settings.BigHide=true;
+                break;
+            case 't':
+                if(optarg) {
+                    settings.Languages=QString(optarg);
+                }
+                break;
+            case 'M':
+                listHelpmenue();
+                return 0;
+            default:
+                //Falsche eingabe
+                std::cout << "Aufruf: S_New2 [PARAMETER]" << std::endl;
+                std::cout << "„S_New2 --help“ liefert weitere Informationen." << std::endl;
+            return 0;
+        }
+
+    }
+
+    if(settings.GenaueHoster.lastIndexOf(',') != -1 && hasRevomedDefauldHoster)
+        settings.GenaueHoster.remove(settings.GenaueHoster.lastIndexOf(','),1);
+
+
+    return settings;*/
+}
+
+
+void listHelpmenue() {
+    std::cout << "Aufruf: S_New2 [PARAMETER]" << std::endl
+              << std::endl
+              << "ALGEMEINE PARAMETER:" << std::endl
+              << std::endl
+
+              << "\t-n [Name], --name [Name]  " << std::endl
+              << "\t\tMit diesem Paramter gibt man den Namen einer Serie an." << std::endl
+              << "\t\tBei -c oder -l kann dieser Parameter weggelassen werden," << std::endl
+              << "\t\tfalls der Ordnername gleicher des Seriennamens ist." << std::endl
+              << std::endl
+
+              << "\t-o [Pfad], --output-file [Pfad]" << std::endl
+              << "\t\tMit diesem Parameter gibt man den Pfad zu einem Text File an," << std::endl
+              << "\t\tdas nicht exestieren muss, in das alle genauen Links" << std::endl
+              << "\t\tgeschrieben werden sollen." << std::endl
+              << std::endl
+
+              << "\t-g [Hoster Name], --genau [Hoster Name]" << std::endl
+              << "\t\tMit diesem Paramter gibt man die genauen Hoster, also die" << std::endl
+              << "\t\tRedirect Links, die zu den Links der Hoster umgewandelt" <<std::endl
+              << "\t\twerden sollen. -g mehrmals verwendbar oder mit , angeben." << std::endl
+              << "\t\tDer erste angegebene Hoster hat die größt Priorität." << std::endl
+              << "\t\tDer Zeite die zweitgrößte Priorität... ." << std::endl
+              << std::endl
+
+              << "\t-d, --only-one" << std::endl
+              << "\t\tMit diesem Parameter wird nur 1 genauer Hoster pro Folge" << std::endl
+              << "\t\tgenommen. Der Parameter kann öfters verwendet werden, der" << std::endl
+              << "\t\tVorgang benötigt aber bei jedem Link etwas Zeit." << std::endl
+              << std::endl
+
+              << "\t-i [Ip Addresse], --ip [Ip Addresse]" << std::endl
+              << "\t\tMit diesem Parameter kann man die Ip des Sock-5 Proxys ändern." << std::endl
+              << "\t\tStandert: 127.0.0.1" << std::endl
+              << std::endl
+
+              << "\t-p [Port], --port [Port]" << std::endl
+              << "\t\tMit diesem Parameter kann man den Port des Sock-5 Proxys ändern." << std::endl
+              << "\t\tStandert: 9050" << std::endl
+              << std::endl
+
+              << "\t-w, --window" << std::endl
+              << "\t\tMit diesem Paramter kann man das Window sichtbar machen." << std::endl
+              << "\t\tAber nicht während dem Ablauf darin herumtippen. (:" << std::endl
+              << std::endl
+
+              << "\t-e [Folge], --episode [Folge]" << std::endl
+              << "\t\tMit diesem Parameter kann man festlegen," << std::endl
+              << "\t\tmit welcher Folge das Programm STARTET." << std::endl
+              << std::endl
+
+              << "\t-E [Folge], --end-episode [Folge]" << std::endl
+              << "\t\tMit diesem Parameter kann man festlegen," << std::endl
+              << "\t\tmit welcher Folge das Programm STOPPT." << std::endl
+              << std::endl
+
+              << "\t-s [Staffel], --season [Staffel]" << std::endl
+              << "\t\tMit diesem Parameter kann man festlegen," << std::endl
+              << "\t\tmit welcher Staffel das Programm STARTET." << std::endl
+              << std::endl
+
+              << "\t-S [Staffel], --end-season [Staffel]" << std::endl
+              << "\t\tMit diesem Parameter kann man festlegen," << std::endl
+              << "\t\tmit welcher Staffel das Programm STOPPT." << std::endl
+              << std::endl
+
+              << "\t-h, --hide" << std::endl
+              << "\t\tMit diesem Parameter werden die meisten Infos verborgen, auch" << std::endl
+              << "\t\tdie Redirectlinks.2>/dev/null am Ende verbirgt zusätzlich Infos." << std::endl
+              << std::endl
+
+              << "\t-H, --remove-number" << std::endl
+              << "\t\tMit diesem Parameter werden die Staffel und Folgenangaben" << std::endl
+              << "\t\tbei den genauen Links verborgen. Auch bei: -o" << std::endl
+              << std::endl
+
+              << "\t-D [Tiefe], --depth [Tiefe]" << std::endl
+              << "\t\tMit diesem Parameter kann man die Maximale Suchtiefe" << std::endl
+              << "\t\tvom durchsuchen der Ordner festlgen. Default: 4" << std::endl
+              << std::endl
+
+              << "\t-C, --no-color" << std::endl
+              << "\t\tMit diesem Parameter kann man die Farbe ausschalten." << std::endl
+              << std::endl
+
+              << "\t-m [Muster], --muster [Muster]" << std::endl
+              << "\t\tMit diesem Parameter kann man das Muster verändern, mit dem" << std::endl
+              << "\t\tÜberprüft wird, ob eine Folge exestiert." << std::endl
+              << "\t\t#Staffel# == Variable für die Staffel." << std::endl
+              << "\t\t#Folge# == Variable für die Folge." << std::endl
+              << "\t\tStandert Muster ist: S#Staffel#E#Folge#.mp4" << std::endl
+              << "\t\tonly \"all\" == ignore Format bei Deafault ==> S#Staffel#E#Folge#" << std::endl
+              << std::endl
+
+              << "\t-L [Anzahl], --limit-dir [Anzahl]" << std::endl
+              << "\t\tMit diesem Parameter kann man die maximale Anzahl an" << std::endl
+              << "\t\tOrdnern angeben, die bei -c oder -l durchsucht werden." << std::endl
+              << "\t\tDefault: 100" << std::endl
+              << std::endl
+
+              << "\t-t [Languages], --languages [Languages]" << std::endl
+              << "\t\tMit diesem Parameter kann man die Sprachen festlegen." << std::endl
+              << "\t\tDie Wichtigste zuert. [ GerDub | GerSub | Eng ] möglich." << std::endl
+              << "\t\tKommagetrennt schreiben. Default: GerDub,GerSub,Eng" << std::endl
+              << std::endl
+
+              << "FUNKTIONEN:" << std::endl  << std::endl
+
+
+              << "\t-n [Name], --name [Name]" << std::endl
+              << "\t\tDefault Modus:" << std::endl
+              << "\t\tParams: -n -o -g -d -i -p -w -e -E -s -S -h -H -C -t" << std::endl
+              << std::endl
+
+              << "\t-c [Pfad], --check-path [Pfad]" << std::endl
+              << "\t\tMit diesem Parameter kann man einen Ordner angeben, indem" << std::endl
+              << "\t\tbereits gedownloadetet Folgen sind. Das Programm überprüft dann," << std::endl
+              << "\t\tbevor es einen Redirect Link zu einem Hoster Link macht, ob" << std::endl
+              << "\t\tdiese Folge in dem Ordner ist. Kein -n nötig, falls der" << std::endl
+              << "\t\tOrdnername gleich dem Seriennamen ist. Es verwendet beim" << std::endl
+              << "\t\tüberprüfen, ob eine Folge exestiert, das Muster von -m." << std::endl
+              << "\t\tAuch verwendbar mit *: /hom*/*/Dow*/ für /home/User/Downloads/." << std::endl
+              << "\t\tParams: -n -o -g -d -i -p -w -e -E -s -S -h -H -D -C -m -L -t" << std::endl
+              << std::endl
+
+              << "\t-y [Name], --infos [Name]" << std::endl
+              << "\t\tMit diesem Parameter werden alle Staffeln einer Serie und deren" << std::endl
+              << "\t\tFolgen aufgelistet. Zusätzlich werden alle Namen der Folgen" << std::endl
+              << "\t\taufgelistet.Namen werden verborgen mit -h." << std::endl
+              << "\t\tParams: -n -o -i -p -w -h" << std::endl
+              << std::endl
+
+              << "\t-l [Pfad], --list [Pfad]" << std::endl
+              << "\t\tMit diesem Parameter werden alle fehlenden Folgen in einem" << std::endl
+              << "\t\tOrdner aufgelistet. Kein -n nötig, falls der Ordnername gleich" << std::endl
+              << "\t\tdem Seriennamen ist." << std::endl
+              << "\t\tAuch verwendbar mit *: /hom*/*/Dow*/ für /home/User/Downloads/." << std::endl
+              << "\t\tParams: -n -o -i -p -w -e -E -s -S -h -D -C -m -L" << std::endl
+              << std::endl
+
+              << "\t-f [Pfad/Url], --file [Pfad/Url]  " << std::endl
+              << "\t\tMit diesem Parameter werden entweder alle Redirect-Links aus dem" << std::endl
+              << "\t\tim Parameter angegedenen Text File umgewandelt, oder direkt der" << std::endl
+              << "\t\tim Parameter angegebene Redirect-Link. Mehrere mit Komma" << std::endl
+              << "\t\tgetrennt schreiben." << std::endl
+              << "\t\tParams: -o -i -p -w -h" << std::endl
+              << std::endl
+
+              << "\t-b [Name], --search [Name]" << std::endl
+              << "\t\tSucht Serien mit diesem Namen." << std::endl
+              << "\t\tParams: -n -i -p -w -C" << std::endl
+              << std::endl
+
+              << "\t-v, --version" << std::endl
+              << "\t\tGibt die Verison des Programmes aus." << std::endl
+              << std::endl
+
+              << "\t-V, --v-check" << std::endl
+              << "\t\tGibt die Version des Programmes & die neuste Version" << std::endl
+              <<"\t\tdes Programmes aus." << std::endl
+              << std::endl
+
+              << "\t-M, --help" << std::endl
+              << "\t\tGibt diese Helpmenü aus." << std::endl
+              << std::endl
+
+              << std::endl << std::endl
+
+              << "EINSTELLUNGEN/ACCOUNTS:" << std::endl << std::endl
+
+              << "In dem Pfad " << getenv("HOME") << "/.config/S_New2/ sind Folgene Dateien:" << std::endl
+              << " => */Accounts:" << std::endl
+              << "      In diesem File werden die s.to Accounts gespeichert." << std::endl
+              << "      Eigene Accounts können hinzugefügt werden." << std::endl
+              << " => */Account_Number:" << std::endl
+              << "      In diesem File wird die Nummer des zuletzt verwendeten" << std::endl
+              << "      Accounts gespeichert, um zu verhindern, dass 1 Account" << std::endl
+              << "      die ganze Zeit verwendet wird und dann Captchas kommen." << std::endl
+              << " => */Defaults:" << std::endl
+              << "      In diesem File kann man standert einstellungen festlegen." << std::endl
+              << "      Zeilen ohne = werden ignoriert. Wenn nach dem = nichts ist," << std::endl
+              << "      Wird die Einstellung auch ignoriert." << std::endl
+              << "      Mit noD als erstem Parameter kann man das Default File ignorieren." << std::endl
+
+              << std::endl;
+}
+
+
+void unterOption_help(Settings *settings, char * argv0)
+{
+    std::cout << "Aufruf: " << getProgramName(argv0) << " [Unteroption] [PARAMETER]" << std::endl << std::endl;
+    std::cout << "Unteroptionen:" << std::endl
+              << "\t„--help“" << std::endl
+              << "\t„default“" << std::endl
+              << "\t„url“" << std::endl
+              << "\t„--version“" << std::endl;
+    settings->modus = Modus::EXIT;
+}
+
+void unterOption_default(Settings *settings, int argc, char ** argv)
+{
+    settings->modus = Modus::DEFAULT_MODUS;
+
+    int c = 0;
+    const option long_opts[] = {
+        {"name", required_argument, nullptr, 'n'},
+        {"ip-addresse", required_argument, nullptr, 'i'},
+        {"port", required_argument, nullptr, 'p'},
+        {"genauer-hoster", required_argument, nullptr, 'g'},
+        {"languages", required_argument, nullptr, 'l'},
+        {"output-file", required_argument, nullptr, 'o'},
+
+        {"help", no_argument, nullptr, 'h'},
+        {"colorless", no_argument, nullptr, 'c'},
+
+        {nullptr, no_argument, nullptr, 0}
+
+    };
+
+    while( ( c = getopt_long (argc, argv, "n:i:p:g:l:o:hc", long_opts, nullptr) ) != -1 ) {
+        switch(c) {
+            case 'n':
+                if(optarg)
+                    settings->name = optarg;
+                break;
+            case 'i':
+                if(optarg)
+                    settings->proxy_ip = optarg;
+                break;
+            case 'p':
+                if(optarg)
+                    settings->proxy_port = std::to_string( atoi( optarg ) );
+                if(settings->proxy_port != optarg) {
+                    std::cout << "Invalid Port: " << optarg << std::endl;
+                    settings->modus = Modus::EXIT;
+                    return;
+                }
+                break;
+            case 'g':
+                if(optarg)
+                    settings->genaueHoster =+ optarg + std::string(",");
+                break;
+            case 'l':
+                if(optarg)
+                settings->languages =+ optarg + std::string(",");
+                break;
+            case 'o':
+                if(optarg)
+                    settings->outputFilePath = optarg;
+                break;
+            case 'c':
+                settings->colorless = true;
+                break;
+
+            case 'h':
+                unterOption_default_help(settings, argv[0]);
+                return;
+            default:
+                std::cout << "Aufruf: " << getProgramName(argv[0]) << " default [PARAMETER]" << std::endl;
+                std::cout << "„" << getProgramName(argv[0]) << " default --help“ liefert weitere Informationen." << std::endl;
+                settings->modus = Modus::EXIT;
+                return;
+        }
+    }
+}
+
+
+void unterOption_default_help(Settings *settings, char * argv0)
+{
+    std::cout << getProgramName(argv0) << " default: " << std::endl
+              << "\t-n, --name \t\t[Name]" << std::endl
+              << "\t-i, --ip-addresse \t[IP]\t\t\t Default: 127.0.0.1" << std::endl
+              << "\t-p, --port \t\t[Port]\t\t\t Default: 9050" << std::endl
+              << "\t-g, --genauer-hoster \t[Hoster1,Hoster2,...]" << std::endl
+              << "\t-l, --languages \t[GerSub/GerDub/Eng,...]\t Default: GerDub,GerSub,Eng" << std::endl
+              << "\t-o, --output-file \t[Pfad]" << std::endl
+              << "\t-c, --colorless\t\t\t\t\t Default: false" << std::endl
+              << "\t-h, --help" << std::endl;
+
+
+    settings->modus = Modus::EXIT;
+}
+
+void unterOption_url(Settings *settings, int argc, char **argv)
+{
+    settings->modus = Modus::DIRECT_LINK_MODUS;
+
+    int c = 0;
+    const option long_opts[] = {
+        {"url", required_argument, nullptr, 'u'},
+        {"help", no_argument, nullptr, 'h'},
+
+        {nullptr, no_argument, nullptr, 0}
+
+    };
+
+    while( ( c = getopt_long (argc, argv, "u:h", long_opts, nullptr) ) != -1 ) {
+        switch(c) {
+            case 'u':
+                if(optarg)
+                    settings->name = optarg;
+                break;
+            case 'h':
+                unterOption_url_help(settings, argv[0]);
+                return;
+            default:
+                std::cout << "Aufruf: " << getProgramName(argv[0]) << " url [PARAMETER]" << std::endl;
+                std::cout << "„" << getProgramName(argv[0]) << " url --help“ liefert weitere Informationen." << std::endl;
+                settings->modus = Modus::EXIT;
+                return;
+        }
+    }
+}
+
+void unterOption_url_help(Settings *settings, char * argv0)
+{
+    std::cout << getProgramName(argv0) <<" url: " << std::endl
+              << "\t-u, --url [Url1,Url2]" << std::endl
+              << "\t-h, --help" << std::endl;
+    settings->modus = Modus::EXIT;
+}
+
+
+std::string getProgramName(char *argv0)
+{
+    return std::string(argv0).erase(0, ( (std::string(argv0).find_last_of("/\\") != std::string::npos ) ? std::string(argv0).find_last_of("/\\") +1 : 0 ) );
 }

parameterManager.h

@@ -2,6 +2,9 @@
 #define PARAMETERMANAGER_H
 
 #include <iostream>
+#include <getopt.h>
+#include <string.h>
+
 
 enum Modus {
     EXIT = -1,
@@ -14,12 +17,28 @@ struct Settings {
     Settings() {}
     Settings(std::string name) : name(name) {}
 
-    std::string name;
+    std::string name,
+        accountFilePath = "/home/markus/a",
+        proxy_ip = "127.0.0.1",
+        proxy_port = "9050",
+        genaueHoster,
+        languages = "GerDub,GerSub,Eng",
+        outputFilePath;
     Modus modus = Modus::DEFAULT_MODUS;
-    std::string accountFilePath = "/home/markus/a";
-    bool color;
+    bool colorless = false;
 };
 
 Settings manageParameter(int argc, char ** argv);
+std::string getProgramName(char * argv0);
+
+void unterOption_help(Settings * settings, char *argv0);
+
+
+void unterOption_default(Settings * settings, int argc, char **argv);
+void unterOption_default_help(Settings * settings, char * argv0);
+
+void unterOption_url(Settings * settings, int argc, char **argv);
+void unterOption_url_help(Settings * settings, char *argv0);
+
 
 #endif // PARAMETERMANAGER_H

programManager.cpp

@@ -19,32 +19,39 @@ int ProgramManager::start(Settings setting)
 
 int ProgramManager::defaultModus(Settings *settings)
 {
-    std::cout << "Default Modus" << std::endl;
-
     AccountManager accountManager(settings->accountFilePath);
+    pageManager.setProxy(settings->proxy_ip, settings->proxy_port);
+
     std::string nameInUrl =pageManager.checkName(settings->name);
     if(nameInUrl == "-1")
         return 25;
     else if (pageManager.login(accountManager.getNextAccount()) != 0)
         return 29;
+    pageManager.writeToFile(settings->outputFilePath, "Name: " + settings->name);
 
     //Find out number of all seasons
     Reply tmp_reply = pageManager.getServerRequest(pageManager.UrlPraefix + nameInUrl);
+    if(tmp_reply.html == "-1")
+        return 32;
     int maxStaffel = pageManager.counterContains(tmp_reply.html, "/staffel-%i");
     //For every season
     for (int staffel = 1; staffel <= maxStaffel; ++staffel) {
 
         //Find out number of all episodes
         tmp_reply = pageManager.getServerRequest(pageManager.UrlPraefix + nameInUrl + "/staffel-" + std::to_string(staffel));
+        if(tmp_reply.html == "-1")
+            return 40;
         int maxFolge = pageManager.counterContains(tmp_reply.html, "/episode-%i");
         //for every episode
         for (int folge = 1; folge <= maxFolge; ++folge) {
 
             tmp_reply =pageManager.getServerRequest(pageManager.UrlPraefix + nameInUrl + "/staffel-" + std::to_string(staffel) + "/episode-" + std::to_string(folge));
+            if(tmp_reply.html == "-1")
+                return 47;
             std::string allLinks = pageManager.getLinks(tmp_reply.html);
-            std::string Link = pageManager.chooseHosterLink(allLinks, "GoUnlimited", "GerDub,Eng,GerSub");
+            std::string Link = pageManager.chooseHosterLink(allLinks, settings->genaueHoster, settings->languages);
 
-            std::cout << " -> Link: " << Link << std::endl;
+            std::cout << " -> Link: https://s.to" << Link << std::endl;
             if(convertLink(Link, &accountManager, settings, staffel, folge, allLinks) != 0)
                 return 51;
 
@@ -57,18 +64,19 @@ int ProgramManager::defaultModus(Settings *settings)
 
 int ProgramManager::directLinkModus(Settings *settings)
 {
-    std::cout << "Direct Link Modus" << std::endl;
-
     AccountManager accountManager(settings->accountFilePath);
     std::istringstream iStrStream( pageManager.replace( settings->name, ",", "\n" ) + "\n" );
     std::string line;
 
+    if(pageManager.login(accountManager.getNextAccount()) != 0)
+        return 71;
+
     while (getline(iStrStream, line).good()) {
-        if(line.find("://s.to/redirect/") == std::string::npos) {
+        if(line.find("https://s.to/redirect/") == std::string::npos) {
             std::cout << "Invalid Redirect Link: '" << line << "'" << std::endl;
             continue;
         }
-        if(convertLink(line, &accountManager, settings) != 0)
+        else if(convertLink(pageManager.replace(line, "https://s.to", ""), &accountManager, settings) != 0)
             return 78;
     }
 
@@ -78,13 +86,15 @@ int ProgramManager::directLinkModus(Settings *settings)
 int ProgramManager::convertLink(std::string redirectLink, AccountManager * accountManager, Settings * settings, int Staffel, int Folge, std::string allLinks)
 {
     std::string folgenID = std::string((Staffel == -1 || Folge == -1 ) ? "" : "S" + std::string( (Staffel < 10) ? "0" : "" ) + std::to_string(Staffel)
-                                                                            + "E" + std::string( (Folge   < 10) ? "0" : "" ) + std::to_string( Folge ));
-    if(redirectLink == "") {
-        std::cout << " => " << ( (allLinks == "" ) ? "KEINEN" : "Keinen PASSENDEN" ) << " Hoster für die Folge " << folgenID << " gefunden." << std::endl;
+                                                                            + "E" + std::string( (Folge   < 10) ? "0" : "" ) + std::to_string( Folge ) + ": ");
+    std::string green = ((settings->colorless) ? "" : "\033[32m"), red = ((settings->colorless) ? "" : "\033[31m"), orange =((settings->colorless) ? "" : "\033[33m"), blue = ((settings->colorless) ? "" : "\033[34m");
+
+    if(redirectLink == "" && settings->modus == Modus::DEFAULT_MODUS) {
+        std::cout << " => " << ( (allLinks == "" ) ? "\033[31mKEINEN" : "\033[33mKeinen PASSENDEN" ) << " Hoster für die Folge " << folgenID << " gefunden." << "\033[0m"  << std::endl;
         return 0;
     }
 
-    for (int i = 1; i <= 4; ++i) {
+    for (int i = 1; i <= 3; ++i) {
         std::string newUrl = pageManager.getUrlAfterRedirect("https://s.to" + redirectLink);
         if (newUrl == "-1") {
             return 102;
@@ -94,11 +104,17 @@ int ProgramManager::convertLink(std::string redirectLink, AccountManager * accou
             continue;
         }
         else {
-            std::cout << " => " << folgenID << ": " << ((settings->color) ? "\033[33m" : "") << newUrl << "\033[0m" << std::endl;
+            std::cout << " => " << folgenID << green << newUrl << "\033[0m" << std::endl;
+            if(settings->outputFilePath != "")
+                if(pageManager.writeToFile(folgenID + settings->outputFilePath, newUrl) != 0)
+                    return 108;
             return 0;
         }
     }
-    std::cout << " => " << ": " << ((settings->color) ? "\033[32m" : "") << "https://s.to" << redirectLink << "\033[0m" << std::endl;
+    std::cout << " => " << folgenID << red << "https://s.to" << redirectLink << "\033[0m" << std::endl;
+    if(settings->outputFilePath != "")
+        if(pageManager.writeToFile(settings->outputFilePath, folgenID + redirectLink) != 0)
+            return 114;
     return 0;
 }
 

programManager.h

@@ -4,7 +4,7 @@
 #include "parameterManager.h"
 #include "pageManager.h"
 #include "accountManager.h"
-
+#include <unistd.h>
 
 class ProgramManager
 {