v0.01

.gitignore

@@ -0,0 +1,3 @@
+.idea
+cmake-build-debug
+cmake-build-release

CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.12)
+project(anonfile)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CURL_LIBRARY "-lcurl")
+find_package(CURL REQUIRED)
+
+add_executable(anonfile main.cpp helpers/helpers.cpp helpers/helpers.h pjson/pjson.h json_handler/JHandler.cpp json_handler/JHandler.h)
+
+include_directories(${CURL_INCLUDE_DIR})
+target_link_libraries(anonfile ${CURL_LIBRARIES})

build.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+echo "build"
+if [ ! -d build ]; then
+   mkdir ./build
+   fi
+cd ./build
+cmake ..
+make -j4

helpers/helpers.cpp

@@ -0,0 +1,52 @@
+#include "helpers.h"
+
+int Helpers::get_current_length(char* str) {
+  int i = 0;
+  while (str[i] != '\0')
+    i++;
+  return i;
+}
+
+bool Helpers::contains(char*& tmp) {
+  for (size_t i = 0; i < get_current_length(tmp); i++)
+    if (tmp[i] == '\\' || tmp[i] == '/')
+      return true;
+  return false;
+}
+
+char* Helpers::reverse(char*& str) {
+  int ecx = get_current_length(str) - 1;
+  char tmp;
+  for (int i = 0; i < ecx; i++, ecx--) {
+    tmp = str[i];
+    str[i] = str[ecx];
+    str[ecx] = tmp;
+  }
+  return str;
+}
+
+std::string Helpers::readFromFile(std::ifstream& _in) {
+  std::string tmp;
+  if (_in) {
+    _in.seekg(0, std::ios::end);
+    tmp.resize(_in.tellg());
+    _in.seekg(0, std::ios::beg);
+    _in.read(&tmp[0], tmp.size());
+    printf("Size of input file: %d\n", tmp.size());
+    _in.close();
+  } else
+    throw std::runtime_error("Error, unable to open file!");
+  return tmp;
+}
+
+void Helpers::printRequestData() {
+  if (status) {
+    std::cout << "File was uploaded successfully!\n"
+              << "Full url to file: " << url_ptr->str_full
+              << "\nShort url to file: " << url_ptr->str_short
+              << "\nFile id: " << MD_ptr->id
+              << "\nFilename: " << MD_ptr->name
+              << "\nSize of file: " << MD_ptr->size << '\n';
+  } else
+    std::cerr << "Error: " << error_msg << std::endl;
+}

helpers/helpers.h

@@ -0,0 +1,23 @@
+#ifndef ANONFILE_HELPERS_H
+#define ANONFILE_HELPERS_H
+
+#include <string>
+#include <fstream>
+#include "../json_handler/JHandler.h"
+
+class Helpers : protected JHandler {
+public:
+  Helpers(std::string cfg) : JHandler(cfg) {}
+
+  Helpers() = default;
+  static int get_current_length(char* str);
+
+  static bool contains(char* &tmp);
+
+  static char* reverse(char*& str);
+
+  static std::string readFromFile(std::ifstream& _in);
+
+  void printRequestData();
+};
+#endif //ANONFILE_HELPERS_H

json_handler/JHandler.cpp

@@ -0,0 +1,38 @@
+#include "JHandler.h"
+
+JHandler::JHandler(std::string &cfg){
+  pjson::document doc;
+  try {
+    if (doc.deserialize_in_place(const_cast<char*>(cfg.c_str()))) {
+      if (doc.has_key("status") && doc.has_key("data")) {
+        status = doc["status"].as_bool();
+        url_ptr->str_full = doc["data"]["file"].get_object()[0].get_value()[0].as_string_ptr();
+        url_ptr->str_short = doc["data"]["file"].get_object()[0].get_value()[1].as_string_ptr();
+        MD_ptr->id = doc["data"]["file"].get_object()[1].get_value()[0].as_string_ptr();
+        MD_ptr->name = doc["data"]["file"].get_object()[1].get_value()[1].as_string_ptr();
+        MD_ptr->size = doc["data"]["file"]["metadata"]["size"].get_object()[1].get_value().as_string_ptr();
+
+#ifdef DEBUG
+        std::cout << "[DEBUG|CFG] : status is: " << status << std::endl;
+        std::cout << "[DEBUG|CFG] : url full is: " << url_ptr->str_full << std::endl;
+        std::cout << "[DEBUG|CFG] : url short is: " << url_ptr->str_short << std::endl;
+        std::cout << "[DEBUG|CFG] MD id is: " << MD_ptr->id << std::endl;
+        std::cout << "[DEBUG|CFG] MD name is: " << MD_ptr->name << std::endl;
+        std::cout << "[DEBUG|CFG] MD size is: " << MD_ptr->size << std::endl;
+#endif
+
+      } else if(doc.has_key("error")) {
+        error_msg = doc["error"].get_object()[0].get_value().as_string_ptr();
+#ifdef DEBUG
+        std::cout << "[DEBUG|CFG] error_msg : " << error_msg << std::endl;
+#endif
+      }
+      else
+        throw std::string("Error, bad JSON format, key [status] not found.");
+    } else
+      throw std::string("Error, bad data. [doc.deserialize_in_place()]");
+  }
+  catch(std::string& e) {
+    std::cerr << e << std::endl;
+  }
+}

json_handler/JHandler.h

@@ -0,0 +1,35 @@
+#ifndef ANONFILE_JHANDLER_H
+#define ANONFILE_JHANDLER_H
+//#define DEBUG
+
+#include <string>
+#include <iostream>
+#include <memory>
+#include "../pjson/pjson.h"
+
+class JHandler {
+protected:
+
+  struct url {
+    std::string str_full;
+    std::string str_short;
+  };
+
+  struct metadata {
+    std::string id;
+    std::string name;
+    std::string size;
+  };
+
+  std::shared_ptr<url> url_ptr = std::make_shared<url>();
+  std::shared_ptr<metadata> MD_ptr = std::make_shared<metadata>();
+  std::string error_msg;
+  bool status;
+
+public:
+ explicit JHandler(std::string& cfg);
+ JHandler() = default;
+};
+
+
+#endif //ANONFILE_JHANDLER_H

main.cpp

@@ -0,0 +1,124 @@
+#include <stdio.h>
+#include <curl/curl.h>
+#include <iostream>
+#include <cstring>
+#include "helpers/helpers.h"
+#include "json_handler/JHandler.h"
+
+#define LINUX
+//#define DEBUG
+
+size_t writeCallback(char* buf, size_t size, size_t nmemb, void* up) {
+  ((std::string*)up)->append(buf, size * nmemb);
+  return size * nmemb;
+}
+
+int main(int argc, char** argv) {
+  std::string contents, data;
+  char *filename = new char[256];
+  if (argc == 2)
+    strcpy(filename, argv[1]);
+  else if (argc == 1) {
+    std::cout << "Enter filename: ";
+    std::cin.getline(filename, 256);
+  }
+  else {
+    std::cerr << "Error too many arguments provided, usage: anonfile <your_path_to_file>\n"
+              << "File path must be without spaces.\n";
+    return -1;
+  }
+
+  int ecx = Helpers::get_current_length(filename), i = 0;
+  char *formattedFilename = new char[ecx];
+
+  if (Helpers::contains(filename)) {
+    while (filename[ecx] != '\\') {
+      ecx--;
+      if (ecx < 0) break;
+      if (filename[ecx] == '/') break;
+      formattedFilename[i] = filename[ecx];
+      i++;
+    }
+    Helpers::reverse(formattedFilename);
+
+#ifdef DEBUG
+    std::cout << "[DEBUG] : formatted filename is: " << formattedFilename << std::endl;
+#endif
+
+  } else
+    for (int c = 0; c <= ecx; c++)
+      formattedFilename[c] = filename[c];
+  std::cout << "filename is: " << filename << std::endl;
+
+  std::ifstream in(filename, std::ios::in | std::ios::binary);
+
+  contents = Helpers::readFromFile(in);
+
+  CURL* curl;
+  CURLcode res;
+
+  struct curl_httppost* formpost = NULL;
+  struct curl_httppost* lastptr = NULL;
+  struct curl_slist* headerlist = NULL;
+
+  curl_global_init(CURL_GLOBAL_ALL);
+
+// set up the header
+  curl_formadd(&formpost,
+               &lastptr,
+               CURLFORM_COPYNAME, "cache-control:",
+               CURLFORM_COPYCONTENTS, "no-cache",
+               CURLFORM_END);
+
+  curl_formadd(&formpost,
+               &lastptr,
+               CURLFORM_COPYNAME, "content-type:",
+               CURLFORM_COPYCONTENTS, "multipart/form-data",
+               CURLFORM_END);
+
+  curl_formadd(&formpost, &lastptr,
+               CURLFORM_COPYNAME, "file",  // the (in this case) wanted file-Tag!
+               CURLFORM_BUFFER, formattedFilename,
+               CURLFORM_BUFFERPTR, contents.data(),
+               CURLFORM_BUFFERLENGTH, contents.size(),
+               CURLFORM_END);
+
+  curl = curl_easy_init();
+  headerlist = curl_slist_append(headerlist, "pragma:");
+  if (curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, "https://anonfile.com/api/upload");
+
+#ifndef LINUX
+    curl_easy_setopt (curl, CURLOPT_CAINFO, "cacert.pem"); // set path to SSL CA cert issue "cacert.pem"
+#endif
+
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &writeCallback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
+    curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
+
+    res = curl_easy_perform(curl);
+
+    /* Check for errors */
+    if (res != CURLE_OK)
+      std::cerr <<  "Error, check you internet connection [" << curl_easy_strerror(res)<< "]\n";
+
+#ifdef DEBUG
+    std::cout << std::endl << "[DEBUG|DATA] : " << data << std::endl;
+#endif
+
+    curl_easy_cleanup(curl);
+    curl_formfree(formpost);
+    curl_slist_free_all(headerlist);
+  }
+  curl_global_cleanup();
+
+  delete[] filename;
+  delete[] formattedFilename;
+
+  Helpers handler(data);
+  handler.printRequestData();
+
+  std::cout << "Press ENTER to exit.\n";
+  std::cin.get();
+  return 0;
+}