Copied gpg.texi over from 1.4.5 and started to restructure it into a proper
[gnupg.git] / tests / asschk.c
index 666c637..40b95ba 100644 (file)
@@ -15,7 +15,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 /* This is a simple stand-alone Assuan server test program.  We don't
@@ -30,8 +31,8 @@
    a line is processed but after comment processing.  Macros are only
    expanded once and non existing macros expand to the empty string.
    A macro is dereferenced by prefixing its name with a dollar sign;
-   the end of the name is currently indicated by a white space.  To
-   use a dollor sign verbatim, double it.
+   the end of the name is currently indicated by a white space, a
+   dollar sign or a slash.  To use a dollor sign verbatim, double it.
 
    A macro is assigned by prefixing a statement with the macro name
    and an equal sign.  The value is assigned verbatim if it does not
    unambigiously and it should be used if the value starts with a
    letter.
 
-   The following commands are available:
+   Conditions are not yes implemented except for a simple evaluation
+   which yields false for an empty string or the string "0".  The
+   result may be negated by prefixing with a '!'.
 
-   [<name> =] let <value>
-      Assign VALUE to the macro named NAME.
+   The general syntax of a command is:
 
-   [<name> =] openfile <filename>
-      Open file FILENAME for read access and store the file descriptor
-      in NAME.
+   [<name> =] <statement> [<args>]
 
-   [<name> =] createfile <filename>
-      Create file FILENAME and open for write access, store the file
-      descriptor in NAME.
+   If NAME is not specifed but the statement returns a value it is
+   assigned to the name "?" so that it can be referenced using "$?".
+   The following commands are implemented:
 
-   pipeserver [<path>]
-      Connect to an Assuan server with name PATH.  If PATH is not
-      specified the value ../sm/gpgsm is used.
+   let <value>
+      Return VALUE.
+
+   echo <value>
+      Print VALUE.
+
+   openfile <filename>
+      Open file FILENAME for read access and return the file descriptor.
+
+   createfile <filename>
+      Create file FILENAME, open for write access and return the file
+      descriptor.
+
+   pipeserver <program>
+      Connect to the Assuan server PROGRAM.
 
    send <line>
       Send LINE to the server.
       Expect an ERR response from the server.  Status and data out put
       is ignored.
 
+   count-status <code>
+      Initialize the assigned variable to 0 and assign it as an counter for 
+      status code CODE.  This command must be called with an assignment.
+
    quit
-      Terminate the program
+      Terminate the process.
+
+   quit-if <condition>
+      Terminate the process if CONDITION evaluates to true.
 
+   fail-if <condition>
+      Terminate the process with an exit code of 1 if CONDITION
+      evaluates to true.
+
+   cmpfiles <first> <second>
+      Returns true when the content of the files FIRST and SECOND match.
+
+   getenv <name>
+      Return the value of the environment variable NAME.
 
 */
 
 #include <unistd.h>
 #include <fcntl.h>
 
-#define PGMNAME "asschk"
-
 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
 # define ATTR_PRINTF(f,a)  __attribute__ ((format (printf,f,a)))
 #else
 # define ATTR_PRINTF(f,a)
 #endif
 
+#if __STDC_VERSION__ < 199901L
+# if __GNUC__ >= 2
+#  define __func__ __FUNCTION__
+# else
+/* Let's try our luck here.  Some systems may provide __func__ without
+   providing __STDC_VERSION__ 199901L.  */
+#  if 0
+#   define __func__ "<unknown>"
+#  endif
+# endif
+#endif
+
 #define spacep(p) (*(p) == ' ' || *(p) == '\t')
 
+#define MAX_LINELEN 2048
+
 typedef enum {
   LINE_OK = 0,
   LINE_ERR,
@@ -101,19 +141,35 @@ typedef enum {
   LINE_END,
 } LINETYPE;
 
+typedef enum {
+  VARTYPE_SIMPLE = 0,
+  VARTYPE_FD,
+  VARTYPE_COUNTER
+} VARTYPE;
+
 
 struct variable_s {
   struct variable_s *next;
+  VARTYPE type;
+  unsigned int count;
   char *value;
   char name[1];
 };
 typedef struct variable_s *VARIABLE;
 
 
-
 static void die (const char *format, ...)  ATTR_PRINTF(1,2);
 
 
+/* Name of this program to be printed in error messages. */
+static const char *invocation_name;
+
+/* Talk a bit about what is going on. */
+static int opt_verbose;
+
+/* Option to ignore the echo command. */
+static int opt_no_echo;
+
 /* File descriptors used to communicate with the current server. */
 static int server_send_fd = -1;
 static int server_recv_fd = -1;
@@ -121,7 +177,7 @@ static int server_recv_fd = -1;
 /* The Assuan protocol limits the line length to 1024, so we can
    safely use a (larger) buffer.  The buffer is filled using the
    read_assuan(). */
-static char recv_line[2048];
+static char recv_line[MAX_LINELEN];
 /* Tell the status of the current line. */
 static LINETYPE recv_type;
 
@@ -135,7 +191,7 @@ die (const char *format, ...)
   va_list arg_ptr;
 
   fflush (stdout);
-  fprintf (stderr, "%s: ", PGMNAME);
+  fprintf (stderr, "%s: ", invocation_name);
 
   va_start (arg_ptr, format);
   vfprintf (stderr, format, arg_ptr);
@@ -145,6 +201,22 @@ die (const char *format, ...)
   exit (1);
 }
 
+#define die(format, args...) (die) ("%s: " format, __func__ , ##args)
+
+static void
+err (const char *format, ...)
+{
+  va_list arg_ptr;
+
+  fflush (stdout);
+  fprintf (stderr, "%s: ", invocation_name);
+
+  va_start (arg_ptr, format);
+  vfprintf (stderr, format, arg_ptr);
+  va_end (arg_ptr);
+  putc ('\n', stderr);
+}
+
 static void *
 xmalloc (size_t n)
 {
@@ -205,14 +277,36 @@ writen (int fd, const char *buffer, size_t length)
 static char *
 read_assuan (int fd)
 {
+  static char pending[MAX_LINELEN];
+  static size_t pending_len;
   size_t nleft = sizeof recv_line;
   char *buf = recv_line;
   char *p;
-  int nread = 0;
 
   while (nleft > 0)
     {
-      int n = read (fd, buf, nleft);
+      int n;
+
+      if (pending_len)
+        {
+          if (pending_len >= nleft)
+            die ("received line too large");
+          memcpy (buf, pending, pending_len);
+          n = pending_len;
+          pending_len = 0;
+        }
+      else
+        n = read (fd, buf, nleft);
+
+      if (opt_verbose)
+       {
+         int i;
+         printf ("%s: read \"", __FUNCTION__);
+         for (i = 0; i < n; i ++)
+           putc (buf[i], stdout);
+         printf ("\"\n");
+       }
+
       if (n < 0)
         {
           if (errno == EINTR)
@@ -224,21 +318,24 @@ read_assuan (int fd)
       p = buf;
       nleft -= n;
       buf += n;
-      nread += n;
       
       for (; n && *p != '\n'; n--, p++)
         ;
       if (n)
         {
-          /* fixme: keep pending bytes for next read. */
+          if (n>1)
+            {
+              n--;
+              memcpy (pending, p + 1, n);
+              pending_len = n;
+            }
+         *p = '\0';
           break;
         }
     }
   if (!nleft)
     die ("received line too large");
-  assert (nread>0);
-  recv_line[nread-1] = 0;
-  
+
   p = recv_line;
   if (p[0] == 'O' && p[1] == 'K' && (p[2] == ' ' || !p[2]))
     {
@@ -287,7 +384,8 @@ write_assuan (int fd, const char *line)
     buffer[n++] = '\n';
 
   if (writen (fd, buffer, n))
-      die ("sending line to %d failed: %s", fd, strerror (errno));
+      die ("sending line (\"%s\") to %d failed: %s", buffer, fd,
+          strerror (errno));
 }
 
 
@@ -318,7 +416,9 @@ start_server (const char *pgmname)
       const char *arg0;
 
       arg0 = strrchr (pgmname, '/');
-      if (!arg0)
+      if (arg0)
+        arg0++;
+      else
         arg0 = pgmname;
 
       if (wp[0] != STDIN_FILENO)
@@ -333,7 +433,18 @@ start_server (const char *pgmname)
               die ("dup2 failed in child: %s", strerror (errno));
           close (rp[1]);
         }
+      if (!opt_verbose)
+        {
+         int fd = open ("/dev/null", O_WRONLY);
+         if (fd == -1)
+           die ("can't open `/dev/null': %s", strerror (errno));
+          if (dup2 (fd, STDERR_FILENO) == -1)
+            die ("dup2 failed in child: %s", strerror (errno));
+         close (fd);
+        }
 
+      close (wp[1]);
+      close (rp[0]);
       execl (pgmname, arg0, "--server", NULL); 
       die ("exec failed for `%s': %s", pgmname, strerror (errno));
     }
@@ -362,18 +473,31 @@ unset_var (const char *name)
     ;
   if (!var)
     return;
-  fprintf (stderr, "unsetting `%s'\n", name);
+/*    fprintf (stderr, "unsetting `%s'\n", name); */
+
+  if (var->type == VARTYPE_FD && var->value)
+    {
+      int fd;
+
+      fd = atoi (var->value);
+      if (fd != -1 && fd != 0 && fd != 1 && fd != 2)
+          close (fd);
+    }
 
   free (var->value);
   var->value = NULL;
+  var->type = 0;
+  var->count = 0;
 }
 
 
 static void
-set_var (const char *name, const char *value)
+set_type_var (const char *name, const char *value, VARTYPE type)
 {
   VARIABLE var;
 
+  if (!name)
+    name = "?"; 
   for (var=variable_list; var && strcmp (var->name, name); var = var->next)
     ;
   if (!var)
@@ -386,11 +510,34 @@ set_var (const char *name, const char *value)
   else
     free (var->value);
 
-  var->value = xstrdup (value);
-  fprintf (stderr, "setting `%s' to `%s'\n", var->name, var->value);
+  if (var->type == VARTYPE_FD && var->value)
+    {
+      int fd;
+
+      fd = atoi (var->value);
+      if (fd != -1 && fd != 0 && fd != 1 && fd != 2)
+          close (fd);
+    }
+  
+  var->type = type;
+  var->count = 0;
+  if (var->type == VARTYPE_COUNTER)
+    {
+      /* We need some extra sapce as scratch area for get_var. */
+      var->value = xmalloc (strlen (value) + 1 + 20);
+      strcpy (var->value, value);
+    }
+  else
+    var->value = xstrdup (value);
+}
 
+static void
+set_var (const char *name, const char *value)
+{
+  set_type_var (name, value, 0);
 }
 
+
 static const char *
 get_var (const char *name)
 {
@@ -398,10 +545,35 @@ get_var (const char *name)
 
   for (var=variable_list; var && strcmp (var->name, name); var = var->next)
     ;
-  return var? var->value:NULL;
+  if (!var)
+    return NULL;
+  if (var->type == VARTYPE_COUNTER && var->value)
+    { /* Use the scratch space allocated by set_var. */
+      char *p = var->value + strlen(var->value)+1;
+      sprintf (p, "%u", var->count);
+      return p;
+    }
+  else
+    return var->value;
 }
 
 
+/* Incremente all counter type variables with NAME in their VALUE. */
+static void
+inc_counter (const char *name)
+{
+  VARIABLE var;
+
+  if (!*name)
+    return;
+  for (var=variable_list; var; var = var->next)
+    {
+      if (var->type == VARTYPE_COUNTER
+          && var->value && !strcmp (var->value, name))
+        var->count++;
+    }
+}
+
 
 /* Expand variables in LINE and return a new allocated buffer if
    required.  The function might modify LINE if the expanded version
@@ -427,7 +599,8 @@ expand_line (char *buffer)
           line = p + 1;
           continue;
         }
-      for (pend=p+1; *pend && !spacep (pend) && *pend != '$'; pend++)
+      for (pend=p+1; *pend && !spacep (pend)
+           && *pend != '$' && *pend != '/'; pend++)
         ;
       if (*pend)
         {
@@ -469,30 +642,76 @@ expand_line (char *buffer)
   return result;
 }
 
+
+/* Evaluate COND and return the result. */
+static int 
+eval_boolean (const char *cond)
+{
+  int true = 1;
+
+  for ( ; *cond == '!'; cond++)
+    true = !true;
+  if (!*cond || (*cond == '0' && !cond[1]))
+    return !true;
+  return true;
+}
+
+
+
+
+\f
 static void
 cmd_let (const char *assign_to, char *arg)
 {
-  if (!assign_to)
-    die ("syntax error: \"let\" needs an assignment");
   set_var (assign_to, arg);
 }
 
 
 static void
+cmd_echo (const char *assign_to, char *arg)
+{
+  if (!opt_no_echo)
+    printf ("%s\n", arg);
+}
+
+static void
 cmd_send (const char *assign_to, char *arg)
 {
-  fprintf (stderr, "sending `%s'\n", arg);
+  if (opt_verbose)
+    fprintf (stderr, "sending `%s'\n", arg);
   write_assuan (server_send_fd, arg); 
 }
 
 static void
+handle_status_line (char *arg)
+{
+  char *p;
+
+  for (p=arg; *p && !spacep (p); p++)
+    ;
+  if (*p)
+    {
+      int save = *p;
+      *p = 0;
+      inc_counter (arg);
+      *p = save;
+    }
+  else
+    inc_counter (arg);
+}
+
+static void
 cmd_expect_ok (const char *assign_to, char *arg)
 {
-  fprintf (stderr, "expecting OK\n");
+  if (opt_verbose)
+    fprintf (stderr, "expecting OK\n");
   do
     {
-      read_assuan (server_recv_fd);
-      fprintf (stderr, "got line `%s'\n", recv_line);
+      char *p = read_assuan (server_recv_fd);
+      if (opt_verbose > 1)
+        fprintf (stderr, "got line `%s'\n", recv_line);
+      if (recv_type == LINE_STAT)
+        handle_status_line (p);
     }
   while (recv_type != LINE_OK && recv_type != LINE_ERR);
   if (recv_type != LINE_OK)
@@ -502,10 +721,15 @@ cmd_expect_ok (const char *assign_to, char *arg)
 static void
 cmd_expect_err (const char *assign_to, char *arg)
 {
+  if (opt_verbose)
+    fprintf (stderr, "expecting ERR\n");
   do
     {
-      read_assuan (server_recv_fd);
-      fprintf (stderr, "got line `%s'\n", recv_line);
+      char *p = read_assuan (server_recv_fd);
+      if (opt_verbose > 1)
+        fprintf (stderr, "got line `%s'\n", recv_line);
+      if (recv_type == LINE_STAT)
+        handle_status_line (p);
     }
   while (recv_type != LINE_OK && recv_type != LINE_ERR);
   if (recv_type != LINE_ERR)
@@ -513,41 +737,55 @@ cmd_expect_err (const char *assign_to, char *arg)
 }
 
 static void
+cmd_count_status (const char *assign_to, char *arg)
+{
+  char *p;
+
+  if (!*assign_to || !*arg)
+    die ("syntax error: count-status requires an argument and a variable");
+
+  for (p=arg; *p && !spacep (p); p++)
+    ;
+  if (*p)
+    {
+      for (*p++ = 0; spacep (p); p++)
+        ;
+      if (*p)
+        die ("cmpfiles: syntax error");
+    }
+  set_type_var (assign_to, arg, VARTYPE_COUNTER);
+}
+
+static void
 cmd_openfile (const char *assign_to, char *arg)
 {
   int fd;
+  char numbuf[20];
 
   do 
     fd = open (arg, O_RDONLY);
   while (fd == -1 && errno == EINTR);
   if (fd == -1)
     die ("error opening `%s': %s", arg, strerror (errno));
-  if (assign_to)
-    {
-      char numbuf[20];
-
-      sprintf (numbuf, "%d", fd);
-      set_var (assign_to, numbuf);
-    }
+  
+  sprintf (numbuf, "%d", fd);
+  set_type_var (assign_to, numbuf, VARTYPE_FD);
 }
 
 static void
 cmd_createfile (const char *assign_to, char *arg)
 {
   int fd;
+  char numbuf[20];
 
   do 
     fd = open (arg, O_WRONLY|O_CREAT|O_TRUNC, 0666);
   while (fd == -1 && errno == EINTR);
   if (fd == -1)
     die ("error creating `%s': %s", arg, strerror (errno));
-  if (assign_to)
-    {
-      char numbuf[20];
 
-      sprintf (numbuf, "%d", fd);
-      set_var (assign_to, numbuf);
-    }
+  sprintf (numbuf, "%d", fd);
+  set_type_var (assign_to, numbuf, VARTYPE_FD);
 }
 
 
@@ -555,12 +793,107 @@ static void
 cmd_pipeserver (const char *assign_to, char *arg)
 {
   if (!*arg)
-    arg = "../sm/gpgsm";
+    die ("syntax error: servername missing");
 
   start_server (arg);
 }
 
 
+static void
+cmd_quit_if(const char *assign_to, char *arg)
+{
+  if (eval_boolean (arg))
+    exit (0);
+}
+
+static void
+cmd_fail_if(const char *assign_to, char *arg)
+{
+  if (eval_boolean (arg))
+    exit (1);
+}
+
+
+static void
+cmd_cmpfiles (const char *assign_to, char *arg)
+{
+  char *p = arg;
+  char *second;
+  FILE *fp1, *fp2;
+  char buffer1[2048]; /* note: both must be of equal size. */
+  char buffer2[2048];
+  size_t nread1, nread2;
+  int rc = 0;
+
+  set_var (assign_to, "0"); 
+  for (p=arg; *p && !spacep (p); p++)
+    ;
+  if (!*p)
+    die ("cmpfiles: syntax error");
+  for (*p++ = 0; spacep (p); p++)
+    ;
+  second = p;
+  for (; *p && !spacep (p); p++)
+    ;
+  if (*p)
+    {
+      for (*p++ = 0; spacep (p); p++)
+        ;
+      if (*p)
+        die ("cmpfiles: syntax error");
+    }
+  
+  fp1 = fopen (arg, "rb");
+  if (!fp1)
+    {
+      err ("can't open `%s': %s", arg, strerror (errno));
+      return;
+    }
+  fp2 = fopen (second, "rb");
+  if (!fp2)
+    {
+      err ("can't open `%s': %s", second, strerror (errno));
+      fclose (fp1);
+      return;
+    }
+  while ( (nread1 = fread (buffer1, 1, sizeof buffer1, fp1)))
+    {
+      if (ferror (fp1))
+        break;
+      nread2 = fread (buffer2, 1, sizeof buffer2, fp2);
+      if (ferror (fp2))
+        break;
+      if (nread1 != nread2 || memcmp (buffer1, buffer2, nread1))
+        {
+          rc = 1;
+          break;
+        }
+    }
+  if (feof (fp1) && feof (fp2) && !rc)
+    {
+      if (opt_verbose)
+        err ("files match");
+      set_var (assign_to, "1"); 
+    }
+  else if (!rc)
+    err ("cmpfiles: read error: %s", strerror (errno));
+  else
+    err ("cmpfiles: mismatch");
+  fclose (fp1);
+  fclose (fp2);
+}
+
+static void
+cmd_getenv (const char *assign_to, char *arg)
+{
+  const char *s;
+  s = *arg? getenv (arg):"";
+  set_var (assign_to, s? s:"");
+}
+
+
+
+\f
 /* Process the current script line LINE. */
 static int
 interpreter (char *line)
@@ -570,13 +903,19 @@ interpreter (char *line)
     void (*fnc)(const char*, char*);
   } cmdtbl[] = {
     { "let"       , cmd_let },
+    { "echo"      , cmd_echo },
     { "send"      , cmd_send },
     { "expect-ok" , cmd_expect_ok },
     { "expect-err", cmd_expect_err },
+    { "count-status", cmd_count_status },
     { "openfile"  , cmd_openfile },
     { "createfile", cmd_createfile },
     { "pipeserver", cmd_pipeserver },
     { "quit"      , NULL },
+    { "quit-if"   , cmd_quit_if },
+    { "fail-if"   , cmd_fail_if },
+    { "cmpfiles"  , cmd_cmpfiles },
+    { "getenv"    , cmd_getenv },
     { NULL }
   };
   char *p, *save_p;
@@ -602,7 +941,6 @@ interpreter (char *line)
           return 0; /* empty or comment */
         }
     }
-
   for (p=line; *p && !spacep (p) && *p != '='; p++)
     ;
   if (*p == '=')
@@ -667,14 +1005,58 @@ interpreter (char *line)
 int
 main (int argc, char **argv)
 {
-  char buffer[1025];
-  char *p;
+  char buffer[2048];
+  char *p, *pend;
 
+  if (!argc)
+    invocation_name = "asschk";
+  else
+    {
+      invocation_name = *argv++;
+      argc--;
+      p = strrchr (invocation_name, '/');
+      if (p)
+        invocation_name = p+1;
+    }
+
+
+  set_var ("?","1"); /* defaults to true */
+
+  for (; argc; argc--, argv++)
+    {
+      p = *argv;
+      if (*p != '-')
+        break;
+      if (!strcmp (p, "--verbose"))
+        opt_verbose++;
+      else if (!strcmp (p, "--no-echo"))
+        opt_no_echo++;
+      else if (*p == '-' && p[1] == 'D')
+        {
+          p += 2;
+          pend = strchr (p, '=');
+          if (pend)
+            {
+              int tmp = *pend;
+              *pend = 0;
+              set_var (p, pend+1);
+              *pend = tmp;
+            }
+          else
+            set_var (p, "1");
+        }
+      else if (*p == '-' && p[1] == '-' && !p[2])
+        {
+          argc--; argv++;
+          break;
+        }
+      else
+        break;
+    }
   if (argc)
-    argv++, argc--;
-  if (argc)
-    die ("usage: asschk <script");
-  
+    die ("usage: asschk [--verbose] {-D<name>[=<value>]}");
+
+
   while (fgets (buffer, sizeof buffer, stdin))
     {
       p = strchr (buffer,'\n');
@@ -687,3 +1069,4 @@ main (int argc, char **argv)
     }
   return 0;
 }
+