]> git.saurik.com Git - apt.git/blobdiff - test/interactive-helper/aptwebserver.cc
projects / apt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
do not hardcode /dev/null in changetowebserver so it can be changed
[apt.git] / test / interactive-helper / aptwebserver.cc
diff --git a/test/interactive-helper/aptwebserver.cc b/test/interactive-helper/aptwebserver.cc
index 97a298c701821f09a198901c253376d9f2fb6748..2052fe6d865884df7276587e7fc6b8cb33aba16c 100644 (file)
--- a/test/interactive-helper/aptwebserver.cc
+++ b/test/interactive-helper/aptwebserver.cc
@@ -1,3 +1,5 @@
+#include <config.h>
+
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
@@ -12,11 +14,13 @@
 
 #include <sys/socket.h>
 #include <sys/types.h>
 
 #include <sys/socket.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <netinet/in.h>
 #include <unistd.h>
 #include <errno.h>
 #include <time.h>
 #include <stdlib.h>
 #include <netinet/in.h>
 #include <unistd.h>
 #include <errno.h>
 #include <time.h>
 #include <stdlib.h>
+#include <dirent.h>
 
 char const * const httpcodeToStr(int const httpcode) {                 /*{{{*/
    switch (httpcode) {
 
 char const * const httpcodeToStr(int const httpcode) {                 /*{{{*/
    switch (httpcode) {
@@ -86,7 +90,7 @@ void addDataHeaders(std::list<std::string> &headers, std::string &data) {/*{{{*/
 }
                                                                        /*}}}*/
 bool sendHead(int const client, int const httpcode, std::list<std::string> &headers) { /*{{{*/
 }
                                                                        /*}}}*/
 bool sendHead(int const client, int const httpcode, std::list<std::string> &headers) { /*{{{*/
-   string response("HTTP/1.1 ");
+   std::string response("HTTP/1.1 ");
    response.append(httpcodeToStr(httpcode));
    headers.push_front(response);
 
    response.append(httpcodeToStr(httpcode));
    headers.push_front(response);
 
@@ -129,9 +133,9 @@ bool sendData(int const client, std::string const &data) {          /*{{{*/
    return Success;
 }
                                                                        /*}}}*/
    return Success;
 }
                                                                        /*}}}*/
-void sendError(int const client, int const httpcode, string const &request, bool content) { /*{{{*/
+void sendError(int const client, int const httpcode, std::string const &request, bool content) { /*{{{*/
    std::list<std::string> headers;
    std::list<std::string> headers;
-   string response("<html><head><title>");
+   std::string response("<html><head><title>");
    response.append(httpcodeToStr(httpcode)).append("</title></head>");
    response.append("<body><h1>").append(httpcodeToStr(httpcode)).append("</h1");
    response.append("This error is a result of the request: <pre>");
    response.append(httpcodeToStr(httpcode)).append("</title></head>");
    response.append("<body><h1>").append(httpcodeToStr(httpcode)).append("</h1");
    response.append("This error is a result of the request: <pre>");
@@ -142,6 +146,109 @@ void sendError(int const client, int const httpcode, string const &request, bool
       sendData(client, response);
 }
                                                                        /*}}}*/
       sendData(client, response);
 }
                                                                        /*}}}*/
+void sendRedirect(int const client, int const httpcode, std::string const &uri, std::string const &request, bool content) { /*{{{*/
+   std::list<std::string> headers;
+   std::string response("<html><head><title>");
+   response.append(httpcodeToStr(httpcode)).append("</title></head>");
+   response.append("<body><h1>").append(httpcodeToStr(httpcode)).append("</h1");
+   response.append("<p>You should be redirected to <em>").append(uri).append("</em></p>");
+   response.append("This page is a result of the request: <pre>");
+   response.append(request).append("</pre></body></html>");
+   addDataHeaders(headers, response);
+   std::string location("Location: ");
+   if (strncmp(uri.c_str(), "http://", 7) != 0)
+      location.append("http://").append(LookupTag(request, "Host")).append("/").append(uri);
+   else
+      location.append(uri);
+   headers.push_back(location);
+   sendHead(client, httpcode, headers);
+   if (content == true)
+      sendData(client, response);
+}
+                                                                       /*}}}*/
+// sendDirectoryLisiting                                               /*{{{*/
+int filter_hidden_files(const struct dirent *a) {
+   if (a->d_name[0] == '.')
+      return 0;
+#ifdef _DIRENT_HAVE_D_TYPE
+   // if we have the d_type check that only files and dirs will be included
+   if (a->d_type != DT_UNKNOWN &&
+       a->d_type != DT_REG &&
+       a->d_type != DT_LNK && // this includes links to regular files
+       a->d_type != DT_DIR)
+      return 0;
+#endif
+   return 1;
+}
+int grouped_alpha_case_sort(const struct dirent **a, const struct dirent **b) {
+#ifdef _DIRENT_HAVE_D_TYPE
+   if ((*a)->d_type == DT_DIR && (*b)->d_type == DT_DIR);
+   else if ((*a)->d_type == DT_DIR && (*b)->d_type == DT_REG)
+      return -1;
+   else if ((*b)->d_type == DT_DIR && (*a)->d_type == DT_REG)
+      return 1;
+   else
+#endif
+   {
+      struct stat f_prop; //File's property
+      stat((*a)->d_name, &f_prop);
+      int const amode = f_prop.st_mode;
+      stat((*b)->d_name, &f_prop);
+      int const bmode = f_prop.st_mode;
+      if (S_ISDIR(amode) && S_ISDIR(bmode));
+      else if (S_ISDIR(amode))
+        return -1;
+      else if (S_ISDIR(bmode))
+        return 1;
+   }
+   return strcasecmp((*a)->d_name, (*b)->d_name);
+}
+void sendDirectoryListing(int const client, std::string const &dir, std::string const &request, bool content) {
+   std::list<std::string> headers;
+   std::ostringstream listing;
+
+   struct dirent **namelist;
+   int const counter = scandir(dir.c_str(), &namelist, filter_hidden_files, grouped_alpha_case_sort);
+   if (counter == -1) {
+      sendError(client, 500, request, content);
+      return;
+   }
+
+   listing << "<html><head><title>Index of " << dir << "</title>"
+          << "<style type=\"text/css\"><!-- td {padding: 0.02em 0.5em 0.02em 0.5em;}"
+          << "tr:nth-child(even){background-color:#dfdfdf;}"
+          << "h1, td:nth-child(3){text-align:center;}"
+          << "table {margin-left:auto;margin-right:auto;} --></style>"
+          << "</head>" << std::endl
+          << "<body><h1>Index of " << dir << "</h1>" << std::endl
+          << "<table><tr><th>#</th><th>Name</th><th>Size</th><th>Last-Modified</th></tr>" << std::endl;
+   if (dir != ".")
+      listing << "<tr><td>d</td><td><a href=\"..\">Parent Directory</a></td><td>-</td><td>-</td></tr>";
+   for (int i = 0; i < counter; ++i) {
+      struct stat fs;
+      std::string filename(dir);
+      filename.append("/").append(namelist[i]->d_name);
+      stat(filename.c_str(), &fs);
+      if (S_ISDIR(fs.st_mode)) {
+        listing << "<tr><td>d</td>"
+                << "<td><a href=\"" << namelist[i]->d_name << "/\">" << namelist[i]->d_name << "</a></td>"
+                << "<td>-</td>";
+      } else {
+        listing << "<tr><td>f</td>"
+                << "<td><a href=\"" << namelist[i]->d_name << "\">" << namelist[i]->d_name << "</a></td>"
+                << "<td>" << SizeToStr(fs.st_size) << "B</td>";
+      }
+      listing << "<td>" << TimeRFC1123(fs.st_mtime) << "</td></tr>" << std::endl;
+   }
+   listing << "</table></body></html>" << std::endl;
+
+   std::string response(listing.str());
+   addDataHeaders(headers, response);
+   sendHead(client, 200, headers);
+   if (content == true)
+      sendData(client, response);
+}
+                                                                       /*}}}*/
 int main(int const argc, const char * argv[])
 {
    CommandLine::Args Args[] = {
 int main(int const argc, const char * argv[])
 {
    CommandLine::Args Args[] = {
@@ -224,24 +331,26 @@ int main(int const argc, const char * argv[])
            }
 
            size_t const filestart = m->find(' ', 5);
            }
 
            size_t const filestart = m->find(' ', 5);
-           string filename = m->substr(5, filestart - 5);
+           std::string filename = m->substr(5, filestart - 5);
+           if (filename.empty() == true)
+              filename = ".";
+           else
+              filename = DeQuoteString(filename);
 
            if (simulate_broken_server == true) {
 
            if (simulate_broken_server == true) {
-              string data("ni ni ni\n");
+              std::string data("ni ni ni\n");
               addDataHeaders(headers, data);
               sendHead(client, 200, headers);
               sendData(client, data);
            }
               addDataHeaders(headers, data);
               sendHead(client, 200, headers);
               sendData(client, data);
            }
-           else if (RealFileExists(filename) == false)
-              sendError(client, 404, *m, sendContent);
-           else {
+           else if (RealFileExists(filename) == true) {
               FileFd data(filename, FileFd::ReadOnly);
               std::string condition = LookupTag(*m, "If-Modified-Since", "");
               if (condition.empty() == false) {
                  time_t cache;
                  if (RFC1123StrToTime(condition.c_str(), cache) == true &&
                      cache >= data.ModificationTime()) {
               FileFd data(filename, FileFd::ReadOnly);
               std::string condition = LookupTag(*m, "If-Modified-Since", "");
               if (condition.empty() == false) {
                  time_t cache;
                  if (RFC1123StrToTime(condition.c_str(), cache) == true &&
                      cache >= data.ModificationTime()) {
-                    sendError(client, 304, *m, false);
+                    sendHead(client, 304, headers);
                     continue;
                  }
               }
                     continue;
                  }
               }
@@ -250,6 +359,14 @@ int main(int const argc, const char * argv[])
               if (sendContent == true)
                  sendFile(client, data);
            }
               if (sendContent == true)
                  sendFile(client, data);
            }
+           else if (DirectoryExists(filename) == true) {
+              if (filename == "." || filename[filename.length()-1] == '/')
+                 sendDirectoryListing(client, filename, *m, sendContent);
+              else
+                 sendRedirect(client, 301, filename.append("/"), *m, sendContent);
+           }
+           else
+              sendError(client, 404, *m, false);
         }
         _error->DumpErrors(std::cerr);
         messages.clear();
         }
         _error->DumpErrors(std::cerr);
         messages.clear();
APT (for Cydia)