Finally got sick of changing the version number in !Boot and !Run and AunMap...

Finally got sick of changing the version number in !Boot and !Run and AunMap so now only !Help tells you the version.

Added lots of "-Dlint"s as previously the (un)lucky developer who checked
the source out got their name stamped in the released binaries.
#if'd out a bum switch which only makes sense for FreeBSD.
A bit more of 'host' imported,probably not worth finishing.

Version 5.41. Tagged as 'Internet-5_41'

Resources/!Boot,feb

 |================================================================|
-| Boot file for !Internet V5.39 (10-Jan-03)                      |
+| Boot file for !Internet                                        |
 |                                                                |
 | Copyright (C) Acorn Computers Ltd., 1996                       |
 |================================================================|

Resources/!Run,feb

 |================================================================|
-| Run file for !Internet V5.39 (10-Jan-03)                       |
+| Run file for !Internet                                         |
 |                                                                |
 | Copyright (C) Acorn Computers Ltd., 1996                       |
 |================================================================|

Resources/UK/!Help

-          !Internet version 5.39 (10-Jan-03)
+          !Internet version 5.41 (03-Oct-03)
           ==================================
 
 This is the Internet resource directory. It stores

Resources/files/AUNMap,feb

 |===============================================================|
-| AUN map file for !Internet V5.39 (10-Jan-03)                  |
+| AUN map file for !Internet                                    |
 |                                                               |
 | This file is used if you are running AUN protocols, but have  |
 | enabled the full TCP/IP Protocol Suite.                       |

Sources/host/Makefile

@@ -23,8 +23,9 @@ CP      = copy
 LD      = link
 RM      = remove
 WIPE    = -wipe
+SQUEEZE = squeeze
 
-DEFINES = -DRISCOS_TWEAK
+DEFINES = -DRISCOS_TWEAK -Dlint
 AFLAGS  = -depend !Depend -Stamp -quit
 CFLAGS  = -c -depend !Depend -ffah -Wp -zps1 ${INCLUDES} ${DEFINES} ${DFLAGS}
 CPFLAGS = ~cfr~v
@@ -52,7 +53,7 @@ DIRS = o._dirs
 COMPONENT = Host
 TARGET    = bin.Host
 
-OBJS =      o.ns o.host o.res_debug
+OBJS =      o.ns o.host o.res o.dst o.base64 o.getaddrinfo
 
 #
 # Rule patterns
@@ -77,5 +78,6 @@ ${DIRS}:
 
 bin.Host: ${OBJS} ${NET5LIBS} ${CLIB} ${DIRS}
         ${LD} -o $@ ${OBJS} ${NET5LIBS} ${CLIB}
+        ${SQUEEZE} $@
 
 # Dynamic dependencies:

Sources/host/c/base64

+/* Copyright 2003 Tematic Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+/*
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: base64.c,v 1.2 1997/04/13 10:30:31 mrg Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include  <sys/types.h>
+#include  <sys/param.h>
+#include  <sys/socket.h>
+#include  <netinet/in.h>
+#include  <arpa/inet.h>
+#include  <arpa/nameser.h> 
+
+#include  <ctype.h> 
+#include  <resolv.h> 
+#include  <stdio.h> 
+
+#include  <stdlib.h>
+#include  <string.h>
+
+#define Assert(Cond) if (!(Cond)) abort()
+
+static const char Base64[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
+
+/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
+   The following encoding technique is taken from RFC 1521 by Borenstein
+   and Freed.  It is reproduced here in a slightly edited form for
+   convenience.
+
+   A 65-character subset of US-ASCII is used, enabling 6 bits to be
+   represented per printable character. (The extra 65th character, "=",
+   is used to signify a special processing function.)
+
+   The encoding process represents 24-bit groups of input bits as output
+   strings of 4 encoded characters. Proceeding from left to right, a
+   24-bit input group is formed by concatenating 3 8-bit input groups.
+   These 24 bits are then treated as 4 concatenated 6-bit groups, each
+   of which is translated into a single digit in the base64 alphabet.
+
+   Each 6-bit group is used as an index into an array of 64 printable
+   characters. The character referenced by the index is placed in the
+   output string.
+
+                         Table 1: The Base64 Alphabet
+
+      Value Encoding  Value Encoding  Value Encoding  Value Encoding
+          0 A            17 R            34 i            51 z
+          1 B            18 S            35 j            52 0
+          2 C            19 T            36 k            53 1
+          3 D            20 U            37 l            54 2
+          4 E            21 V            38 m            55 3
+          5 F            22 W            39 n            56 4
+          6 G            23 X            40 o            57 5
+          7 H            24 Y            41 p            58 6
+          8 I            25 Z            42 q            59 7
+          9 J            26 a            43 r            60 8
+         10 K            27 b            44 s            61 9
+         11 L            28 c            45 t            62 +
+         12 M            29 d            46 u            63 /
+         13 N            30 e            47 v
+         14 O            31 f            48 w         (pad) =
+         15 P            32 g            49 x
+         16 Q            33 h            50 y
+
+   Special processing is performed if fewer than 24 bits are available
+   at the end of the data being encoded.  A full encoding quantum is
+   always completed at the end of a quantity.  When fewer than 24 input
+   bits are available in an input group, zero bits are added (on the
+   right) to form an integral number of 6-bit groups.  Padding at the
+   end of the data is performed using the '=' character.
+
+   Since all base64 input is an integral number of octets, only the
+         -------------------------------------------------                       
+   following cases can arise:
+   
+       (1) the final quantum of encoding input is an integral
+           multiple of 24 bits; here, the final unit of encoded
+           output will be an integral multiple of 4 characters
+           with no "=" padding,
+       (2) the final quantum of encoding input is exactly 8 bits;
+           here, the final unit of encoded output will be two
+           characters followed by two "=" padding characters, or
+       (3) the final quantum of encoding input is exactly 16 bits;
+           here, the final unit of encoded output will be three
+           characters followed by one "=" padding character.
+   */
+
+/*  */
+int
+b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize)
+{
+        size_t datalength = 0;
+        u_char input[3];
+        u_char output[4];
+        int i;
+
+        while (2 < srclength) {
+                input[0] = *src++;
+                input[1] = *src++;
+                input[2] = *src++;
+                srclength -= 3;
+
+                output[0] = input[0] >> 2;
+                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+                output[3] = input[2] & 0x3f;
+                Assert(output[0] < 64);
+                Assert(output[1] < 64);
+                Assert(output[2] < 64);
+                Assert(output[3] < 64);
+
+                if (datalength + 4 > targsize)
+                        return (-1);
+                target[datalength++] = Base64[output[0]];
+                target[datalength++] = Base64[output[1]];
+                target[datalength++] = Base64[output[2]];
+                target[datalength++] = Base64[output[3]];
+        }
+    
+        /* Now we worry about padding. */
+        if (0 != srclength) {
+                /* Get what's left. */
+                input[0] = input[1] = input[2] = '\0';
+                for (i = 0; i < srclength; i++)
+                        input[i] = *src++;
+        
+                output[0] = input[0] >> 2;
+                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+                Assert(output[0] < 64);
+                Assert(output[1] < 64);
+                Assert(output[2] < 64);
+
+                if (datalength + 4 > targsize)
+                        return (-1);
+                target[datalength++] = Base64[output[0]];
+                target[datalength++] = Base64[output[1]];
+                if (srclength == 1)
+                        target[datalength++] = Pad64;
+                else
+                        target[datalength++] = Base64[output[2]];
+                target[datalength++] = Pad64;
+        }
+        if (datalength >= targsize)
+                return (-1);
+        target[datalength] = '\0';      /* Returned value doesn't count \0. */
+        return (datalength);
+}
+
+#ifndef RISCOS_TWEAK
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+/*  */
+int
+b64_pton(char const *src,
+         u_char *target,
+         size_t targsize)
+{
+        int tarindex, state, ch;
+        char *pos;
+
+        state = 0;
+        tarindex = 0;
+
+        while ((ch = *src++) != '\0') {
+                if (isspace(ch))        /* Skip whitespace anywhere. */
+                        continue;
+
+                if (ch == Pad64)
+                        break;
+
+                pos = strchr(Base64, ch);
+                if (pos == 0)           /* A non-base64 character. */
+                        return (-1);
+
+                switch (state) {
+                case 0:
+                        if (target) {
+                                if (tarindex >= targsize)
+                                        return (-1);
+                                target[tarindex] = (pos - Base64) << 2;
+                        }
+                        state = 1;
+                        break;
+                case 1:
+                        if (target) {
+                                if (tarindex + 1 >= targsize)
+                                        return (-1);
+                                target[tarindex]   |=  (pos - Base64) >> 4;
+                                target[tarindex+1]  = ((pos - Base64) & 0x0f)
+                                                        << 4 ;
+                        }
+                        tarindex++;
+                        state = 2;
+                        break;
+                case 2:
+                        if (target) {
+                                if (tarindex + 1 >= targsize)
+                                        return (-1);
+                                target[tarindex]   |=  (pos - Base64) >> 2;
+                                target[tarindex+1]  = ((pos - Base64) & 0x03)
+                                                        << 6;
+                        }
+                        tarindex++;
+                        state = 3;
+                        break;
+                case 3:
+                        if (target) {
+                                if (tarindex >= targsize)
+                                        return (-1);
+                                target[tarindex] |= (pos - Base64);
+                        }
+                        tarindex++;
+                        state = 0;
+                        break;
+                default:
+                        abort();
+                }
+        }
+
+        /*
+         * We are done decoding Base-64 chars.  Let's see if we ended
+         * on a byte boundary, and/or with erroneous trailing characters.
+         */
+
+        if (ch == Pad64) {              /* We got a pad char. */
+                ch = *src++;            /* Skip it, get next. */
+                switch (state) {
+                case 0:         /* Invalid = in first position */
+                case 1:         /* Invalid = in second position */
+                        return (-1);
+
+                case 2:         /* Valid, means one byte of info */
+                        /* Skip any number of spaces. */
+                        for (NULL; ch != '\0'; ch = *src++)
+                                if (!isspace(ch))
+                                        break;
+                        /* Make sure there is another trailing = sign. */
+                        if (ch != Pad64)
+                                return (-1);
+                        ch = *src++;            /* Skip the = */
+                        /* Fall through to "single trailing =" case. */
+                        /* FALLTHROUGH */
+
+                case 3:         /* Valid, means two bytes of info */
+                        /*
+                         * We know this char is an =.  Is there anything but
+                         * whitespace after it?
+                         */
+                        for (NULL; ch != '\0'; ch = *src++)
+                                if (!isspace(ch))
+                                        return (-1);
+
+                        /*
+                         * Now make sure for cases 2 and 3 that the "extra"
+                         * bits that slopped past the last full byte were
+                         * zeros.  If we don't check them, they become a
+                         * subliminal channel.
+                         */
+                        if (target && target[tarindex] != 0)
+                                return (-1);
+                }
+        } else {
+                /*
+                 * We ended by seeing the end of the string.  Make sure we
+                 * have no partial bytes lying around.
+                 */
+                if (state != 0)
+                        return (-1);
+        }
+
+        return (tarindex);
+}
+
+#endif

Sources/host/c/dst

+/* Copyright 2003 Tematic Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* Domain Signature Tools functions */
+/* These functions do nothing */
+
+#include "sys/types.h"
+#define NOTUSED(k) k=k;
+
+typedef struct dst_key {
+        char    *dk_key_name;   /* name of the key */
+        int     dk_key_size;    /* this is the size of the key in bits */
+        int     dk_proto;       /* what protocols this key can be used for */
+        int     dk_alg;         /* algorithm number from key record */
+        u_int32_t dk_flags;     /* and the flags of the public key */
+        u_int16_t dk_id;        /* identifier of the key */
+} DST_KEY;
+
+/*
+ *  dst_dnskey_to_public_key
+ *      This function converts the contents of a DNS KEY RR into a DST
+ *      key structure.
+ *  Paramters
+ *      len      Length of the RDATA of the KEY RR RDATA
+ *      rdata    A pointer to the the KEY RR RDATA.
+ *      in_name  Key name to be stored in key structure.
+ *  Returns
+ *      NULL        Failure
+ *      NON-NULL        Success.  Pointer to key structure.
+ *                      Caller's responsibility to free() it.
+ */
+
+DST_KEY *dst_dnskey_to_key(const char *in_name, /* KEY record name */
+                           const u_char *key,   /* KEY RDATA */
+                           const int len)       /* size of input buffer*/
+{
+(void)len;
+(void)in_name;
+(void)key;
+
+return NULL;
+}
+
+/*
+ *  dst_init
+ *      This function initializes the Digital Signature Toolkit.
+ *      Right now, it just checks the DSTKEYPATH environment variable.
+ *  Parameters
+ *      none
+ *  Returns
+ *      none
+ */
+void dst_init()
+{
+}
+
+/*
+ *  dst_verify_data
+ *      An incremental verify function.  Data is verified in steps.
+ *      First the context must be initialized (SIG_MODE_INIT).
+ *      Then data is hashed (SIG_MODE_UPDATE).  Finally the signature
+ *      is verified (SIG_MODE_FINAL).  This function can be called
+ *      once with INIT, UPDATE and FINAL modes all set, or it can be
+ *      called separately with a different mode set for each step.  The
+ *      UPDATE step can be repeated.
+ *  Parameters
+ *      mode    Operations to perform this time.
+ *                    SIG_MODE_INIT       1   Initialize digest
+ *                    SIG_MODE_UPDATE     2   add data to digest
+ *                    SIG_MODE_FINAL      4   verify signature
+ *                    SIG_MODE_ALL
+ *                        (SIG_MODE_INIT,SIG_MODE_UPDATE,SIG_MODE_FINAL)
+ *      data    Data to pass through the hash function.
+ *      len     Length of the data in bytes.
+ *      in_key      Key for verification.
+ *      signature   Location of signature.
+ *      sig_len     Length of the signature in bytes.
+ *  Returns
+ *      0          Verify success
+ *      Non-Zero   Verify Failure
+ */
+
+int dst_verify_data(const int mode,       /* specifies INIT/UPDATE/FINAL/ALL */
+                    DST_KEY *in_key,     /* the key to use */
+                    void **context,      /* pointer to state structure */
+                    const u_char *data,  /* data to be verified */
+                    const int len,       /* length of input data */
+                    const u_char *signature,/* buffer containing signature */
+                    const int sig_len)
+{
+NOTUSED(in_key)
+NOTUSED(context)
+(void)data;
+(void)len;
+(void)signature;
+(void)sig_len;
+(void)mode;
+
+return -1;
+}
+
+/*
+ *  dst_free_key
+ *      Release all data structures pointed to by a key structure.
+ *  Parameters
+ *      f_key   Key structure to be freed.
+ */
+
+DST_KEY *dst_free_key(DST_KEY *f_key)
+{
+NOTUSED(f_key)
+
+return (NULL);
+}
+

Sources/host/c/getaddrinfo

+/* Copyright 2003 Tematic Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* Get address info */
+
+#include "sys/types.h"
+#include "sys/param.h"
+#include "sys/socket.h"
+
+#include "netinet/in.h"
+#include "arpa/inet.h"
+#include "arpa/nameser.h"
+
+#include "ctype.h"
+#include "netdb.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "unistd.h"
+
+#include "memory.h"
+#include "sys/errno.h"
+#include "sys/stat.h"
+#include "dst.h"
+
+#include "resolv.h"
+
+#include "port_after.h"
+
+#define SUCCESS 0
+
+int h_errno;
+extern struct hostent *gethostbyname(const char *);
+
+void
+freeaddrinfo(ai)
+        struct addrinfo *ai;
+{
+        struct addrinfo *next;
+
+        do {
+                next = ai->ai_next;
+                if (ai->ai_canonname)
+                        free(ai->ai_canonname);
+                /* no need to free(ai->ai_addr) */
+                free(ai);
+                ai = next;
+        } while (ai);
+}
+
+/* 1 unfinished */
+
+int
+getaddrinfo(hostname, servname, hints, res)
+        const char *hostname, *servname;
+        const struct addrinfo *hints;
+        struct addrinfo **res;
+{
+
+/* Sweeping assumption: as Host only ever calls this with servname set to
+   NULL this might as well be a gethostbyname if we ignore the hints it passes */
+
+   struct hostent  *host;
+   struct addrinfo sentinel;
+
+
+   if (hostname == NULL && servname == NULL)
+      return EAI_NONAME;
+
+   host = gethostbyname(hostname);
+
+   if (h_errno != NETDB_SUCCESS)
+      {
+      /* Unsuccessful */
+      if (sentinel.ai_next) freeaddrinfo(sentinel.ai_next);
+      *res = NULL;
+      return h_errno;
+      }
+   else
+      {
+      /* Successful */
+      if (sentinel.ai_next) 
+         {
+         sentinel.ai_flags =  0;
+         sentinel.ai_family = 0;
+         sentinel.ai_socktype = 0;
+         sentinel.ai_protocol = 0;
+         sentinel.ai_addrlen = (size_t)host->h_length;
+         sentinel.ai_canonname = host->h_name;
+         sentinel.ai_addr = 0;
+         *res = sentinel.ai_next;
+         return SUCCESS;
+         }
+      else