From 278d59163a3ce9377a242e0eba86949301289779 Mon Sep 17 00:00:00 2001 From: Markus Date: Sun, 7 Jul 2019 18:30:37 +0200 Subject: [PATCH] add * --- main.cpp | 3 - pageManager.cpp | 36 ++- pageManager.h | 5 + parameterManager.cpp | 670 ++++++++++++++++++++++++++++++++++++++++++- parameterManager.h | 25 +- programManager.cpp | 44 ++- programManager.h | 2 +- 7 files changed, 761 insertions(+), 24 deletions(-) diff --git a/main.cpp b/main.cpp index c862079..246d219 100644 --- a/main.cpp +++ b/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); } diff --git a/pageManager.cpp b/pageManager.cpp index a9ad03c..cf1367c 100644 --- a/pageManager.cpp +++ b/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" ); diff --git a/pageManager.h b/pageManager.h index 9661bef..2ba8846 100644 --- a/pageManager.h +++ b/pageManager.h @@ -4,6 +4,7 @@ #include #include #include +//#include <../../../../../home/markus/Downloads/Curl/include/curl/curl.h> #include #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: diff --git a/parameterManager.cpp b/parameterManager.cpp index 346fd7e..ad85abf 100644 --- a/parameterManager.cpp +++ b/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(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(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(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(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(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(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" </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 ) ); } diff --git a/parameterManager.h b/parameterManager.h index 56a7081..f803553 100644 --- a/parameterManager.h +++ b/parameterManager.h @@ -2,6 +2,9 @@ #define PARAMETERMANAGER_H #include +#include +#include + 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 diff --git a/programManager.cpp b/programManager.cpp index c555e6d..a206b43 100644 --- a/programManager.cpp +++ b/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; } diff --git a/programManager.h b/programManager.h index ba58d48..e289498 100644 --- a/programManager.h +++ b/programManager.h @@ -4,7 +4,7 @@ #include "parameterManager.h" #include "pageManager.h" #include "accountManager.h" - +#include class ProgramManager {