[BACK]Return to radix.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/Attic/radix.c between version 1.3 and 1.4

version 1.3, 1999/10/01 18:18:40 version 1.4, 1999/11/23 22:25:54
Line 7 
Line 7 
   
   Dug Song <dugsong@UMICH.EDU>    Dug Song <dugsong@UMICH.EDU>
 */  */
   
 #include "includes.h"  #include "includes.h"
   
 #ifdef AFS  #ifdef AFS
 #include <krb.h>  #include <krb.h>
   
 char six2pr[64] = {  char six2pr[64] = {
     'A','B','C','D','E','F','G','H','I','J','K','L','M',          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
     'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
     'a','b','c','d','e','f','g','h','i','j','k','l','m',          'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
     'n','o','p','q','r','s','t','u','v','w','x','y','z',          'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
     '0','1','2','3','4','5','6','7','8','9','+','/'          '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
 };  };
   
 unsigned char pr2six[256];  unsigned char pr2six[256];
   
 int uuencode(unsigned char *bufin, unsigned int nbytes, char *bufcoded)  int
   uuencode(unsigned char *bufin, unsigned int nbytes, char *bufcoded)
 {  {
   /* ENC is the basic 1 character encoding function to make a char printing */          /* ENC is the basic 1 character encoding function to make a char printing */
 #define ENC(c) six2pr[c]  #define ENC(c) six2pr[c]
   
   register char *outptr = bufcoded;          register char *outptr = bufcoded;
   unsigned int i;          unsigned int i;
   
   for (i=0; i<nbytes; i += 3) {          for (i = 0; i < nbytes; i += 3) {
     *(outptr++) = ENC(*bufin >> 2);            /* c1 */                  *(outptr++) = ENC(*bufin >> 2);                                         /* c1 */
     *(outptr++) = ENC(((*bufin << 4) & 060) | ((bufin[1] >> 4) & 017)); /*c2*/                  *(outptr++) = ENC(((*bufin << 4) & 060)   | ((bufin[1] >> 4) & 017));   /* c2 */
     *(outptr++) = ENC(((bufin[1] << 2) & 074) | ((bufin[2] >> 6) & 03));/*c3*/                  *(outptr++) = ENC(((bufin[1] << 2) & 074) | ((bufin[2] >> 6) & 03));    /* c3 */
     *(outptr++) = ENC(bufin[2] & 077);         /* c4 */                  *(outptr++) = ENC(bufin[2] & 077);                                      /* c4 */
     bufin += 3;                  bufin += 3;
   }          }
   if (i == nbytes+1) {          if (i == nbytes + 1) {
     outptr[-1] = '=';                  outptr[-1] = '=';
   } else if (i == nbytes+2) {          } else if (i == nbytes + 2) {
     outptr[-1] = '=';                  outptr[-1] = '=';
     outptr[-2] = '=';                  outptr[-2] = '=';
   }          }
   *outptr = '\0';          *outptr = '\0';
   return(outptr - bufcoded);          return (outptr - bufcoded);
 }  }
   
 int uudecode(const char *bufcoded, unsigned char *bufplain, int outbufsize)  int
   uudecode(const char *bufcoded, unsigned char *bufplain, int outbufsize)
 {  {
   /* single character decode */          /* single character decode */
 #define DEC(c) pr2six[(unsigned char)c]  #define DEC(c) pr2six[(unsigned char)c]
 #define MAXVAL 63  #define MAXVAL 63
   
   static int first = 1;          static int first = 1;
   int nbytesdecoded, j;          int nbytesdecoded, j;
   const char *bufin = bufcoded;          const char *bufin = bufcoded;
   register unsigned char *bufout = bufplain;          register unsigned char *bufout = bufplain;
   register int nprbytes;          register int nprbytes;
   
   /* If this is the first call, initialize the mapping table. */          /* If this is the first call, initialize the mapping table. */
   if (first) {          if (first) {
     first = 0;                  first = 0;
     for(j=0; j<256; j++) pr2six[j] = MAXVAL+1;                  for (j = 0; j < 256; j++)
     for(j=0; j<64; j++) pr2six[(unsigned char)six2pr[j]] = (unsigned char)j;                          pr2six[j] = MAXVAL + 1;
   }                  for (j = 0; j < 64; j++)
                           pr2six[(unsigned char) six2pr[j]] = (unsigned char) j;
   /* Strip leading whitespace. */          }
   while (*bufcoded==' ' || *bufcoded == '\t') bufcoded++;          /* Strip leading whitespace. */
           while (*bufcoded == ' ' || *bufcoded == '\t')
   /* Figure out how many characters are in the input buffer.                  bufcoded++;
      If this would decode into more bytes than would fit into  
      the output buffer, adjust the number of input bytes downwards. */          /* Figure out how many characters are in the input buffer. If this
   bufin = bufcoded;             would decode into more bytes than would fit into the output
   while (DEC(*(bufin++)) <= MAXVAL);             buffer, adjust the number of input bytes downwards. */
   nprbytes = bufin - bufcoded - 1;          bufin = bufcoded;
   nbytesdecoded = ((nprbytes+3)/4) * 3;          while (DEC(*(bufin++)) <= MAXVAL);
   if (nbytesdecoded > outbufsize)          nprbytes = bufin - bufcoded - 1;
     nprbytes = (outbufsize*4)/3;          nbytesdecoded = ((nprbytes + 3) / 4) * 3;
           if (nbytesdecoded > outbufsize)
   bufin = bufcoded;                  nprbytes = (outbufsize * 4) / 3;
   
   while (nprbytes > 0) {          bufin = bufcoded;
     *(bufout++) = (unsigned char) (DEC(*bufin) << 2 | DEC(bufin[1]) >> 4);  
     *(bufout++) = (unsigned char) (DEC(bufin[1]) << 4 | DEC(bufin[2]) >> 2);          while (nprbytes > 0) {
     *(bufout++) = (unsigned char) (DEC(bufin[2]) << 6 | DEC(bufin[3]));                  *(bufout++) = (unsigned char) (DEC(*bufin)   << 2 | DEC(bufin[1]) >> 4);
     bufin += 4;                  *(bufout++) = (unsigned char) (DEC(bufin[1]) << 4 | DEC(bufin[2]) >> 2);
     nprbytes -= 4;                  *(bufout++) = (unsigned char) (DEC(bufin[2]) << 6 | DEC(bufin[3]));
   }                  bufin += 4;
   if (nprbytes & 03) {                  nprbytes -= 4;
     if (DEC(bufin[-2]) > MAXVAL)          }
       nbytesdecoded -= 2;          if (nprbytes & 03) {
     else                  if (DEC(bufin[-2]) > MAXVAL)
       nbytesdecoded -= 1;                          nbytesdecoded -= 2;
   }                  else
   return(nbytesdecoded);                          nbytesdecoded -= 1;
           }
           return (nbytesdecoded);
 }  }
   
 typedef unsigned char my_u_char;  typedef unsigned char my_u_char;
Line 156 
Line 160 
 }  }
   
   
 int creds_to_radix(CREDENTIALS *creds, unsigned char *buf)  int
   creds_to_radix(CREDENTIALS *creds, unsigned char *buf)
 {  {
   char *p, *s;          char *p, *s;
   int len;          int len;
   char temp[2048];          char temp[2048];
   
   p = temp;  
   *p++ = 1; /* version */  
   s = creds->service;   while (*s) *p++ = *s++; *p++ = *s;  
   s = creds->instance;  while (*s) *p++ = *s++; *p++ = *s;  
   s = creds->realm;     while (*s) *p++ = *s++; *p++ = *s;  
   
   s = creds->pname;     while (*s) *p++ = *s++;   *p++ = *s;          p = temp;
   s = creds->pinst;     while (*s) *p++ = *s++;   *p++ = *s;          *p++ = 1;               /* version */
   /* Null string to repeat the realm. */          s = creds->service;
   *p++ = '\0';          while (*s)
                   *p++ = *s++;
           *p++ = *s;
           s = creds->instance;
           while (*s)
                   *p++ = *s++;
           *p++ = *s;
           s = creds->realm;
           while (*s)
                   *p++ = *s++;
           *p++ = *s;
   
   PUTLONG(creds->issue_date,p);          s = creds->pname;
   {          while (*s)
     unsigned int        endTime ;                  *p++ = *s++;
     endTime = (unsigned int)krb_life_to_time(creds->issue_date,          *p++ = *s;
                                               creds->lifetime);          s = creds->pinst;
     PUTLONG(endTime,p);          while (*s)
   }                  *p++ = *s++;
           *p++ = *s;
           /* Null string to repeat the realm. */
           *p++ = '\0';
   
   memcpy(p,&creds->session, sizeof(creds->session));          PUTLONG(creds->issue_date, p);
   p += sizeof(creds->session);          {
                   unsigned int endTime;
   PUTSHORT(creds->kvno,p);                  endTime = (unsigned int) krb_life_to_time(creds->issue_date,
   PUTLONG(creds->ticket_st.length,p);                                                            creds->lifetime);
                   PUTLONG(endTime, p);
   memcpy(p,creds->ticket_st.dat, creds->ticket_st.length);          }
   p += creds->ticket_st.length;  
   len = p - temp;  
   
   return(uuencode(temp, len, buf));          memcpy(p, &creds->session, sizeof(creds->session));
           p += sizeof(creds->session);
   
           PUTSHORT(creds->kvno, p);
           PUTLONG(creds->ticket_st.length, p);
   
           memcpy(p, creds->ticket_st.dat, creds->ticket_st.length);
           p += creds->ticket_st.length;
           len = p - temp;
   
           return (uuencode(temp, len, buf));
 }  }
   
 int radix_to_creds(const char *buf, CREDENTIALS *creds)  int
   radix_to_creds(const char *buf, CREDENTIALS *creds)
 {  {
   
   char *p;          char *p;
   int len, tl;          int len, tl;
   char version;          char version;
   char temp[2048];          char temp[2048];
   
   if (!(len = uudecode(buf, temp, sizeof(temp))))  
     return 0;  
   
   p = temp;  
   
   /* check version and length! */          if (!(len = uudecode(buf, temp, sizeof(temp))))
   if (len < 1) return 0;                  return 0;
   version = *p; p++; len--;  
   
   GETSTRING(creds->service, p, len);          p = temp;
   GETSTRING(creds->instance, p, len);  
   GETSTRING(creds->realm, p, len);  
   
   GETSTRING(creds->pname, p, len);  
   GETSTRING(creds->pinst, p, len);  
   /* Ignore possibly different realm. */  
   while (*p && len) p++, len--;  
   if (len == 0) return 0;  
   p++, len--;  
   
   /* Enough space for remaining fixed-length parts? */  
   if (len < (4 + 4 + sizeof(creds->session) + 2 + 4))  
     return 0;  
   
   GETLONG(creds->issue_date,p);  
   len -= 4;  
   {  
     unsigned int        endTime;  
     GETLONG(endTime,p);  
     len -= 4;  
     creds->lifetime = krb_time_to_life(creds->issue_date, endTime);  
   }  
   
   memcpy(&creds->session, p, sizeof(creds->session));          /* check version and length! */
   p += sizeof(creds->session);          if (len < 1)
   len -= sizeof(creds->session);                  return 0;
           version = *p;
   GETSHORT(creds->kvno,p);          p++;
   len -= 2;          len--;
   GETLONG(creds->ticket_st.length,p);  
   len -= 4;  
   
   tl = creds->ticket_st.length;          GETSTRING(creds->service, p, len);
   if (tl < 0 || tl > len || tl > sizeof(creds->ticket_st.dat))          GETSTRING(creds->instance, p, len);
     return 0;          GETSTRING(creds->realm, p, len);
   
   memcpy(creds->ticket_st.dat, p, tl);  
   p += tl;  
   len -= tl;  
   
   return 1;  
 }  
   
           GETSTRING(creds->pname, p, len);
           GETSTRING(creds->pinst, p, len);
           /* Ignore possibly different realm. */
           while (*p && len)
                   p++, len--;
           if (len == 0)
                   return 0;
           p++, len--;
   
           /* Enough space for remaining fixed-length parts? */
           if (len < (4 + 4 + sizeof(creds->session) + 2 + 4))
                   return 0;
   
           GETLONG(creds->issue_date, p);
           len -= 4;
           {
                   unsigned int endTime;
                   GETLONG(endTime, p);
                   len -= 4;
                   creds->lifetime = krb_time_to_life(creds->issue_date, endTime);
           }
   
           memcpy(&creds->session, p, sizeof(creds->session));
           p += sizeof(creds->session);
           len -= sizeof(creds->session);
   
           GETSHORT(creds->kvno, p);
           len -= 2;
           GETLONG(creds->ticket_st.length, p);
           len -= 4;
   
           tl = creds->ticket_st.length;
           if (tl < 0 || tl > len || tl > sizeof(creds->ticket_st.dat))
                   return 0;
   
           memcpy(creds->ticket_st.dat, p, tl);
           p += tl;
           len -= tl;
   
           return 1;
   }
 #endif /* AFS */  #endif /* AFS */
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4