[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.16.2.5 and 1.17

version 1.16.2.5, 2002/10/11 14:53:07 version 1.17, 2001/11/19 19:02:16
Line 1 
Line 1 
 /*  /*
  * Copyright (c) 1999 Dug Song.  All rights reserved.   * Copyright (c) 1999 Dug Song.  All rights reserved.
  * Copyright (c) 2002 Markus Friedl.  All rights reserved.  
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions   * modification, are permitted provided that the following conditions
Line 32 
Line 31 
 #include <krb.h>  #include <krb.h>
   
 #include <radix.h>  #include <radix.h>
 #include "bufaux.h"  
   
   typedef u_char my_u_char;
   typedef u_int my_u_int32_t;
   typedef u_short my_u_short;
   
   /* Nasty macros from BIND-4.9.2 */
   
   #define GETSHORT(s, cp) { \
           my_u_char *t_cp = (my_u_char *)(cp); \
           (s) = (((my_u_short)t_cp[0]) << 8) \
               | (((my_u_short)t_cp[1])) \
               ; \
           (cp) += 2; \
   }
   
   #define GETLONG(l, cp) { \
           my_u_char *t_cp = (my_u_char *)(cp); \
           (l) = (((my_u_int32_t)t_cp[0]) << 24) \
               | (((my_u_int32_t)t_cp[1]) << 16) \
               | (((my_u_int32_t)t_cp[2]) << 8) \
               | (((my_u_int32_t)t_cp[3])) \
               ; \
           (cp) += 4; \
   }
   
   #define PUTSHORT(s, cp) { \
           my_u_short t_s = (my_u_short)(s); \
           my_u_char *t_cp = (my_u_char *)(cp); \
           *t_cp++ = t_s >> 8; \
           *t_cp   = t_s; \
           (cp) += 2; \
   }
   
   #define PUTLONG(l, cp) { \
           my_u_int32_t t_l = (my_u_int32_t)(l); \
           my_u_char *t_cp = (my_u_char *)(cp); \
           *t_cp++ = t_l >> 24; \
           *t_cp++ = t_l >> 16; \
           *t_cp++ = t_l >> 8; \
           *t_cp   = t_l; \
           (cp) += 4; \
   }
   
   #define GETSTRING(s, p, p_l) {                  \
       char *p_targ = (p) + p_l;           \
       char *s_c = (s);                    \
       char *p_c = (p);                    \
       while (*p_c && (p_c < p_targ)) {            \
           *s_c++ = *p_c++;                        \
       }                                           \
       if (p_c == p_targ) {                        \
           return 1;                               \
       }                                           \
       *s_c = *p_c++;                              \
       (p_l) = (p_l) - (p_c - (p));                \
       (p) = p_c;                                  \
   }
   
   
 int  int
 creds_to_radix(CREDENTIALS *creds, u_char *buf, size_t buflen)  creds_to_radix(CREDENTIALS *creds, u_char *buf, size_t buflen)
 {  {
         Buffer b;          char *p, *s;
         int ret;          int len;
           char temp[2048];
   
         buffer_init(&b);          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;
   
         buffer_put_char(&b, 1); /* version */          s = creds->pname;
           while (*s)
         buffer_append(&b, creds->service, strlen(creds->service));                  *p++ = *s++;
         buffer_put_char(&b, '\0');          *p++ = *s;
         buffer_append(&b, creds->instance, strlen(creds->instance));          s = creds->pinst;
         buffer_put_char(&b, '\0');          while (*s)
         buffer_append(&b, creds->realm, strlen(creds->realm));                  *p++ = *s++;
         buffer_put_char(&b, '\0');          *p++ = *s;
         buffer_append(&b, creds->pname, strlen(creds->pname));  
         buffer_put_char(&b, '\0');  
         buffer_append(&b, creds->pinst, strlen(creds->pinst));  
         buffer_put_char(&b, '\0');  
   
         /* Null string to repeat the realm. */          /* Null string to repeat the realm. */
         buffer_put_char(&b, '\0');          *p++ = '\0';
   
         buffer_put_int(&b, creds->issue_date);          PUTLONG(creds->issue_date, p);
         buffer_put_int(&b, krb_life_to_time(creds->issue_date,          {
             creds->lifetime));                  u_int endTime;
         buffer_append(&b, creds->session, sizeof(creds->session));                  endTime = (u_int) krb_life_to_time(creds->issue_date,
         buffer_put_short(&b, creds->kvno);                                                            creds->lifetime);
                   PUTLONG(endTime, p);
           }
   
         /* 32 bit size + data */          memcpy(p, &creds->session, sizeof(creds->session));
         buffer_put_string(&b, creds->ticket_st.dat, creds->ticket_st.length);          p += sizeof(creds->session);
   
         ret = uuencode(buffer_ptr(&b), buffer_len(&b), (char *)buf, buflen);          PUTSHORT(creds->kvno, p);
           PUTLONG(creds->ticket_st.length, p);
   
         buffer_free(&b);          memcpy(p, creds->ticket_st.dat, creds->ticket_st.length);
         return ret;          p += creds->ticket_st.length;
           len = p - temp;
   
           return (uuencode((u_char *)temp, len, (char *)buf, buflen));
 }  }
   
 #define GETSTRING(b, t, tlen) \  
         do { \  
                 int i, found = 0; \  
                 for (i = 0; i < tlen; i++) { \  
                         if (buffer_len(b) == 0) \  
                                 goto done; \  
                         t[i] = buffer_get_char(b); \  
                         if (t[i] == '\0') { \  
                                 found = 1; \  
                                 break; \  
                         } \  
                 } \  
                 if (!found) \  
                         goto done; \  
         } while(0)  
   
 int  int
 radix_to_creds(const char *buf, CREDENTIALS *creds)  radix_to_creds(const char *buf, CREDENTIALS *creds)
 {  {
         Buffer b;  
         u_char *space;  
         char c, version, *p;  
         u_int endTime, len;  
         int blen, ret;  
   
         ret = 0;          char *p;
         blen = strlen(buf);          int len, tl;
           char version;
           char temp[2048];
   
         /* sanity check for size */          len = uudecode(buf, (u_char *)temp, sizeof(temp));
         if (blen > 8192)          if (len < 0)
                 return 0;                  return 0;
   
         buffer_init(&b);          p = temp;
         space = buffer_append_space(&b, blen);  
   
         /* check version and length! */          /* check version and length! */
         len = uudecode(buf, space, blen);  
         if (len < 1)          if (len < 1)
                 goto done;                  return 0;
           version = *p;
           p++;
           len--;
   
         version = buffer_get_char(&b);          GETSTRING(creds->service, p, len);
           GETSTRING(creds->instance, p, len);
           GETSTRING(creds->realm, p, len);
   
         GETSTRING(&b, creds->service, sizeof creds->service);          GETSTRING(creds->pname, p, len);
         GETSTRING(&b, creds->instance, sizeof creds->instance);          GETSTRING(creds->pinst, p, len);
         GETSTRING(&b, creds->realm, sizeof creds->realm);  
         GETSTRING(&b, creds->pname, sizeof creds->pname);  
         GETSTRING(&b, creds->pinst, sizeof creds->pinst);  
   
         if (buffer_len(&b) == 0)  
                 goto done;  
   
         /* Ignore possibly different realm. */          /* Ignore possibly different realm. */
         while (buffer_len(&b) > 0 && (c = buffer_get_char(&b)) != '\0')          while (*p && len)
                 ;                  p++, len--;
           if (len == 0)
                   return 0;
           p++, len--;
   
         if (buffer_len(&b) == 0)          /* Enough space for remaining fixed-length parts? */
                 goto done;          if (len < (4 + 4 + sizeof(creds->session) + 2 + 4))
                   return 0;
   
         creds->issue_date = buffer_get_int(&b);          GETLONG(creds->issue_date, p);
           len -= 4;
           {
                   u_int endTime;
                   GETLONG(endTime, p);
                   len -= 4;
                   creds->lifetime = krb_time_to_life(creds->issue_date, endTime);
           }
   
         endTime = buffer_get_int(&b);          memcpy(&creds->session, p, sizeof(creds->session));
         creds->lifetime = krb_time_to_life(creds->issue_date, endTime);          p += sizeof(creds->session);
           len -= sizeof(creds->session);
   
         len = buffer_len(&b);          GETSHORT(creds->kvno, p);
         if (len < sizeof(creds->session))          len -= 2;
                 goto done;          GETLONG(creds->ticket_st.length, p);
         memcpy(&creds->session, buffer_ptr(&b), sizeof(creds->session));          len -= 4;
         buffer_consume(&b, sizeof(creds->session));  
   
         creds->kvno = buffer_get_short(&b);          tl = creds->ticket_st.length;
           if (tl < 0 || tl > len || tl > sizeof(creds->ticket_st.dat))
                   return 0;
   
         p = buffer_get_string(&b, &len);          memcpy(creds->ticket_st.dat, p, tl);
         if (len < 0 || len > sizeof(creds->ticket_st.dat))          p += tl;
                 goto done;          len -= tl;
         memcpy(&creds->ticket_st.dat, p, len);  
         creds->ticket_st.length = len;  
   
         ret = 1;          return 1;
 done:  
         buffer_free(&b);  
         return ret;  
 }  }
 #endif /* AFS */  #endif /* AFS */
Legend:
Removed from v.1.16.2.5  
changed lines
  Added in v.1.17