Initial revision

diff --git a/src/rxkad/fc_test.c b/src/rxkad/fc_test.c
new file mode 100644 (file)
index 0000000..ba3ebc4
--- /dev/null
+++ b/src/rxkad/fc_test.c
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 1995 - 2000, 2002 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <afs/param.h>
+#include "rxkad.h"
+#include <rx/rx.h>
+#include "private_data.h"
+
+#define ROUNDS 16
+#define ENCRYPT 1
+#define DECRYPT 0
+
+typedef afs_int32 int32;
+typedef afs_uint32 u_int32;
+
+#include <stdio.h>
+#include <string.h>
+
+#include <time.h>
+
+const char the_quick[] = "The quick brown fox jumps over the lazy dogs.\0\0";
+
+const unsigned char key1[8]={0xf0,0xe1,0xd2,0xc3,0xb4,0xa5,0x96,0x87};
+const char ciph1[] = {
+  0x00, 0xf0, 0xe,  0x11, 0x75, 0xe6, 0x23, 0x82, 0xee, 0xac, 0x98, 0x62,
+  0x44, 0x51, 0xe4, 0x84, 0xc3, 0x59, 0xd8, 0xaa, 0x64, 0x60, 0xae, 0xf7,
+  0xd2, 0xd9, 0x13, 0x79, 0x72, 0xa3, 0x45, 0x03, 0x23, 0xb5, 0x62, 0xd7,
+  0xc,  0xf5, 0x27, 0xd1, 0xf8, 0x91, 0x3c, 0xac, 0x44, 0x22, 0x92, 0xef };
+
+const unsigned char key2[8]={0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
+const char ciph2[] = {
+  0xca, 0x90, 0xf5, 0x9d, 0xcb, 0xd4, 0xd2, 0x3c, 0x01, 0x88, 0x7f, 0x3e,
+  0x31, 0x6e, 0x62, 0x9d, 0xd8, 0xe0, 0x57, 0xa3, 0x06, 0x3a, 0x42, 0x58,
+  0x2a, 0x28, 0xfe, 0x72, 0x52, 0x2f, 0xdd, 0xe0, 0x19, 0x89, 0x09, 0x1c,
+  0x2a, 0x8e, 0x8c, 0x94, 0xfc, 0xc7, 0x68, 0xe4, 0x88, 0xaa, 0xde, 0x0f };
+
+#ifdef TEST_KERNEL
+#define fc_keysched    _afs_QTKrFdpoFL
+#define fc_ecb_encrypt _afs_sDLThwNLok
+#define fc_cbc_encrypt _afs_fkyCWTvfRS
+#define rxkad_DecryptPacket _afs_SRWEeqTXrS
+#define rxkad_EncryptPacket _afs_bpwQbdoghO
+#endif
+
+int
+main()
+{
+  int32 sched[ROUNDS];
+  char ciph[100], clear[100];
+  u_int32 data[2];
+  u_int32 iv[2];
+  struct rx_connection conn;
+  struct rx_securityClass obj;
+  struct rxkad_cprivate cpriv;
+  struct rx_packet packet;
+  int fail = 0;
+
+  conn.securityObject = &obj;
+  obj.privateData = (void *)&cpriv;
+  cpriv.type = 0;
+
+  if (sizeof(int32) != 4) {
+    fprintf(stderr, "error: sizeof(int32) != 4\n");
+    fail++;
+  }
+  if (sizeof(u_int32) != 4) {
+    fprintf(stderr, "error: sizeof(u_int32) != 4\n");
+    fail++;
+  }
+
+  /*
+   * Use key1 and key2 as iv */
+  fc_keysched(key1, sched);
+  memcpy(iv, key2, sizeof(iv));
+  fc_cbc_encrypt(the_quick, ciph, sizeof(the_quick), sched, iv, ENCRYPT);
+  if (memcmp(ciph1, ciph, sizeof(ciph1)) != 0) {
+    fprintf(stderr, "encrypt FAILED\n");
+    fail++;
+  }
+  memcpy(iv, key2, sizeof(iv));
+  fc_cbc_encrypt(ciph, clear, sizeof(the_quick), sched, iv, DECRYPT);
+  if (strcmp(the_quick, clear) != 0) {
+    fprintf(stderr, "crypt decrypt FAILED\n");
+    fail++;
+  }
+
+  /*
+   * Use key2 and key1 as iv
+   */
+  fc_keysched(key2, sched);
+  memcpy(iv, key1, sizeof(iv));
+  fc_cbc_encrypt(the_quick, ciph, sizeof(the_quick), sched, iv, ENCRYPT);
+  if (memcmp(ciph2, ciph, sizeof(ciph2)) != 0) {
+    fprintf(stderr, "encrypt FAILED\n");
+    fail++;
+  }
+  memcpy(iv, key1, sizeof(iv));
+  fc_cbc_encrypt(ciph, clear, sizeof(the_quick), sched, iv, DECRYPT);
+  if (strcmp(the_quick, clear) != 0) {
+    fprintf(stderr, "crypt decrypt FAILED\n");
+    fail++;
+  }
+
+  /*
+   * Test Encrypt- and Decrypt-Packet, use key1 and key2 as iv
+   */
+  fc_keysched(key1, sched);
+  memcpy(iv, key2, sizeof(iv));
+  strcpy(clear, the_quick);
+  packet.wirevec[1].iov_base = clear;
+  packet.wirevec[1].iov_len = sizeof(the_quick);
+  packet.wirevec[2].iov_len = 0;
+
+  /* For unknown reasons bytes 4-7 are zeroed in rxkad_EncryptPacket */
+  rxkad_EncryptPacket(&conn, sched, iv, sizeof(the_quick), &packet);
+  rxkad_DecryptPacket(&conn, sched, iv, sizeof(the_quick), &packet);
+  clear[4] ^= 'q';
+  clear[5] ^= 'u';
+  clear[6] ^= 'i';
+  clear[7] ^= 'c';
+  if (strcmp(the_quick, clear) != 0)
+    fprintf(stderr, "rxkad_EncryptPacket/rxkad_DecryptPacket FAILED\n");
+
+  {
+    struct timeval start, stop;
+    int i;
+    
+    fc_keysched(key1, sched);
+    gettimeofday(&start, 0);
+    for (i = 0; i < 1000000; i++)
+      fc_keysched(key1, sched);
+    gettimeofday(&stop, 0);
+    printf("fc_keysched    = %2.2f us\n",
+          (stop.tv_sec - start.tv_sec
+           + (stop.tv_usec - start.tv_usec)/1e6)*1);
+          
+    fc_ecb_encrypt(data, data, sched, ENCRYPT);
+    gettimeofday(&start, 0);
+    for (i = 0; i < 1000000; i++)
+      fc_ecb_encrypt(data, data, sched, ENCRYPT);
+    gettimeofday(&stop, 0);
+    printf("fc_ecb_encrypt = %2.2f us\n",
+          (stop.tv_sec - start.tv_sec
+           + (stop.tv_usec - start.tv_usec)/1e6)*1);
+          
+    fc_cbc_encrypt(the_quick, ciph, sizeof(the_quick), sched, iv, ENCRYPT);
+    gettimeofday(&start, 0);
+    for (i = 0; i < 100000; i++)
+      fc_cbc_encrypt(the_quick, ciph, sizeof(the_quick), sched, iv, ENCRYPT);
+    gettimeofday(&stop, 0);
+    printf("fc_cbc_encrypt = %2.2f us\n",
+          (stop.tv_sec - start.tv_sec
+           + (stop.tv_usec - start.tv_usec)/1e6)*10);
+          
+  }
+
+  exit(fail);
+}

diff --git a/src/tests/KeyFile b/src/tests/KeyFile
new file mode 100644 (file)
index 0000000..a441634
Binary files /dev/null and b/src/tests/KeyFile differ

diff --git a/src/tests/OpenAFS/Auth-Kaserver.pm b/src/tests/OpenAFS/Auth-Kaserver.pm
new file mode 100644 (file)
index 0000000..0055737
--- /dev/null
+++ b/src/tests/OpenAFS/Auth-Kaserver.pm
@@ -0,0 +1,44 @@
+# This is -*- perl -*-
+
+package OpenAFS::Auth;
+use OpenAFS::Dirpath;
+
+use strict;
+#use vars qw( @ISA @EXPORT );
+#@ISA = qw(Exporter);
+#require Exporter;
+#@EXPORT = qw($openafs-authadmin $openafs-authuser);
+
+sub getcell {
+    my($cell);
+    open(CELL, "$openafsdirpath->{'afsconfdir'}/ThisCell") 
+       or die "Cannot open $openafsdirpath->{'afsconfdir'}/ThisCell: $!\n";
+    $cell = <CELL>;
+    chomp $cell;
+    close CELL;
+    return $cell;
+}
+
+sub getrealm {
+    my($cell);
+    open(CELL, "$openafsdirpath->{'afsconfdir'}/ThisCell") 
+       or die "Cannot open $openafsdirpath->{'afsconfdir'}/ThisCell: $!\n";
+    $cell = <CELL>;
+    chomp $cell;
+    close CELL;
+    $cell =~ tr/a-z/A-Z/;
+    return $cell;
+}
+
+sub authadmin {
+    my $cell = &getrealm;
+    my $cmd = "echo \"Proceeding w/o authentication\"|klog -pipe admin\@${cell}";
+    system($cmd);
+}
+sub authuser {
+    my $cell = &getrealm;
+    my $cmd = "echo \"Proceeding w/o authentication\"|klog -pipe user\@${cell}";
+    system($cmd);
+}
+
+1;

diff --git a/src/tests/kaserver.DB0 b/src/tests/kaserver.DB0
new file mode 100644 (file)
index 0000000..d8edd37
Binary files /dev/null and b/src/tests/kaserver.DB0 differ

diff --git a/src/tests/kaserver.DBSYS1 b/src/tests/kaserver.DBSYS1
new file mode 100644 (file)
index 0000000..9017fd9
Binary files /dev/null and b/src/tests/kaserver.DBSYS1 differ

diff --git a/src/tests/snprintf.c b/src/tests/snprintf.c
new file mode 100644 (file)
index 0000000..45c2a79
--- /dev/null
+++ b/src/tests/snprintf.c
@@ -0,0 +1,628 @@
+/*
+ * Copyright (c) 1995-2000 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: snprintf.c,v 1.1 2002/05/11 00:02:31 hartmans Exp $");
+#endif
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifndef min
+#define min(a, b)               ((a) > (b) ? (b) : (a))
+#endif
+#ifndef max
+#define max(a, b)               ((a) < (b) ? (b) : (a))
+#endif
+
+enum format_flags {
+    minus_flag     =  1,
+    plus_flag      =  2,
+    space_flag     =  4,
+    alternate_flag =  8,
+    zero_flag      = 16
+};
+
+/*
+ * Common state
+ */
+
+struct state {
+  unsigned char *str;
+  unsigned char *s;
+  unsigned char *theend;
+  size_t sz;
+  size_t max_sz;
+  int (*append_char)(struct state *, unsigned char);
+  int (*reserve)(struct state *, size_t);
+  /* XXX - methods */
+};
+
+#ifndef HAVE_VSNPRINTF
+static int
+sn_reserve (struct state *state, size_t n)
+{
+  return state->s + n > state->theend;
+}
+
+static int
+sn_append_char (struct state *state, unsigned char c)
+{
+  if (sn_reserve (state, 1)) {
+    return 1;
+  } else {
+    *state->s++ = c;
+    return 0;
+  }
+}
+#endif
+
+static int
+as_reserve (struct state *state, size_t n)
+{
+  if (state->s + n > state->theend) {
+    int off = state->s - state->str;
+    unsigned char *tmp;
+
+    if (state->max_sz && state->sz >= state->max_sz)
+      return 1;
+
+    state->sz = max(state->sz * 2, state->sz + n);
+    if (state->max_sz)
+      state->sz = min(state->sz, state->max_sz);
+    tmp = realloc (state->str, state->sz);
+    if (tmp == NULL)
+      return 1;
+    state->str = tmp;
+    state->s = state->str + off;
+    state->theend = state->str + state->sz - 1;
+  }
+  return 0;
+}
+
+static int
+as_append_char (struct state *state, unsigned char c)
+{
+  if(as_reserve (state, 1))
+    return 1;
+  else {
+    *state->s++ = c;
+    return 0;
+  }
+}
+
+static int
+append_number(struct state *state,
+             unsigned long num, unsigned base, char *rep,
+             int width, int prec, int flags, int minusp)
+{
+  int len = 0;
+  int i;
+
+  /* given precision, ignore zero flag */
+  if(prec != -1)
+    flags &= ~zero_flag;
+  else
+    prec = 1;
+  /* zero value with zero precision -> "" */
+  if(prec == 0 && num == 0)
+    return 0;
+  do{
+    if((*state->append_char)(state, rep[num % base]))
+      return 1;
+    len++;
+    num /= base;
+  }while(num);
+  prec -= len;
+  /* pad with prec zeros */
+  while(prec-- > 0){
+    if((*state->append_char)(state, '0'))
+      return 1;
+    len++;
+  }
+  /* add length of alternate prefix (added later) to len */
+  if(flags & alternate_flag && (base == 16 || base == 8))
+    len += base / 8;
+  /* pad with zeros */
+  if(flags & zero_flag){
+    width -= len;
+    if(minusp || (flags & space_flag) || (flags & plus_flag))
+      width--;
+    while(width-- > 0){
+      if((*state->append_char)(state, '0'))
+       return 1;
+      len++;
+    }
+  }
+  /* add alternate prefix */
+  if(flags & alternate_flag && (base == 16 || base == 8)){
+    if(base == 16)
+      if((*state->append_char)(state, rep[10] + 23)) /* XXX */
+       return 1;
+    if((*state->append_char)(state, '0'))
+      return 1;
+  }
+  /* add sign */
+  if(minusp){
+    if((*state->append_char)(state, '-'))
+      return 1;
+    len++;
+  } else if(flags & plus_flag) {
+    if((*state->append_char)(state, '+'))
+      return 1;
+    len++;
+  } else if(flags & space_flag) {
+    if((*state->append_char)(state, ' '))
+      return 1;
+    len++;
+  }
+  if(flags & minus_flag)
+    /* swap before padding with spaces */
+    for(i = 0; i < len / 2; i++){
+      char c = state->s[-i-1];
+      state->s[-i-1] = state->s[-len+i];
+      state->s[-len+i] = c;
+    }
+  width -= len;
+  while(width-- > 0){
+    if((*state->append_char)(state,  ' '))
+      return 1;
+    len++;
+  }
+  if(!(flags & minus_flag))
+    /* swap after padding with spaces */
+    for(i = 0; i < len / 2; i++){
+      char c = state->s[-i-1];
+      state->s[-i-1] = state->s[-len+i];
+      state->s[-len+i] = c;
+    }
+    
+  return 0;
+}
+
+static int
+append_string (struct state *state,
+              unsigned char *arg,
+              int width,
+              int prec,
+              int flags)
+{
+    if(arg == NULL)
+       arg = (unsigned char*)"(null)";
+
+    if(prec != -1)
+       width -= prec;
+    else
+       width -= strlen((char *)arg);
+    if(!(flags & minus_flag))
+       while(width-- > 0)
+           if((*state->append_char) (state, ' '))
+               return 1;
+    if (prec != -1) {
+       while (*arg && prec--)
+           if ((*state->append_char) (state, *arg++))
+               return 1;
+    } else {
+       while (*arg)
+           if ((*state->append_char) (state, *arg++))
+               return 1;
+    }
+    if(flags & minus_flag)
+       while(width-- > 0)
+           if((*state->append_char) (state, ' '))
+               return 1;
+    return 0;
+}
+
+static int
+append_char(struct state *state,
+           unsigned char arg,
+           int width,
+           int flags)
+{
+  while(!(flags & minus_flag) && --width > 0)
+    if((*state->append_char) (state, ' '))
+      return 1;
+    
+  if((*state->append_char) (state, arg))
+    return 1;
+  while((flags & minus_flag) && --width > 0)
+    if((*state->append_char) (state, ' '))
+      return 1;
+    
+  return 0;
+}
+
+/*
+ * This can't be made into a function...
+ */
+
+#define PARSE_INT_FORMAT(res, arg, unsig) \
+if (long_flag) \
+     res = (unsig long)va_arg(arg, unsig long); \
+else if (short_flag) \
+     res = (unsig short)va_arg(arg, unsig int); \
+else \
+     res = (unsig int)va_arg(arg, unsig int)
+
+/*
+ * zyxprintf - return 0 or -1
+ */
+
+static int
+xyzprintf (struct state *state, const char *char_format, va_list ap)
+{
+  const unsigned char *format = (const unsigned char *)char_format;
+  unsigned char c;
+
+  while((c = *format++)) {
+    if (c == '%') {
+      int flags      = 0;
+      int width      = 0;
+      int prec       = -1;
+      int long_flag  = 0;
+      int short_flag = 0;
+
+      /* flags */
+      while((c = *format++)){
+       if(c == '-')
+         flags |= minus_flag;
+       else if(c == '+')
+         flags |= plus_flag;
+       else if(c == ' ')
+         flags |= space_flag;
+       else if(c == '#')
+         flags |= alternate_flag;
+       else if(c == '0')
+         flags |= zero_flag;
+       else
+         break;
+      }
+      
+      if((flags & space_flag) && (flags & plus_flag))
+       flags ^= space_flag;
+
+      if((flags & minus_flag) && (flags & zero_flag))
+       flags ^= zero_flag;
+
+      /* width */
+      if (isdigit(c))
+       do {
+         width = width * 10 + c - '0';
+         c = *format++;
+       } while(isdigit(c));
+      else if(c == '*') {
+       width = va_arg(ap, int);
+       c = *format++;
+      }
+
+      /* precision */
+      if (c == '.') {
+       prec = 0;
+       c = *format++;
+       if (isdigit(c))
+         do {
+           prec = prec * 10 + c - '0';
+           c = *format++;
+         } while(isdigit(c));
+       else if (c == '*') {
+         prec = va_arg(ap, int);
+         c = *format++;
+       }
+      }
+
+      /* size */
+
+      if (c == 'h') {
+       short_flag = 1;
+       c = *format++;
+      } else if (c == 'l') {
+       long_flag = 1;
+       c = *format++;
+      }
+
+      switch (c) {
+      case 'c' :
+       if(append_char(state, va_arg(ap, int), width, flags))
+         return -1;
+       break;
+      case 's' :
+       if (append_string(state,
+                         va_arg(ap, unsigned char*),
+                         width,
+                         prec, 
+                         flags))
+         return -1;
+       break;
+      case 'd' :
+      case 'i' : {
+       long arg;
+       unsigned long num;
+       int minusp = 0;
+
+       PARSE_INT_FORMAT(arg, ap, signed);
+
+       if (arg < 0) {
+         minusp = 1;
+         num = -arg;
+       } else
+         num = arg;
+
+       if (append_number (state, num, 10, "0123456789",
+                          width, prec, flags, minusp))
+         return -1;
+       break;
+      }
+      case 'u' : {
+       unsigned long arg;
+
+       PARSE_INT_FORMAT(arg, ap, unsigned);
+
+       if (append_number (state, arg, 10, "0123456789",
+                          width, prec, flags, 0))
+         return -1;
+       break;
+      }
+      case 'o' : {
+       unsigned long arg;
+
+       PARSE_INT_FORMAT(arg, ap, unsigned);
+
+       if (append_number (state, arg, 010, "01234567",
+                          width, prec, flags, 0))
+         return -1;
+       break;
+      }
+      case 'x' : {
+       unsigned long arg;
+
+       PARSE_INT_FORMAT(arg, ap, unsigned);
+
+       if (append_number (state, arg, 0x10, "0123456789abcdef",
+                          width, prec, flags, 0))
+         return -1;
+       break;
+      }
+      case 'X' :{
+       unsigned long arg;
+
+       PARSE_INT_FORMAT(arg, ap, unsigned);
+
+       if (append_number (state, arg, 0x10, "0123456789ABCDEF",
+                          width, prec, flags, 0))
+         return -1;
+       break;
+      }
+      case 'p' : {
+       unsigned long arg = (unsigned long)va_arg(ap, void*);
+
+       if (append_number (state, arg, 0x10, "0123456789ABCDEF",
+                          width, prec, flags, 0))
+         return -1;
+       break;
+      }
+      case 'n' : {
+       int *arg = va_arg(ap, int*);
+       *arg = state->s - state->str;
+       break;
+      }
+      case '\0' :
+         --format;
+         /* FALLTHROUGH */
+      case '%' :
+       if ((*state->append_char)(state, c))
+         return -1;
+       break;
+      default :
+       if (   (*state->append_char)(state, '%')
+           || (*state->append_char)(state, c))
+         return -1;
+       break;
+      }
+    } else
+      if ((*state->append_char) (state, c))
+       return -1;
+  }
+  return 0;
+}
+
+#ifndef HAVE_SNPRINTF
+int
+snprintf (char *str, size_t sz, const char *format, ...)
+{
+  va_list args;
+  int ret;
+
+  va_start(args, format);
+  ret = vsnprintf (str, sz, format, args);
+
+#ifdef PARANOIA
+  {
+    int ret2;
+    char *tmp;
+
+    tmp = malloc (sz);
+    if (tmp == NULL)
+      abort ();
+
+    ret2 = vsprintf (tmp, format, args);
+    if (ret != ret2 || strcmp(str, tmp))
+      abort ();
+    free (tmp);
+  }
+#endif
+
+  va_end(args);
+  return ret;
+}
+#endif
+
+#ifndef HAVE_ASPRINTF
+int
+asprintf (char **ret, const char *format, ...)
+{
+  va_list args;
+  int val;
+
+  va_start(args, format);
+  val = vasprintf (ret, format, args);
+
+#ifdef PARANOIA
+  {
+    int ret2;
+    char *tmp;
+    tmp = malloc (val + 1);
+    if (tmp == NULL)
+      abort ();
+
+    ret2 = vsprintf (tmp, format, args);
+    if (val != ret2 || strcmp(*ret, tmp))
+      abort ();
+    free (tmp);
+  }
+#endif
+
+  va_end(args);
+  return val;
+}
+#endif
+
+#ifndef HAVE_ASNPRINTF
+int
+asnprintf (char **ret, size_t max_sz, const char *format, ...)
+{
+  va_list args;
+  int val;
+
+  va_start(args, format);
+  val = vasnprintf (ret, max_sz, format, args);
+
+#ifdef PARANOIA
+  {
+    int ret2;
+    char *tmp;
+    tmp = malloc (val + 1);
+    if (tmp == NULL)
+      abort ();
+
+    ret2 = vsprintf (tmp, format, args);
+    if (val != ret2 || strcmp(*ret, tmp))
+      abort ();
+    free (tmp);
+  }
+#endif
+
+  va_end(args);
+  return val;
+}
+#endif
+
+#ifndef HAVE_VASPRINTF
+int
+vasprintf (char **ret, const char *format, va_list args)
+{
+  return vasnprintf (ret, 0, format, args);
+}
+#endif
+
+
+#ifndef HAVE_VASNPRINTF
+int
+vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
+{
+  int st;
+  size_t len;
+  struct state state;
+
+  state.max_sz = max_sz;
+  state.sz     = 1;
+  state.str    = malloc(state.sz);
+  if (state.str == NULL) {
+    *ret = NULL;
+    return -1;
+  }
+  state.s = state.str;
+  state.theend = state.s + state.sz - 1;
+  state.append_char = as_append_char;
+  state.reserve     = as_reserve;
+
+  st = xyzprintf (&state, format, args);
+  if (st) {
+    free (state.str);
+    *ret = NULL;
+    return -1;
+  } else {
+    char *tmp;
+
+    *state.s = '\0';
+    len = state.s - state.str;
+    tmp = realloc (state.str, len+1);
+    if (tmp == NULL) {
+      free (state.str);
+      *ret = NULL;
+      return -1;
+    }
+    *ret = tmp;
+    return len;
+  }
+}
+#endif
+
+#ifndef HAVE_VSNPRINTF
+int
+vsnprintf (char *str, size_t sz, const char *format, va_list args)
+{
+  struct state state;
+  int ret;
+  unsigned char *ustr = (unsigned char *)str;
+
+  state.max_sz = 0;
+  state.sz     = sz;
+  state.str    = ustr;
+  state.s      = ustr;
+  state.theend = ustr + sz - 1;
+  state.append_char = sn_append_char;
+  state.reserve     = sn_reserve;
+
+  ret = xyzprintf (&state, format, args);
+  *state.s = '\0';
+  if (ret)
+    return sz;
+  else
+    return state.s - state.str;
+}
+#endif
+

diff --git a/src/tests/verr.c b/src/tests/verr.c
new file mode 100644 (file)
index 0000000..633c45d
--- /dev/null
+++ b/src/tests/verr.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan 
+ * (Royal Institute of Technology, Stockholm, Sweden).  
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: verr.c,v 1.1 2002/05/11 00:02:34 hartmans Exp $");
+#endif
+
+#include <err.h>
+
+void
+verr(int eval, const char *fmt, va_list ap)
+{
+    warnerr(1, fmt, ap);
+    exit(eval);
+}

diff --git a/src/tests/verrx.c b/src/tests/verrx.c
new file mode 100644 (file)
index 0000000..0dda084
--- /dev/null
+++ b/src/tests/verrx.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan 
+ * (Royal Institute of Technology, Stockholm, Sweden).  
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: verrx.c,v 1.1 2002/05/11 00:02:34 hartmans Exp $");
+#endif
+
+#include <err.h>
+
+void
+verrx(int eval, const char *fmt, va_list ap)
+{
+    warnerr(0, fmt, ap);
+    exit(eval);
+}

diff --git a/src/tests/vwarn.c b/src/tests/vwarn.c
new file mode 100644 (file)
index 0000000..6ed5e17
--- /dev/null
+++ b/src/tests/vwarn.c
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan 
+ * (Royal Institute of Technology, Stockholm, Sweden).  
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: vwarn.c,v 1.1 2002/05/11 00:02:37 hartmans Exp $");
+#endif
+
+#include <err.h>
+
+void
+vwarn(const char *fmt, va_list ap)
+{
+    warnerr(1, fmt, ap);
+}

diff --git a/src/tests/vwarnx.c b/src/tests/vwarnx.c
new file mode 100644 (file)
index 0000000..c6de485
--- /dev/null
+++ b/src/tests/vwarnx.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan 
+ * (Royal Institute of Technology, Stockholm, Sweden).  
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: vwarnx.c,v 1.1 2002/05/11 00:02:37 hartmans Exp $");
+#endif
+
+#include <err.h>
+
+void
+vwarnx(const char *fmt, va_list ap)
+{
+    warnerr(0, fmt, ap);
+}
+

diff --git a/src/tests/warnerr.c b/src/tests/warnerr.c
new file mode 100644 (file)
index 0000000..81456cd
--- /dev/null
+++ b/src/tests/warnerr.c
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan 
+ * (Royal Institute of Technology, Stockholm, Sweden).  
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+RCSID("$Id: warnerr.c,v 1.1 2002/05/11 00:02:37 hartmans Exp $");
+#endif
+
+#include "err.h"
+
+#ifndef HAVE___PROGNAME
+const char *__progname;
+#endif
+
+#ifndef HAVE_GETPROGNAME
+const char *
+getprogname(void)
+{
+    return __progname;
+}
+#endif
+
+#ifndef HAVE_SETPROGNAME
+void
+setprogname(const char *argv0)
+{
+#ifndef HAVE___PROGNAME
+    char *p;
+    if(argv0 == NULL)
+       return;
+    p = strrchr(argv0, '/');
+    if(p == NULL)
+       p = argv0;
+    else
+       p++;
+    __progname = p;
+#endif
+}
+#endif /* HAVE_SETPROGNAME */
+
+void
+set_progname(char *argv0)
+{
+    setprogname ((const char *)argv0);
+}
+
+const char *
+get_progname (void)
+{
+    return getprogname ();
+}
+
+void
+warnerr(int doerrno, const char *fmt, va_list ap)
+{
+    int sverrno = errno;
+    const char *progname = getprogname();
+
+    if(progname != NULL){
+       fprintf(stderr, "%s", progname);
+       if(fmt != NULL || doerrno)
+           fprintf(stderr, ": ");
+    }
+    if (fmt != NULL){
+       vfprintf(stderr, fmt, ap);
+       if(doerrno)
+           fprintf(stderr, ": ");
+    }
+    if(doerrno)
+       fprintf(stderr, "%s", strerror(sverrno));
+    fprintf(stderr, "\n");
+}