Enable test cases to provide sections base64-encoded to be able to test

with binary data.

tests/FILEFORMAT

@@ -14,7 +14,7 @@ specified, that will be checked/used if specified. This document includes all
 the subsections currently supported.
 
 <reply>
-<data [nocheck=1] [sendzero=yes]>
+<data [nocheck=1] [sendzero=yes] [base64=yes]>
 §data to sent to the client on its request and later verified that it arrived
 safely. Set the nocheck=1 to prevent the test script to verify the arrival
 of this data.
@@ -31,6 +31,11 @@ for auth tests and similar.
 'sendzero' set to yes means that the (FTP) server will "send" the data even if
 the size is zero bytes. Used to verify curl's behaviour on zero bytes
 transfers.
+
+'base64' set to yes means that the data provided in the test-file is a chunk
+of data encoded with base64. It is the only way a test case can contain binary
+data. (This attribute can in fact be used on any section, but it doesn't make
+much sense for other sections than "data").
 </data>
 <dataNUM>
 Send back this contents instead of the <data> one. The num is set by:

tests/getpart.pm

@@ -56,6 +56,7 @@ sub getpart {
 
     my @this;
     my $inside=0;
+    my $base64=0;
 
  #   print "Section: $section, part: $part\n";
 
@@ -65,6 +66,10 @@ sub getpart {
             $inside++;
         }
         elsif((1 ==$inside) && ($_ =~ /^ *\<$part[ \>]/)) {
+            if($_ =~ /$part .*base64=/) {
+                # attempt to detect base64 encoded parts
+                $base64=1;
+            }
             $inside++;
         }
         elsif((2 ==$inside) && ($_ =~ /^ *\<\/$part/)) {
@@ -77,6 +82,13 @@ sub getpart {
             if(!@this && $warning) {
                 print STDERR "*** getpart.pm: $section/$part returned empty!\n";
             }
+            if($base64) {
+                # decode the whole array before returning it!
+                for(@this) {
+                    my $decoded = decode_base64($_);
+                    $_ = $decoded;
+                }
+            }
             return @this;
         }
         elsif(2==$inside) {
@@ -138,16 +150,31 @@ sub compareparts {
  my $sizefirst=scalar(@$firstref);
  my $sizesecond=scalar(@$secondref);
 
+ my $first;
+ my $second;
+
  for(1 .. $sizefirst) {
      my $index = $_ - 1;
      if($firstref->[$index] ne $secondref->[$index]) {
          (my $aa = $firstref->[$index]) =~ s/\r+\n$/\n/;
          (my $bb = $secondref->[$index]) =~ s/\r+\n$/\n/;
-         if($aa ne $bb) {
+         
-             return 1+$index;
+         $first .= $firstref->[$index];
-         }
+         $second .= $secondref->[$index];
      }
  }
+
+ # we cannot compare arrays index per index since with the base64 chunks,
+ # they may not be "evenly" distributed
+
+ # NOTE: this no longer strips off carriage returns from the arrays. Is that
+ # really necessary? It ruins the testing of newlines. I believe it was once
+ # added to enable tests on win32.
+
+ if($first ne $second) {
+     return 1;
+ }
+
  return 0;
 }
 

tests/runtests.pl

@@ -23,6 +23,7 @@
 ###########################################################################
 # These should be the only variables that might be needed to get edited:
 
+use MIME::Base64;
 use strict;
 #use warnings;
 

tests/server/Makefile.am

@@ -29,9 +29,16 @@ AUTOMAKE_OPTIONS = foreign
 
 INCLUDES = -I$(top_srcdir)/lib -I$(top_srcdir)/include
 
-noinst_PROGRAMS = sws
+noinst_PROGRAMS = sws getpart
 
-sws_SOURCES= sws.c getpart.c getpart.h $(top_srcdir)/lib/strequal.c
+sws_SOURCES= sws.c getpart.c getpart.h $(top_srcdir)/lib/strequal.c	\
+ $(top_srcdir)/lib/base64.c $(top_srcdir)/lib/mprintf.c			\
+ $(top_srcdir)/lib/memdebug.c
 
-extra_DIST = config.h.in
+extra_DIST = base64.pl
 
+getpart_CPPFLAGS = -DGETPART_TEST
+
+getpart_SOURCES= getpart.c getpart.h $(top_srcdir)/lib/strequal.c	\
+ $(top_srcdir)/lib/base64.c $(top_srcdir)/lib/mprintf.c			\
+ $(top_srcdir)/lib/memdebug.c

tests/server/getpart.c

@@ -27,6 +27,14 @@
 #include <stdlib.h>
 #include "getpart.h"
 
+#define _MPRINTF_REPLACE /* use our functions only */
+#include <curl/mprintf.h>
+
+#include "base64.h"
+
+/* include memdebug.h last */
+#include "memdebug.h"
+
 #define EAT_SPACE(ptr) while( ptr && *ptr && isspace((int)*ptr) ) ptr++
 #define EAT_WORD(ptr) while( ptr && *ptr && !isspace((int)*ptr) && ('>' != *ptr)) ptr++
 
@@ -36,14 +44,29 @@
 #define show(x)
 #endif
 
+curl_malloc_callback Curl_cmalloc = (curl_malloc_callback)malloc;
+curl_free_callback Curl_cfree = (curl_free_callback)free;
+curl_realloc_callback Curl_crealloc = (curl_realloc_callback)realloc;
+curl_strdup_callback Curl_cstrdup = (curl_strdup_callback)strdup;
+curl_calloc_callback Curl_ccalloc = (curl_calloc_callback)calloc;
+
 static
 char *appendstring(char *string, /* original string */
                    char *buffer, /* to append */
                    size_t *stringlen, /* length of string */
-                   size_t *stralloc)  /* allocated size */
+                   size_t *stralloc,  /* allocated size */
+                   char base64) /* 1 if base64 encoded */
 {
   size_t len = strlen(buffer);
   size_t needed_len = len + *stringlen;
+  char buf64[256]; /* big enough? */
+
+  if(base64) {
+    /* decode the given buffer first */
+    len = Curl_base64_decode(buffer, buf64); /* updated len */
+    buffer = buf64;
+    needed_len = len + *stringlen; /* recalculate */
+  }
 
   if(needed_len >= *stralloc) {
     char *newptr;
@@ -57,7 +80,8 @@ char *appendstring(char *string, /* original string */
     else
       return NULL;
   }
-  strcpy(&string[*stringlen], buffer);
+  /* memcpy to support binary blobs */
+  memcpy(&string[*stringlen], buffer, len);
   *stringlen += len;
 
   return string;
@@ -77,6 +101,7 @@ const char *spitout(FILE *stream,
   char *string;
   size_t stringlen=0;
   size_t stralloc=256;
+  char base64 = 0; /* set to 1 if true */
 
   enum {
     STATE_OUTSIDE,
@@ -101,7 +126,7 @@ const char *spitout(FILE *stream,
     if('<' != *ptr) {
       if(display) {
         show(("=> %s", buffer));
-        string = appendstring(string, buffer, &stringlen, &stralloc);
+        string = appendstring(string, buffer, &stringlen, &stralloc, base64);
         show(("* %s\n", buffer));
       }
       continue;
@@ -152,9 +177,19 @@ const char *spitout(FILE *stream,
       default:
         break;
       }
+
+      if(!end[1] != '>') {
+        /* There might be attributes here. Check for those we know of and care
+           about. */
+        if(strstr(&end[1], "base64=")) {
+          /* rought and dirty, but "mostly" functional */
+          /* Treat all data as base64 encoded */
+          base64 = 1;
+        }
+      }
     }
     if(display) {
-      string = appendstring(string, buffer, &stringlen, &stralloc);
+      string = appendstring(string, buffer, &stringlen, &stralloc, base64);
       show(("* %s\n", buffer));
     }
 
@@ -174,15 +209,16 @@ const char *spitout(FILE *stream,
   return string;
 }
 
-#ifdef TEST
+#ifdef GETPART_TEST
 int main(int argc, char **argv)
 {
   if(argc< 3) {
     printf("./moo main sub\n");
   }
   else {
-    int size;
+    size_t size;
-    char *buffer = spitout(stdin, argv[1], argv[2], &size);
+    const char *buffer = spitout(stdin, argv[1], argv[2], &size);
+    printf("%s", buffer);
   }
   return 0;
 }

tests/server/sws.c

@@ -81,6 +81,9 @@
 static void win32_cleanup(void);
 #endif
 
+/* include memdebug.h last */
+#include "memdebug.h"
+
 #define REQBUFSIZ 150000
 #define REQBUFSIZ_TXT "149999"