API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 3rd, 2017
98
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 22.98 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <cmath>
  4. #include <fstream>
  5. #include <string>
  6. #include <sstream>
  7. #include <sys/resource.h>
  8. #include <sys/time.h>
  9. #include <unistd.h>
  10. #include <ctime>
  11.  
  12. #include <mysql_connection.h>
  13. #include <mysql_driver.h>
  14. #include <cppconn/exception.h>
  15. #include <cppconn/resultset.h>
  16. #include <cppconn/statement.h>
  17. #include <cppconn/prepared_statement.h>
  18. #include <cppconn/driver.h>
  19. #include "seccomp-bpf.h"
  20. #include "seccomp.h"
  21. #include <sys/resource.h>
  22. #include <sys/types.h>
  23. #include <sys/wait.h>
  24. #include <sys/prctl.h>
  25. #include <sys/ptrace.h>
  26. #include <sys/stat.h>
  27. #include <fcntl.h>
  28. #include <errno.h>
  29. #include <stddef.h>
  30. #include <linux/audit.h>
  31. #include <linux/filter.h>
  32. #include <sys/socket.h>
  33.  
  34. #include "pstream.h"
  35. #include "config.h"
  36.  
  37. #define BUF_SIZE    256
  38. using namespace std;
  39. void syscall_filter_init(bool action){
  40.    
  41.     prctl (PR_SET_NO_NEW_PRIVS, 1);
  42.     prctl (PR_SET_DUMPABLE, 0);
  43.  
  44.     scmp_filter_ctx ctx = seccomp_init (SCMP_ACT_ALLOW);
  45.    
  46. //    seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(fork), 0);
  47.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(vfork), 0);
  48.    // seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(clone), 1,
  49.      //   SCMP_A1 (SCMP_CMP_EQ, 0));
  50.    // seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(kill), 0);
  51.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(sigaction), 0);
  52.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(unlink), 0);
  53.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(unlinkat), 0);
  54.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(rename), 0);
  55.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(chdir), 0);
  56.     seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(mkdir), 0);
  57.    
  58.    // seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(bind), 0);
  59. //    seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(setsockopt), 0);
  60.  /*   seccomp_rule_add (ctx, SCMP_ACT_TRAP, SCMP_SYS(listen), 0);
  61.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(execve), 0);
  62.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);
  63.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
  64.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0);
  65.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(access), 0);
  66.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(open), 0);
  67.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fstat), 0);
  68.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
  69.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mprotect), 0);
  70.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(close), 0);
  71.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(arch_prctl), 0);
  72.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
  73.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
  74.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(uname), 0);
  75.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
  76.     seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(readlink), 0);
  77.   */
  78.    if(action==true) {
  79.     seccomp_load (ctx);
  80.    }
  81.   else if(action==false)
  82.      {
  83.       seccomp_release(ctx);
  84.      }
  85.  
  86. /*scmp_filter_ctx ctx;
  87.   ctx = seccomp_init(SCMP_ACT_KILL); // default action: kill
  88.  
  89.   // setup basic whitelist
  90.   seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigreturn), 0);
  91.   seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
  92.   seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
  93.   seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
  94.  
  95.   // setup our rule
  96.   seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(dup2), 2,
  97.                         SCMP_A0(SCMP_CMP_EQ, 1),
  98.                         SCMP_A1(SCMP_CMP_EQ, 2));
  99.  
  100.   // build and load the filter
  101.   seccomp_load(ctx);
  102. */
  103. }
  104.  
  105. struct tm *theTime;
  106.  
  107. //konwersja z int na string
  108. string konwertuj(int i) {
  109.  ostringstream ss;
  110.    ss << i;
  111.     string str=ss.str();
  112.     return str;
  113.   }
  114.  
  115. //dopisywanie tekstu do logów
  116. void dopisz(string log) {
  117.    fstream plik;
  118.     plik.open(LOG, ios::out|ios::app);
  119.      plik<<endl<<log;
  120.      plik.close();
  121. }
  122.  
  123. //tworzenie katalogu submita
  124. string dir(int id)
  125.  {
  126.   string dir="sudo mkdir /POJS/result/";
  127.   dir+=konwertuj(id);
  128.   dir+=" && sudo chmod -R 777 /POJS/result/";
  129.   dir+=konwertuj(id);
  130.    return dir;
  131.  }
  132.  
  133. //Uzyskiwanie czasu
  134. string get_time() {
  135.   time_t tim;
  136.    time(&tim);
  137.   theTime = localtime(&tim);
  138.    string time="";
  139.    time+=konwertuj(1900+(theTime->tm_year));
  140.    time+="-";
  141.    if(((theTime->tm_mon)+1)<10) {
  142.       time+="0";
  143.       time+=konwertuj((theTime->tm_mon)+1);
  144.      }
  145.    else {
  146.      time+=konwertuj((theTime->tm_mon)+1);
  147.      }
  148.    
  149.    time+="-";
  150.    time+=konwertuj(theTime->tm_mday);
  151.    time+=" ";
  152.    time+=konwertuj(theTime->tm_hour);
  153.    time+=":";
  154.    time+=konwertuj(theTime->tm_min);
  155.    time+=":";
  156.    time+=konwertuj(theTime->tm_sec);
  157.     return time;
  158. }
  159.  
  160. //sprawdzanie rozszerzenia submita
  161. string ext(string submit) {
  162.    int indeks=0;
  163.     for(int i=0;i<submit.length();i++)
  164.         {
  165.          if(submit[i]=='.')
  166.             {
  167.              indeks=i;
  168.             }
  169.         }
  170.    string ext="";
  171.         for(int i=indeks+1;i<submit.length();i++)
  172.              {
  173.                ext+=submit[i];
  174.              }
  175.          return ext;
  176.    }
  177.  
  178. //tworzenie polecenia kompilacji
  179. string compile(string path, string lang, int id) {
  180.     string comp="";
  181.         if(lang=="cpp"){
  182.            comp+="g++ -O2 -std=c++11 -static -lm -Wall ";
  183.            comp+=path;
  184.            comp+=" -o /POJS/result/";
  185.            comp+=konwertuj(id);
  186.            comp+="/";
  187.            comp+=konwertuj(id);
  188.            comp+=" 2> /tmp/comperror";
  189.             return comp;
  190.          }
  191.          else if(lang=="c") {
  192.           comp+="gcc -std=gnu99 -O2 -static -lm -Wall ";
  193.           comp+=path;
  194.           comp+=" -o /POJS/result/";
  195.            comp+=konwertuj(id);
  196.            comp+="/";
  197.            comp+=konwertuj(id);
  198.            comp+=" 2> /tmp/comperror";
  199.             return comp;
  200.          }
  201.         else if(lang=="ml") {
  202.           comp+="ocamlc ";
  203.           comp+=path;
  204.           comp+=" -o /POJS/result/";
  205.           comp+=konwertuj(id);
  206.           comp+="/";
  207.           comp+=konwertuj(id);
  208.           comp+=" 2> /tmp/comperror";
  209.            return comp;
  210.          }
  211.         else if(lang=="RAMCode") {
  212.             comp+="sudo awk -f var/www/html/ram2cpp.awk ";
  213.             comp+=path;
  214.             comp+=" > /POJS/result/";
  215.             comp+=konwertuj(id);
  216.             comp+="/";
  217.             comp+=konwertuj(id);
  218.             comp+=".cpp; ";
  219.             comp+="g++ -O2 -std=c++11 -static -lm -Wall ";
  220.             comp+="/POJS/result/";
  221.             comp+=konwertuj(id);
  222.             comp+="/";
  223.             comp+=konwertuj(id);
  224.             comp+=".cpp";
  225.             comp+=" -o /POJS/result/";
  226.             comp+=konwertuj(id);
  227.             comp+="/";
  228.             comp+=konwertuj(id);
  229.             comp+=" 2> /tmp/comperror";
  230.               return comp;
  231.           }
  232.  }
  233.  
  234. //Tworzenie MySQL query
  235. string create_query(string status, int points, int id, string output) {
  236.   string query="UPDATE submits SET status='";
  237.    query+=status;
  238.    query+="', points='";
  239.    query+=konwertuj(points);
  240.    query+="', tests='";
  241.    query+=output;
  242.    query+="' WHERE id='";
  243.    query+=konwertuj(id);
  244.    query+="';";
  245.      return query;
  246. }
  247. string create_query_sec(string status, int points, int id, int section, string output) {
  248.   string query="UPDATE contest";
  249.   query+=konwertuj(section);
  250.   query+=" SET nazwa='";
  251.   query+=status;
  252.   query+="', ilosc='";
  253.   query+=konwertuj(points);
  254.   query+="', output='";
  255.   query+=output;
  256.   query+="' WHERE id='";
  257.   query+=konwertuj(id);
  258.   query+="';";
  259.    return query;
  260. }
  261.  
  262. //Sprawdzanie poprawności wykonania kompilacji
  263. bool checkcomp(int id) {
  264.    fstream exist;
  265.    string name="/POJS/result/";
  266.    name+=konwertuj(id);
  267.    name+="/";
  268.    name+=konwertuj(id);
  269.     exist.open(name.c_str());
  270.    bool come;
  271.      if(exist.good()==true)
  272.         {
  273.          exist.close();
  274.         come=true;
  275.          
  276.         }
  277.      else
  278.         {
  279.              come=false;
  280.          }
  281.        name="sudo cp /tmp/comperror /POJS/result/";
  282.        name+=konwertuj(id);
  283.        name+="/ce.log";
  284.        system(name.c_str());
  285.        system("sudo rm /tmp/comperror");
  286.    return come;
  287.  }
  288.  
  289. //sprawdzanie czy istnieją różnice między wzorcem, a zgłoszeniem
  290. bool checkdiff() {
  291.     int lines_num=0;
  292.      string line;
  293.       fstream diff("/tmp/diffmerge");
  294.        while (std::getline(diff, line))
  295.         ++lines_num;
  296.         if(lines_num>0)
  297.            {
  298.             return false;
  299.            }
  300.         else {
  301.              return true;
  302.           }
  303. }
  304.  
  305. //Sprawdzanie, czy program wypisał oczekiwane wyjście
  306. bool checkdifff() {
  307.     int lines_num=0;
  308.      string line;
  309.       fstream diff("/tmp/difffault");
  310.        while (std::getline(diff, line))
  311.         ++lines_num;
  312.         if(lines_num>0)
  313.            {
  314.             return false;
  315.            }
  316.         else {
  317.              return true;
  318.           }
  319. }
  320.  
  321. //Sprawdzanie czy zaszedł while(true) z std::cout
  322. bool checktle(int id, int i) {
  323.  string name="/POJS/result/";
  324.   name+=konwertuj(id);
  325.   name+="/";
  326.   name+=konwertuj(i);
  327.   name+=".out";
  328.   struct stat filestatus;
  329.   stat( name.c_str(), &filestatus );
  330.    if(filestatus.st_size>100056128) {
  331.         return true;
  332.      }
  333.    else {
  334.        return false;
  335.    }
  336. }
  337.  
  338. //Sprawdzanie czy nie pisze się tego outputa pod rząd
  339. bool groupcheck(int id, int tests) {
  340.   string diff="";
  341.   int k=0;
  342.   int n=0;
  343.    for(int i=1;i<tests;i++) {
  344.       diff="diff -w /POJS/result/";
  345.       diff+=konwertuj(id);
  346.       diff+="/";
  347.       diff+=konwertuj(i);
  348.       diff+=".out /POJS/result/";
  349.       int k=i+1;
  350.       diff+=konwertuj(id);
  351.       diff+="/";
  352.       diff+=konwertuj(k);
  353.       system("rm /tmp/difffault");
  354.       diff+=".out > /tmp/difffault";
  355.        system(diff.c_str());
  356.        if(checkdifff()==true) {
  357.           n++;
  358.         }
  359. }
  360.    if(n==tests) {
  361.       return true;
  362.      }
  363.    else {
  364.        return false;
  365.      }
  366. }
  367.  
  368. //Funkcja Główna
  369. int main(int argc, char ** argv)
  370.  {
  371.     struct rlimit rl;
  372.     string log="Sprawdzaczka POJS uruchomiona\n";
  373.       dopisz(log); //Dopisywanie do Pliku /POJS/pojs.log
  374.         if(argc>=7) //Jeżeli liczba argumentów jest większa niż 7
  375.            {
  376.             log="Liczba argumentów poprawna";
  377.               dopisz(log);
  378.              for(int i=1;i<argc;i++)
  379.                  {
  380.                   log="Argument ";
  381.                   log+=konwertuj(i);
  382.                   log+=": ";
  383.                   log+=argv[i];
  384.                    dopisz(log);
  385.                  }
  386.               string quest=argv[1]; //kod zadania
  387.               int id=atoi(argv[2]); //ID zgłoszenia
  388.               string submit=argv[3]; //ścieżka do submita
  389.               int tests=atoi(argv[4]); //liczba testów
  390.               int time=atoi(argv[5]); //limit czasu
  391.               int memory=atoi(argv[6]); //limit pamięci
  392.               int section=0;
  393.               int secid=0;
  394.               string output="";
  395.                 if(argc==9){
  396.                  section=atoi(argv[7]);
  397.                  secid=atoi(argv[8]);
  398.                 }
  399.               system(dir(id).c_str()); //tworzenie katalogu zgłoszenia
  400.                string comp="";
  401.                 if(ext(submit)=="cpp") { //Jeżeli język to C++
  402.                     log="Język: C++ (.cpp)";
  403.                       dopisz(log);
  404.                   }
  405.                 else if(ext(submit)=="c") { //Jeżeli język to C
  406.                     log="Język: C (.c)";
  407.                       dopisz(log);
  408.                    }
  409.                 else if(ext(submit)=="ml") { //Jeżeli język to OCaml
  410.                     log="Język OCaml (.ml)";
  411.                        dopisz(log);
  412.                    }
  413.                   else if(ext(submit)=="RAMCode") { //Jeżeli język to RAM
  414.                      log="Język RAM (.ram)";
  415.                        dopisz(log);
  416.                     }
  417.                  else {
  418.                     log="\n==ERROR==\nBłędny Format przesłanego pliku\nKoniec pracy\n\n";
  419.                      dopisz(log);
  420.                       cout<<log;
  421.                        return 0;
  422.                   }
  423.                   log="Polecenie kompilujące:";
  424.                    log+=compile(submit, ext(submit), id);
  425.                      dopisz(log);
  426.                       log="Kompilacja Rozpoczęta!!!";
  427.                         dopisz(log);
  428.                          /* Pobieramy obecny limit czasu */
  429.                          getrlimit (RLIMIT_CPU, &rl);
  430.                           /* Ustalamy czas kompilacji na 3 sekundy */
  431.                           rl.rlim_cur = 3;
  432.                           setrlimit (RLIMIT_CPU, &rl);
  433.                           system(compile(submit, ext(submit), id).c_str());
  434.                           system("sudo chmod -R 777 /tmp/comperror ");
  435.                           if(checkcomp(id)==true) { //Jeżeli kompilacja przebiegła pomyślnie
  436.                              log="Zkompilowano pomyślnie !!!\n";
  437.                               dopisz(log);
  438.                               int points=0;
  439.                               string run="";
  440.                               string diff="";
  441.                              for(int i=1;i<=tests;i++) {
  442.                                  run="";
  443.                                  diff="";
  444.                                  run+="/POJS/result/";
  445.                                  run+=konwertuj(id);
  446.                                  run+="/";
  447.                                  run+=konwertuj(id);
  448.                                  run+="</POJS/quests/";
  449.                                  run+=quest;
  450.                                  run+="/";
  451.                                  run+=konwertuj(i);
  452.                                  run+=".in>/POJS/result/";
  453.                                  run+=konwertuj(id);
  454.                                  run+="/";
  455.                                  run+=konwertuj(i);
  456.                                  run+=".out";
  457.                                getrlimit (RLIMIT_CPU, &rl);
  458.                                rl.rlim_cur = time;
  459.                                 setrlimit (RLIMIT_CPU, &rl);
  460.                            //    getrlimit (RLIMIT_AS, &ml); //Ustalanie limitu pamięci (W TOKU)
  461.                              //   ml.rlim_cur = memory;
  462.                                // setrlimit(RLIMIT_AS, &ml);
  463.                                 bool action=true;
  464.                                 syscall_filter_init(action);
  465.                                 system(run.c_str());
  466.                                 action=false;
  467.                                 syscall_filter_init(action);
  468.                                 diff="diff -w /POJS/quests/";
  469.                                 diff+=quest;
  470.                                 diff+="/";
  471.                                 diff+=konwertuj(i);
  472.                                 diff+=".out /POJS/result/";
  473.                                 diff+=konwertuj(id);
  474.                                 diff+="/";
  475.                                 diff+=konwertuj(i);
  476.                                 system("rm /tmp/diffmerge");
  477.                                 diff+=".out > /tmp/diffmerge";
  478.                                   system(diff.c_str());
  479.                                     system("chmod -R 777 /tmp/diffmerge");
  480.                                       if(checktle(id, i)==true) {
  481.                                         string status="TLE";
  482.                                         log+="\nStatus: TLE\nPunkty:";
  483.                                         log+=konwertuj(points);
  484.                                          for(int k=i;k<=tests;k++) {
  485.                                              output+="Test nr ";
  486.                                              output+=konwertuj(k);
  487.                                              output+=": 0pkt TLE <br>";
  488.                                             }
  489.                                              dopisz(output);
  490.                                         dopisz(log);
  491.                                          sql::mysql::MySQL_Driver *driver;
  492.                                          sql::Connection *con;
  493.                                          sql::Statement *stmt;
  494.                                          sql::ResultSet *res;
  495.                                          driver = sql::mysql::get_driver_instance();
  496.                                          con=driver->connect("tcp://156.17.4.36:3306", DB_USER, DB_PASSWORD);
  497.                                          log="Łączenie z bazą danych POJS pod ip: 156.17.4.36, Port: 3306";
  498.                                           dopisz(log);
  499.                                          con->setSchema("mysql");
  500.                                            log="Pomyślnie przesłano dane do bazy danych";
  501.                                          dopisz(log);
  502.                                         stmt = con->createStatement();
  503.                                           if(argc==9) {
  504.                                             stmt->execute(create_query_sec(status, points, secid, section, output).c_str());
  505.                                            }
  506.                                          else {
  507.                                          stmt->execute(create_query(status, points, id, output).c_str());
  508.                                           }
  509.                                            delete stmt;
  510.                                            delete con;
  511.                                              return 0;
  512.                                         }
  513.                                     system(diff.c_str());
  514.                                     system("chmod -R 777 /tmp/diffmerge");
  515.                                     if(checkdiff()==true) {
  516.                                        output+="Test nr ";
  517.                                        output+=konwertuj(i);
  518.                                        output+=": ";
  519.                                        int punkt=(100/tests);
  520.                                        output+=konwertuj(punkt);
  521.                                        output+="pkt AC <br>";
  522.                                        points+=(100/tests);
  523.                                        
  524.                                       }
  525.                                    else {
  526.                                       output+="Test nr ";
  527.                                       output+=konwertuj(i);
  528.                                       output+=": ";
  529.                                        output+="0pkt WA <br>";
  530.                                      }
  531.                               }
  532.                                cout<<points;
  533.                                    string status="";
  534.                                    // if(groupcheck(id, tests)==true) {
  535.                                      //   points=0;
  536.                                     // }
  537.                                     if(points>=95)
  538.                                         {
  539.                                           status="AC";
  540.                                         }
  541.                                     else {
  542.                                            status="WA";
  543.                                        }
  544.                                  dopisz(output);
  545.                                  log+="\nStatus: ";
  546.                                  log+=status;
  547.                                  log+="\nPunkty:";
  548.                                  log+=konwertuj(points);
  549.                                     dopisz(log);
  550.                                      sql::mysql::MySQL_Driver *driver;
  551.                                      sql::Connection *con;
  552.                                      sql::Statement *stmt;
  553.                                      sql::ResultSet *res;
  554.                                       driver = sql::mysql::get_driver_instance();
  555.                                        con=driver->connect("tcp://156.17.4.36:3306", DB_USER, DB_PASSWORD);
  556.                                        log="Łączenie z bazą danych POJS pod ip: 156.17.4.36, Port: 3306";
  557.                                          dopisz(log);
  558.                                         con->setSchema("mysql");
  559.                                            log="Pomyślnie przesłano dane do bazy danych\n\nKoniec Pracy\n";
  560.                                          dopisz(log);
  561.                                         stmt = con->createStatement();
  562.                                          if(argc==9) {
  563.                                            stmt->execute(create_query_sec(status, points, secid, section, output).c_str());
  564.                                           }
  565.                                            else {
  566.                                         stmt->execute(create_query(status, points, id, output).c_str());
  567.                                            }
  568.                                            delete stmt;
  569.                                            delete con;
  570.                                              return 0;
  571.                             }
  572.                             else if(checkcomp(id)==false) {
  573.                                 log="\n==ERROR==\nKompilacja nie powiodła się\n";
  574.                                  dopisz(log);
  575.                                cout<<log;
  576.                                 sql::mysql::MySQL_Driver *driver;
  577.                                 sql::Connection *con;
  578.                                 sql::Statement *stmt;
  579.                                 sql::ResultSet *res;
  580.                                 driver = sql::mysql::get_driver_instance();
  581.                                 con=driver->connect("tcp://156.17.4.36:3306", DB_USER, DB_PASSWORD);
  582.                                 log="Łączenie z bazą danych POJS pod ip: 156.17.4.36, Port: 3306";
  583.                                   dopisz(log);
  584.                                 con->setSchema("mysql");
  585.                                   log="Pomyślnie przesłano dane do bazy danych";
  586.                                    dopisz(log);
  587.                                   log="ID:";
  588.                                   log+=konwertuj(id);
  589.                                   log+="\nStatus: CE\nPunkty:0\n\nKoniec pracy\n";
  590.                                    dopisz(log);
  591.                                   cout<<log;
  592.                                 stmt = con->createStatement();
  593.                                 string status="CE";
  594.                                 string output="ALL TESTS CE";
  595.                                 int points=0;
  596.                                 if(argc==9) {
  597.                                 stmt->execute(create_query_sec(status, points, secid, section, output).c_str());
  598.                                    }
  599.                                 else {
  600.                                 stmt->execute(create_query(status, points, id, output).c_str());
  601.                                   }
  602.                                 delete stmt;
  603.                                 delete con;
  604.                                  return 0;
  605.                              }
  606.            }
  607.          else {
  608.            log="\n==ERROR==\nNiepoprawna liczba argumentów\nKoniec pracy\n\n";
  609.             dopisz(log);
  610.             cout<<log;
  611.              return 0;
  612.             }
  613.     return 0;
  614.  }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!