From 57da1b4bd21aceced30f658993fb811a5232cff7 Mon Sep 17 00:00:00 2001
From: David Kalnischkies <kalnischkies@gmail.com>
Date: Fri, 31 May 2013 18:19:09 +0200
Subject: stop building l10n if strings are unchanged

The buildsystem tried to build l10n for test applications which never
produced the output it expected causing it to try building it all the
time.
---
 test/interactive-helper/makefile | 1 +
 1 file changed, 1 insertion(+)

(limited to 'test/interactive-helper')

diff --git a/test/interactive-helper/makefile b/test/interactive-helper/makefile
index 10d1e44ec..fa4f5fecb 100644
--- a/test/interactive-helper/makefile
+++ b/test/interactive-helper/makefile
@@ -1,6 +1,7 @@
 # -*- make -*-
 BASE=../..
 SUBDIR=test/interactive-helper
+APT_DOMAIN=none
 
 # Bring in the default rules
 include ../../buildlib/defaults.mak
-- 
cgit v1.2.3


From fbd29dd60a195a5c252ba1d28366d52d60447560 Mon Sep 17 00:00:00 2001
From: David Kalnischkies <kalnischkies@gmail.com>
Date: Sat, 15 Jun 2013 15:45:22 +0200
Subject: add a simple webserver for our testcases

APT needs to acquire data in a secure fashion over an inherently
unsecure way, known as the internet, while communicating with
unreliable partners, known as webservers and proxies.

For your integration tests we so far relied on 'normal' webservers,
but all of them have certain quirks and none is able to provide us
with all quirks which can be observed in the wild and we therefore
have to test with, so this webserver isn't trying to be fast, secure
or feature complete, but to provide all the quirks we need in a
consistent way.

This webserver also makes the APT project self-contained, as it is now
able to generate, serve as well as acquire package indexes. ;)

Git-Dch: Ignore
---
 test/interactive-helper/aptwebserver.cc | 343 ++++++++++++++++++++++++++++++++
 test/interactive-helper/makefile        |   7 +
 2 files changed, 350 insertions(+)
 create mode 100644 test/interactive-helper/aptwebserver.cc

(limited to 'test/interactive-helper')

diff --git a/test/interactive-helper/aptwebserver.cc b/test/interactive-helper/aptwebserver.cc
new file mode 100644
index 000000000..98bbde21b
--- /dev/null
+++ b/test/interactive-helper/aptwebserver.cc
@@ -0,0 +1,343 @@
+#include <config.h>
+
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/cmndline.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/init.h>
+
+#include <vector>
+#include <string>
+#include <list>
+#include <sstream>
+
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <errno.h>
+#include <time.h>
+#include <stdlib.h>
+#include <signal.h>
+
+char const * const httpcodeToStr(int const httpcode)			/*{{{*/
+{
+   switch (httpcode)
+   {
+      // Informational 1xx
+      case 100: return "100 Continue";
+      case 101: return "101 Switching Protocols";
+      // Successful 2xx
+      case 200: return "200 OK";
+      case 201: return "201 Created";
+      case 202: return "202 Accepted";
+      case 203: return "203 Non-Authoritative Information";
+      case 204: return "204 No Content";
+      case 205: return "205 Reset Content";
+      case 206: return "206 Partial Content";
+      // Redirections 3xx
+      case 300: return "300 Multiple Choices";
+      case 301: return "301 Moved Permanently";
+      case 302: return "302 Found";
+      case 303: return "303 See Other";
+      case 304: return "304 Not Modified";
+      case 305: return "304 Use Proxy";
+      case 307: return "307 Temporary Redirect";
+      // Client errors 4xx
+      case 400: return "400 Bad Request";
+      case 401: return "401 Unauthorized";
+      case 402: return "402 Payment Required";
+      case 403: return "403 Forbidden";
+      case 404: return "404 Not Found";
+      case 405: return "405 Method Not Allowed";
+      case 406: return "406 Not Acceptable";
+      case 407: return "407 Proxy Authentication Required";
+      case 408: return "408 Request Time-out";
+      case 409: return "409 Conflict";
+      case 410: return "410 Gone";
+      case 411: return "411 Length Required";
+      case 412: return "412 Precondition Failed";
+      case 413: return "413 Request Entity Too Large";
+      case 414: return "414 Request-URI Too Large";
+      case 415: return "415 Unsupported Media Type";
+      case 416: return "416 Requested range not satisfiable";
+      case 417: return "417 Expectation Failed";
+      case 418: return "418 I'm a teapot";
+      // Server error 5xx
+      case 500: return "500 Internal Server Error";
+      case 501: return "501 Not Implemented";
+      case 502: return "502 Bad Gateway";
+      case 503: return "503 Service Unavailable";
+      case 504: return "504 Gateway Time-out";
+      case 505: return "505 HTTP Version not supported";
+   }
+   return NULL;
+}
+									/*}}}*/
+void addFileHeaders(std::list<std::string> &headers, FileFd &data)	/*{{{*/
+{
+   std::ostringstream contentlength;
+   contentlength << "Content-Length: " << data.FileSize();
+   headers.push_back(contentlength.str());
+
+   std::string lastmodified("Last-Modified: ");
+   lastmodified.append(TimeRFC1123(data.ModificationTime()));
+   headers.push_back(lastmodified);
+}
+									/*}}}*/
+void addDataHeaders(std::list<std::string> &headers, std::string &data)	/*{{{*/
+{
+   std::ostringstream contentlength;
+   contentlength << "Content-Length: " << data.size();
+   headers.push_back(contentlength.str());
+}
+									/*}}}*/
+bool sendHead(int const client, int const httpcode, std::list<std::string> &headers)/*{{{*/
+{
+   std::string response("HTTP/1.1 ");
+   response.append(httpcodeToStr(httpcode));
+   headers.push_front(response);
+
+   headers.push_back("Server: APT webserver");
+
+   std::string date("Date: ");
+   date.append(TimeRFC1123(time(NULL)));
+   headers.push_back(date);
+
+   std::clog << ">>> RESPONSE >>>" << std::endl;
+   bool Success = true;
+   for (std::list<std::string>::const_iterator h = headers.begin();
+	Success == true && h != headers.end(); ++h)
+   {
+      Success &= FileFd::Write(client, h->c_str(), h->size());
+      if (Success == true)
+	 Success &= FileFd::Write(client, "\r\n", 2);
+      std::clog << *h << std::endl;
+   }
+   if (Success == true)
+      Success &= FileFd::Write(client, "\r\n", 2);
+   std::clog << "<<<<<<<<<<<<<<<<" << std::endl;
+   return Success;
+}
+									/*}}}*/
+bool sendFile(int const client, FileFd &data)				/*{{{*/
+{
+   bool Success = true;
+   char buffer[500];
+   unsigned long long actual = 0;
+   while ((Success &= data.Read(buffer, sizeof(buffer), &actual)) == true)
+   {
+      if (actual == 0)
+	 break;
+      if (Success == true)
+	 Success &= FileFd::Write(client, buffer, actual);
+   }
+   if (Success == true)
+      Success &= FileFd::Write(client, "\r\n", 2);
+   return Success;
+}
+									/*}}}*/
+bool sendData(int const client, std::string const &data)		/*{{{*/
+{
+   bool Success = true;
+   Success &= FileFd::Write(client, data.c_str(), data.size());
+   if (Success == true)
+      Success &= FileFd::Write(client, "\r\n", 2);
+   return Success;
+}
+									/*}}}*/
+void sendError(int const client, int const httpcode, std::string const &request,/*{{{*/
+	       bool content, std::string const &error = "")
+{
+   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>");
+   if (error.empty() == false)
+      response.append("<p><em>Error</em>: ").append(error).append("</p>");
+   response.append("This error is a result of the request: <pre>");
+   response.append(request).append("</pre></body></html>");
+   addDataHeaders(headers, response);
+   sendHead(client, httpcode, headers);
+   if (content == true)
+      sendData(client, response);
+}
+									/*}}}*/
+bool parseFirstLine(int const client, std::string const &request,	/*{{{*/
+		    std::string &filename, bool &sendContent,
+		    bool &closeConnection)
+{
+   if (strncmp(request.c_str(), "HEAD ", 5) == 0)
+      sendContent = false;
+   if (strncmp(request.c_str(), "GET ", 4) != 0)
+   {
+      sendError(client, 501, request, true);
+      return false;
+   }
+
+   size_t const lineend = request.find('\n');
+   size_t filestart = request.find(' ');
+   for (; request[filestart] == ' '; ++filestart);
+   size_t fileend = request.rfind(' ', lineend);
+   if (lineend == std::string::npos || filestart == std::string::npos ||
+	 fileend == std::string::npos || filestart == fileend)
+   {
+      sendError(client, 500, request, sendContent, "Filename can't be extracted");
+      return false;
+   }
+
+   size_t httpstart = fileend;
+   for (; request[httpstart] == ' '; ++httpstart);
+   if (strncmp(request.c_str() + httpstart, "HTTP/1.1\r", 9) == 0)
+      closeConnection = strcasecmp(LookupTag(request, "Connection", "Keep-Alive").c_str(), "Keep-Alive") != 0;
+   else if (strncmp(request.c_str() + httpstart, "HTTP/1.0\r", 9) == 0)
+      closeConnection = strcasecmp(LookupTag(request, "Connection", "Keep-Alive").c_str(), "close") == 0;
+   else
+   {
+      sendError(client, 500, request, sendContent, "Not a HTTP/1.{0,1} request");
+      return false;
+   }
+
+   filename = request.substr(filestart, fileend - filestart);
+   if (filename.find(' ') != std::string::npos)
+   {
+      sendError(client, 500, request, sendContent, "Filename contains an unencoded space");
+      return false;
+   }
+   filename = DeQuoteString(filename);
+
+   // this is not a secure server, but at least prevent the obvious …
+   if (filename.empty() == true || filename[0] != '/' ||
+       strncmp(filename.c_str(), "//", 2) == 0 ||
+       filename.find_first_of("\r\n\t\f\v") != std::string::npos ||
+       filename.find("/../") != std::string::npos)
+   {
+      sendError(client, 400, request, sendContent, "Filename contains illegal character (sequence)");
+      return false;
+   }
+
+   // nuke the first character which is a / as we assured above
+   filename.erase(0, 1);
+   if (filename.empty() == true)
+      filename = ".";
+   return true;
+}
+									/*}}}*/
+int main(int const argc, const char * argv[])
+{
+   CommandLine::Args Args[] = {
+      {0, "port", "aptwebserver::port", CommandLine::HasArg},
+      {'c',"config-file",0,CommandLine::ConfigFile},
+      {'o',"option",0,CommandLine::ArbItem},
+      {0,0,0,0}
+   };
+
+   CommandLine CmdL(Args, _config);
+   if(CmdL.Parse(argc,argv) == false)
+   {
+      _error->DumpErrors();
+      exit(1);
+   }
+
+   // create socket, bind and listen to it {{{
+   // ignore SIGPIPE, this can happen on write() if the socket closes connection
+   signal(SIGPIPE, SIG_IGN);
+   int sock = socket(AF_INET6, SOCK_STREAM, 0);
+   if(sock < 0)
+   {
+      _error->Errno("aptwerbserver", "Couldn't create socket");
+      _error->DumpErrors(std::cerr);
+      return 1;
+   }
+
+   int const port = _config->FindI("aptwebserver::port", 8080);
+
+   // ensure that we accept all connections: v4 or v6
+   int const iponly = 0;
+   setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &iponly, sizeof(iponly));
+   // to not linger on an address
+   int const enable = 1;
+   setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
+
+   struct sockaddr_in6 locAddr;
+   memset(&locAddr, 0, sizeof(locAddr));
+   locAddr.sin6_family = AF_INET6;
+   locAddr.sin6_port = htons(port);
+   locAddr.sin6_addr = in6addr_any;
+
+   if (bind(sock, (struct sockaddr*) &locAddr, sizeof(locAddr)) < 0)
+   {
+      _error->Errno("aptwerbserver", "Couldn't bind");
+      _error->DumpErrors(std::cerr);
+      return 2;
+   }
+
+   std::clog << "Serving ANY file on port: " << port << std::endl;
+
+   listen(sock, 1);
+   /*}}}*/
+
+   std::vector<std::string> messages;
+   int client;
+   while ((client = accept(sock, NULL, NULL)) != -1)
+   {
+      std::clog << "ACCEPT client " << client
+		<< " on socket " << sock << std::endl;
+
+      while (ReadMessages(client, messages))
+      {
+	 bool closeConnection = false;
+	 for (std::vector<std::string>::const_iterator m = messages.begin();
+	      m != messages.end() && closeConnection == false; ++m) {
+	    std::clog << ">>> REQUEST >>>>" << std::endl << *m
+		      << std::endl << "<<<<<<<<<<<<<<<<" << std::endl;
+	    std::list<std::string> headers;
+	    std::string filename;
+	    bool sendContent = true;
+	    if (parseFirstLine(client, *m, filename, sendContent, closeConnection) == false)
+	       continue;
+
+	    std::string host = LookupTag(*m, "Host", "");
+	    if (host.empty() == true)
+	    {
+	       // RFC 2616 §14.23 requires Host
+	       sendError(client, 400, *m, sendContent, "Host header is required");
+	       continue;
+	    }
+
+	    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())
+		  {
+		     sendHead(client, 304, headers);
+		     continue;
+		  }
+	       }
+
+	       addFileHeaders(headers, data);
+	       sendHead(client, 200, headers);
+	       if (sendContent == true)
+		  sendFile(client, data);
+	    }
+	    else
+	       sendError(client, 404, *m, sendContent);
+	 }
+	 _error->DumpErrors(std::cerr);
+	 messages.clear();
+	 if (closeConnection == true)
+	    break;
+      }
+
+      std::clog << "CLOSE client " << client
+		<< " on socket " << sock << std::endl;
+      close(client);
+   }
+   return 0;
+}
diff --git a/test/interactive-helper/makefile b/test/interactive-helper/makefile
index fa4f5fecb..f43df97e3 100644
--- a/test/interactive-helper/makefile
+++ b/test/interactive-helper/makefile
@@ -38,3 +38,10 @@ include $(PROGRAM_H)
 #SLIBS = -lapt-pkg -lrpm
 #SOURCE = rpmver.cc
 #include $(PROGRAM_H)
+
+# Program for testing udevcdrom
+PROGRAM=aptwebserver
+SLIBS = -lapt-pkg
+LIB_MAKES = apt-pkg/makefile
+SOURCE = aptwebserver.cc
+include $(PROGRAM_H)
-- 
cgit v1.2.3


From bf3daa15e9e744d9481d9e6d1e250b77d1f7b256 Mon Sep 17 00:00:00 2001
From: David Kalnischkies <kalnischkies@gmail.com>
Date: Sat, 15 Jun 2013 16:45:12 +0200
Subject: add directory listing to the webserver

Git-Dch: Ignore
---
 test/interactive-helper/aptwebserver.cc | 121 ++++++++++++++++++++++++++++++++
 1 file changed, 121 insertions(+)

(limited to 'test/interactive-helper')

diff --git a/test/interactive-helper/aptwebserver.cc b/test/interactive-helper/aptwebserver.cc
index 98bbde21b..d25f50624 100644
--- a/test/interactive-helper/aptwebserver.cc
+++ b/test/interactive-helper/aptwebserver.cc
@@ -13,12 +13,14 @@
 #include <sstream>
 
 #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 <dirent.h>
 #include <signal.h>
 
 char const * const httpcodeToStr(int const httpcode)			/*{{{*/
@@ -164,6 +166,118 @@ void sendError(int const client, int const httpcode, std::string const &request,
       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);
+}
+									/*}}}*/
+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);
+}
+									/*}}}*/
 bool parseFirstLine(int const client, std::string const &request,	/*{{{*/
 		    std::string &filename, bool &sendContent,
 		    bool &closeConnection)
@@ -326,6 +440,13 @@ int main(int const argc, const char * argv[])
 	       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, sendContent);
 	 }
-- 
cgit v1.2.3


From 7ea27d2a6d10ee41f8fca5d8ad7373c8b3d90ea9 Mon Sep 17 00:00:00 2001
From: David Kalnischkies <kalnischkies@gmail.com>
Date: Sat, 15 Jun 2013 23:58:12 +0200
Subject: simple URI rewrite rules config for webserver

we have a test which required traditionally lighttpd to be executed
as it requires a webserver supporting some kind of URI rewriting.
Now with some lines of code our own webserver can do this and the
testcase can be enabled by default. This test hinted at the bug fixed
in the previous commit, so having more tests which can easily be run
is a good thing.

Git-Dch: Ignore
---
 test/interactive-helper/aptwebserver.cc | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'test/interactive-helper')

diff --git a/test/interactive-helper/aptwebserver.cc b/test/interactive-helper/aptwebserver.cc
index d25f50624..de235fa05 100644
--- a/test/interactive-helper/aptwebserver.cc
+++ b/test/interactive-helper/aptwebserver.cc
@@ -420,6 +420,22 @@ int main(int const argc, const char * argv[])
 	       continue;
 	    }
 
+	    // string replacements in the requested filename
+	    ::Configuration::Item const *Replaces = _config->Tree("aptwebserver::redirect::replace");
+	    if (Replaces != NULL)
+	    {
+	       std::string redirect = "/" + filename;
+	       for (::Configuration::Item *I = Replaces->Child; I != NULL; I = I->Next)
+		  redirect = SubstVar(redirect, I->Tag, I->Value);
+	       redirect.erase(0,1);
+	       if (redirect != filename)
+	       {
+		  sendRedirect(client, 301, redirect, *m, sendContent);
+		  continue;
+	       }
+	    }
+
+	    // deal with the request
 	    if (RealFileExists(filename) == true)
 	    {
 	       FileFd data(filename, FileFd::ReadOnly);
-- 
cgit v1.2.3


From ae99ce2e3cadb07c80b89ab2afc804875b1026c5 Mon Sep 17 00:00:00 2001
From: David Kalnischkies <kalnischkies@gmail.com>
Date: Mon, 17 Jun 2013 11:23:13 +0200
Subject: trigger NODATA error for invalid InRelease files

With the selfgrown splitting we got the problem of not recovering
from networks which just reply with invalid data like those sending
us login pages to authenticate with the network (e.g. hotels) back.

The good thing about the InRelease file is that we know that it must
be clearsigned (a Release file might or might not have a detached sig)
so if we get a file but are unable to split it something is seriously
wrong, so there is not much point in trying further.

The Acquire system already looks out for a NODATA error from gpgv,
so this adds a new error message sent to the acquire system in case
the splitting we do now ourselves failed including this magic word.

Closes: #712486
---
 test/interactive-helper/aptwebserver.cc | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

(limited to 'test/interactive-helper')

diff --git a/test/interactive-helper/aptwebserver.cc b/test/interactive-helper/aptwebserver.cc
index de235fa05..05b875673 100644
--- a/test/interactive-helper/aptwebserver.cc
+++ b/test/interactive-helper/aptwebserver.cc
@@ -435,6 +435,32 @@ int main(int const argc, const char * argv[])
 	       }
 	    }
 
+	    ::Configuration::Item const *Overwrite = _config->Tree("aptwebserver::overwrite");
+	    if (Overwrite != NULL)
+	    {
+	       for (::Configuration::Item *I = Overwrite->Child; I != NULL; I = I->Next)
+	       {
+		  regex_t *pattern = new regex_t;
+		  int const res = regcomp(pattern, I->Tag.c_str(), REG_EXTENDED | REG_ICASE | REG_NOSUB);
+		  if (res != 0)
+		  {
+		     char error[300];
+		     regerror(res, pattern, error, sizeof(error));
+		     sendError(client, 500, *m, sendContent, error);
+		     continue;
+		  }
+		  if (regexec(pattern, filename.c_str(), 0, 0, 0) == 0)
+		  {
+		      filename = _config->Find("aptwebserver::overwrite::" + I->Tag + "::filename", filename);
+		      if (filename[0] == '/')
+			 filename.erase(0,1);
+		      regfree(pattern);
+		      break;
+		  }
+		  regfree(pattern);
+	       }
+	    }
+
 	    // deal with the request
 	    if (RealFileExists(filename) == true)
 	    {
-- 
cgit v1.2.3


From e3c62328abbd548bb0da42fdbad954b3ce4f7102 Mon Sep 17 00:00:00 2001
From: David Kalnischkies <kalnischkies@gmail.com>
Date: Mon, 24 Jun 2013 16:34:38 +0200
Subject: simple fork and pidfile aptwebserver
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Forking only after being ready to accept clients avoids running races
with the tests which sometimes failed on the first 'apt-get update'
(or similar) with the previous background-start and hope for the best…

The commit fixes also some oversight output-order changes in regards to
Description-md5 and (I-M-S) race conditions in various tests.

Git-Dch: Ignore
---
 test/interactive-helper/aptwebserver.cc | 37 +++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

(limited to 'test/interactive-helper')

diff --git a/test/interactive-helper/aptwebserver.cc b/test/interactive-helper/aptwebserver.cc
index 05b875673..a8d191d0e 100644
--- a/test/interactive-helper/aptwebserver.cc
+++ b/test/interactive-helper/aptwebserver.cc
@@ -387,6 +387,41 @@ int main(int const argc, const char * argv[])
       return 2;
    }
 
+   FileFd pidfile;
+   if (_config->FindB("aptwebserver::fork", false) == true)
+   {
+      std::string const pidfilename = _config->Find("aptwebserver::pidfile", "aptwebserver.pid");
+      int const pidfilefd = GetLock(pidfilename);
+      if (pidfilefd < 0 || pidfile.OpenDescriptor(pidfilefd, FileFd::WriteOnly) == false)
+      {
+	 _error->Errno("aptwebserver", "Couldn't acquire lock on pidfile '%s'", pidfilename.c_str());
+	 _error->DumpErrors(std::cerr);
+	 return 3;
+      }
+
+      pid_t child = fork();
+      if (child < 0)
+      {
+	 _error->Errno("aptwebserver", "Forking failed");
+	 _error->DumpErrors(std::cerr);
+	 return 4;
+      }
+      else if (child != 0)
+      {
+	 // successfully forked: ready to serve!
+	 std::string pidcontent;
+	 strprintf(pidcontent, "%d", child);
+	 pidfile.Write(pidcontent.c_str(), pidcontent.size());
+	 if (_error->PendingError() == true)
+	 {
+	    _error->DumpErrors(std::cerr);
+	    return 5;
+	 }
+	 std::cout << "Successfully forked as " << child << std::endl;
+	 return 0;
+      }
+   }
+
    std::clog << "Serving ANY file on port: " << port << std::endl;
 
    listen(sock, 1);
@@ -502,5 +537,7 @@ int main(int const argc, const char * argv[])
 		<< " on socket " << sock << std::endl;
       close(client);
    }
+   pidfile.Close();
+
    return 0;
 }
-- 
cgit v1.2.3