rfc1751.txt

中、英文RFC文档大全打包下载完全版 .

/* Display 8 bytes as a series of 16-bit hex digits */
char *
put8(out,s)
char *out;
char *s;
{
        sprintf(out,"%02X%02X %02X%02X %02X%02X %02X%02X",
                s[0] & 0xff,s[1] & 0xff,s[2] & 0xff,
                s[3] & 0xff,s[4] & 0xff,s[5] & 0xff,
                s[6] & 0xff,s[7] & 0xff);
        return out;
}
#ifdef  notdef
/* Encode 8 bytes in 'cp' as stream of ascii letters.
 * Provided as a possible alternative to btoe()
 */
char *
btoc(cp)
char *cp;
{
        int i;
        static char out[31];

        /* code out put by characters 6 bits each added to 0x21 (!)*/
        for(i=0;i <= 10;i++){
                /* last one is only 4 bits not 6*/
                out[i] = '!'+ extract(cp,6*i,i >= 10 ? 4:6);
        }
        out[i] = '\0';
        return(out);
}
#endif

/* Internal subroutines for word encoding/decoding */

/* Dictionary binary search */
static int
wsrch(w,low,high)
char *w;
int low, high;
{
        int i,j;

        for(;;){
                i = (low + high)/2;
                if((j = strncmp(w,Wp[i],4)) == 0)
                        return i;       /* Found it */
                if(high == low+1){



McDonald                                                       [Page 11]

RFC 1751              Human-Readable 128-bit Keys          December 1994


                        /* Avoid effects of integer truncation in /2 */
                        if(strncmp(w,Wp[high],4) == 0)
                                return high;
                        else
                                return -1;
                }
                if(low >= high)
                        return -1;
                   /* I don't *think* this can happen...*/
                if(j < 0)
                        high = i;  /* Search lower half */
                else
                        low = i;   /* Search upper half */
        }
}
static void
insert(s, x, start, length)
char *s;
int x;
int  start, length;
{
        unsigned char cl;
        unsigned char cc;
        unsigned char cr;
        unsigned long y;
        int shift;

        assert(length <= 11);
        assert(start >= 0);
        assert(length >= 0);
        assert(start +length <= 66);

        shift = ((8  -(( start + length) % 8))%8);
        y = (long) x << shift;
        cl = (y >> 16) & 0xff;
        cc = (y >> 8) & 0xff;
        cr = y & 0xff;
        if(shift + length > 16){
                s[start /8] |= cl;
                s[start/8 +1] |= cc;
                s[start/8 +2] |= cr;
        } else if(shift +length > 8){
                s[start/8] |= cc;
                s[start/8 + 1] |= cr;
        } else {
                s[start/8] |= cr;
        }
}



McDonald                                                       [Page 12]

RFC 1751              Human-Readable 128-bit Keys          December 1994


static void
standard(word)
register char *word;
{
        while(*word){
                if(!isascii(*word))
                        break;
                if(islower(*word))
                        *word = toupper(*word);
                if(*word == '1')
                        *word = 'L';
                if(*word == '0')
                        *word = 'O';
                if(*word == '5')
                        *word = 'S';
                word++;
        }
}

/* Extract 'length' bits from the char array 's'
   starting with bit 'start' */
static unsigned long
extract(s, start, length)
char *s;
int start, length;
{
        unsigned char cl;
        unsigned char cc;
        unsigned char cr;
        unsigned long x;

        assert(length <= 11);
        assert(start >= 0);
        assert(length >= 0);
        assert(start +length <= 66);

        cl = s[start/8];
        cc = s[start/8 +1];
        cr = s[start/8 +2];
        x = ((long)(cl<<8 | cc) <<8  | cr) ;
        x = x >> (24 - (length + (start %8)));
        x =( x & (0xffff >> (16-length) )   );
        return(x);
}







McDonald                                                       [Page 13]

RFC 1751              Human-Readable 128-bit Keys          December 1994


Appendix B - Source for 128-bit key to/from English words (convert.c)

/* convert.c  --  Wrapper to S/Key binary-to-English routines.
      Daniel L. McDonald  --  U. S. Naval Research Laboratory. */

#include <string.h>

/* eng2key() assumes words must be separated by spaces only.

   eng2key() returns

   1 if succeeded
   0 if word not in dictionary
   -1 if badly formed string
   -2 if words are okay but parity is wrong.
   (see etob() in S/Key)
*/

int eng2key(keyout,eng)
char *keyout,*eng;
{
  int rc=0,state=1;
  char *eng2;

  /* Find pointer to word 7. */

  for (eng2 = eng; rc<7 && (*(++eng2) != '\0'); )
    if (*eng2 != ' ')
      {
        rc += state;
        state = 0;
      }
    else state=1;

  if ( (rc = etob(keyout,eng)) != 1)
    return rc;

  rc = etob(keyout+8,eng2);

  return rc;
}

/* key2eng() assumes string referenced by
   engout has at least 60 characters
   (4*12 + 11 spaces + '\0') of space.

   key2eng() returns pointer to engout.




McDonald                                                       [Page 14]

RFC 1751              Human-Readable 128-bit Keys          December 1994


*/

char *key2eng(engout,key)
char *engout,*key;
{
  btoe(engout,key);
  strcat(engout," ");
  btoe(engout+strlen(engout),key+8);
  return engout;
}










































McDonald                                                       [Page 15]