Windows global stuff:

[krb5.git] / src / lib / krb5 / ccache / file / fcc_read.c

diff --git a/src/lib/krb5/ccache/file/fcc_read.c b/src/lib/krb5/ccache/file/fcc_read.c
index 7a91d6a0fb22d264dfeb9c7a14a9e4a3712a2404..e963d9eb71e3bff8388f461efc10255d61102c96 100644 (file)
--- a/src/lib/krb5/ccache/file/fcc_read.c
+++ b/src/lib/krb5/ccache/file/fcc_read.c
@@ -41,7 +41,8 @@
  * system errors (read)
  */
 krb5_error_code
-krb5_fcc_read(id, buf, len)
+krb5_fcc_read(context, id, buf, len)
+   krb5_context context;
    krb5_ccache id;
    krb5_pointer buf;
    int len;
@@ -50,7 +51,7 @@ krb5_fcc_read(id, buf, len)
 
      ret = read(((krb5_fcc_data *) id->data)->fd, (char *) buf, len);
      if (ret == -1)
-         return krb5_fcc_interpret(errno);
+         return krb5_fcc_interpret(context, errno);
      else if (ret != len)
          return KRB5_CC_END;
      else
@@ -75,27 +76,28 @@ krb5_fcc_read(id, buf, len)
  */
 
 krb5_error_code
-krb5_fcc_read_principal(id, princ)
+krb5_fcc_read_principal(context, id, princ)
+   krb5_context context;
    krb5_ccache id;
    krb5_principal *princ;
 {
     krb5_fcc_data *data = (krb5_fcc_data *)id->data;
     krb5_error_code kret;
     register krb5_principal tmpprinc;
-    krb5_int32 length, type;
+    krb5_int32 length, type, msize;
     int i;
 
     if (data->version == KRB5_FCC_FVNO_1) {
        type = KRB5_NT_UNKNOWN;
     } else {
         /* Read principal type */
-        kret = krb5_fcc_read_int32(id, &type);
+        kret = krb5_fcc_read_int32(context, id, &type);
         if (kret != KRB5_OK)
            return kret;
     }
 
     /* Read the number of components */
-    kret = krb5_fcc_read_int32(id, &length);
+    kret = krb5_fcc_read_int32(context, id, &length);
     if (kret != KRB5_OK)
        return kret;
 
@@ -110,8 +112,11 @@ krb5_fcc_read_principal(id, princ)
     if (tmpprinc == NULL)
        return KRB5_CC_NOMEM;
     if (length) {
-           tmpprinc->data = (krb5_data *) malloc(length * sizeof(krb5_data));
-           if (tmpprinc->data == 0) {
+            tmpprinc->data = 0;
+            msize = length * sizeof(krb5_data);
+            if ((msize & VALID_UINT_BITS) == msize)  /* Not overflow size_t */
+                   tmpprinc->data = (krb5_data *) malloc((size_t) msize);
+           if (tmpprinc->data == (krb5_data *) 0) {
                    free((char *)tmpprinc);
                    return KRB5_CC_NOMEM;
            }
@@ -121,13 +126,13 @@ krb5_fcc_read_principal(id, princ)
     tmpprinc->length = length;
     tmpprinc->type = type;
 
-    kret = krb5_fcc_read_data(id, krb5_princ_realm(tmpprinc));
+    kret = krb5_fcc_read_data(context, id, krb5_princ_realm(context, tmpprinc));
 
     i = 0;
     CHECK(kret);
 
     for (i=0; i < length; i++) {
-       kret = krb5_fcc_read_data(id, krb5_princ_component(tmpprinc, i));
+       kret = krb5_fcc_read_data(context, id, krb5_princ_component(context, tmpprinc, i));
        CHECK(kret);
     }
     *princ = tmpprinc;
@@ -135,53 +140,58 @@ krb5_fcc_read_principal(id, princ)
 
  errout:
     while(--i >= 0)
-       free(krb5_princ_component(tmpprinc, i)->data);
+       free(krb5_princ_component(context, tmpprinc, i)->data);
     free((char *)tmpprinc->data);
     free((char *)tmpprinc);
     return kret;
 }
 
 krb5_error_code
-krb5_fcc_read_addrs(id, addrs)
+krb5_fcc_read_addrs(context, id, addrs)
+   krb5_context context;
    krb5_ccache id;
    krb5_address ***addrs;
 {
      krb5_error_code kret;
-     krb5_int32 length;
+     krb5_int32 length, msize;
      int i;
 
      *addrs = 0;
 
      /* Read the number of components */
-     kret = krb5_fcc_read_int32(id, &length);
+     kret = krb5_fcc_read_int32(context, id, &length);
      CHECK(kret);
 
      /* Make *addrs able to hold length pointers to krb5_address structs
       * Add one extra for a null-terminated list
       */
-     *addrs = (krb5_address **) calloc(length+1, sizeof(krb5_address *));
+     msize = length+1;
+     if ((msize & VALID_UINT_BITS) != msize)    /* Overflow size_t??? */
+         return KRB5_CC_NOMEM;
+     *addrs = (krb5_address **) calloc((size_t) msize, sizeof(krb5_address *));
      if (*addrs == NULL)
          return KRB5_CC_NOMEM;
 
      for (i=0; i < length; i++) {
          (*addrs)[i] = (krb5_address *) malloc(sizeof(krb5_address));
          if ((*addrs)[i] == NULL) {
-             krb5_free_addresses(*addrs);
+             krb5_free_addresses(context, *addrs);
              return KRB5_CC_NOMEM;
          }       
-         kret = krb5_fcc_read_addr(id, (*addrs)[i]);
+         kret = krb5_fcc_read_addr(context, id, (*addrs)[i]);
          CHECK(kret);
      }
 
      return KRB5_OK;
  errout:
      if (*addrs)
-        krb5_free_addresses(*addrs);
+        krb5_free_addresses(context, *addrs);
      return kret;
 }
 
 krb5_error_code
-krb5_fcc_read_keyblock(id, keyblock)
+krb5_fcc_read_keyblock(context, id, keyblock)
+   krb5_context context;
    krb5_ccache id;
    krb5_keyblock *keyblock;
 {
@@ -193,21 +203,23 @@ krb5_fcc_read_keyblock(id, keyblock)
      keyblock->magic = KV5M_KEYBLOCK;
      keyblock->contents = 0;
 
-     kret = krb5_fcc_read_ui_2(id, &ui2);
+     kret = krb5_fcc_read_ui_2(context, id, &ui2);
      keyblock->keytype = ui2;
      CHECK(kret);
      if ((data->version == KRB5_FCC_FVNO_1) ||
         (data->version == KRB5_FCC_FVNO_2))
             keyblock->etype = ETYPE_UNKNOWN;
      else {
-            kret = krb5_fcc_read_ui_2(id, &ui2);
+            kret = krb5_fcc_read_ui_2(context, id, &ui2);
             keyblock->etype = ui2;
             CHECK(kret);
      }
 
-     kret = krb5_fcc_read_int32(id, &int32);
+     kret = krb5_fcc_read_int32(context, id, &int32);
      CHECK(kret);
-     keyblock->length = int32;
+     if ((int32 & VALID_INT_BITS) != int32)     /* Overflow size_t??? */
+         return KRB5_CC_NOMEM;
+     keyblock->length = (int) int32;
      if ( keyblock->length == 0 )
             return KRB5_OK;
      keyblock->contents = (unsigned char *) malloc(keyblock->length*
@@ -215,7 +227,7 @@ krb5_fcc_read_keyblock(id, keyblock)
      if (keyblock->contents == NULL)
          return KRB5_CC_NOMEM;
      
-     kret = krb5_fcc_read(id, keyblock->contents, keyblock->length);
+     kret = krb5_fcc_read(context, id, keyblock->contents, keyblock->length);
      if (kret)
         goto errout;
 
@@ -227,17 +239,22 @@ krb5_fcc_read_keyblock(id, keyblock)
 }
 
 krb5_error_code
-krb5_fcc_read_data(id, data)
+krb5_fcc_read_data(context, id, data)
+   krb5_context context;
    krb5_ccache id;
    krb5_data *data;
 {
      krb5_error_code kret;
+     krb5_int32 len;
 
      data->magic = KV5M_DATA;
      data->data = 0;
 
-     kret = krb5_fcc_read_int32(id, &data->length);
+     kret = krb5_fcc_read_int32(context, id, &len);
      CHECK(kret);
+     if ((len & VALID_INT_BITS) != len)
+        return KRB5_CC_NOMEM;
+     data->length = (int) len;
 
      if (data->length == 0) {
        data->data = 0;
@@ -248,7 +265,7 @@ krb5_fcc_read_data(id, data)
      if (data->data == NULL)
          return KRB5_CC_NOMEM;
 
-     kret = krb5_fcc_read(id, data->data, data->length);
+     kret = krb5_fcc_read(context, id, data->data, data->length);
      CHECK(kret);
      
      data->data[data->length] = 0; /* Null terminate, just in case.... */
@@ -260,7 +277,8 @@ krb5_fcc_read_data(id, data)
 }
 
 krb5_error_code
-krb5_fcc_read_addr(id, addr)
+krb5_fcc_read_addr(context, id, addr)
+   krb5_context context;
    krb5_ccache id;
    krb5_address *addr;
 {
@@ -271,13 +289,15 @@ krb5_fcc_read_addr(id, addr)
      addr->magic = KV5M_ADDRESS;
      addr->contents = 0;
 
-     kret = krb5_fcc_read_ui_2(id, &ui2);
+     kret = krb5_fcc_read_ui_2(context, id, &ui2);
      CHECK(kret);
      addr->addrtype = ui2;
      
-     kret = krb5_fcc_read_int32(id, &int32);
+     kret = krb5_fcc_read_int32(context, id, &int32);
      CHECK(kret);
-     addr->length = int32;
+     if ((int32 & VALID_INT_BITS) != int32)     /* Overflow int??? */
+         return KRB5_CC_NOMEM;
+     addr->length = (int) int32;
 
      if (addr->length == 0)
             return KRB5_OK;
@@ -286,7 +306,7 @@ krb5_fcc_read_addr(id, addr)
      if (addr->contents == NULL)
          return KRB5_CC_NOMEM;
 
-     kret = krb5_fcc_read(id, addr->contents, addr->length);
+     kret = krb5_fcc_read(context, id, addr->contents, addr->length);
      CHECK(kret);
 
      return KRB5_OK;
@@ -297,28 +317,35 @@ krb5_fcc_read_addr(id, addr)
 }
 
 krb5_error_code
-krb5_fcc_read_int32(id, i)
+krb5_fcc_read_int32(context, id, i)
+   krb5_context context;
    krb5_ccache id;
    krb5_int32 *i;
 {
     krb5_fcc_data *data = (krb5_fcc_data *)id->data;
     krb5_error_code retval;
     unsigned char buf[4];
+    krb5_int32 val;
 
     if ((data->version == KRB5_FCC_FVNO_1) ||
        (data->version == KRB5_FCC_FVNO_2)) 
-       return krb5_fcc_read(id, (krb5_pointer) i, sizeof(krb5_int32));
+       return krb5_fcc_read(context, id, (krb5_pointer) i, sizeof(krb5_int32));
     else {
-       retval = krb5_fcc_read(id, buf, 4);
+       retval = krb5_fcc_read(context, id, buf, 4);
        if (retval)
            return retval;
-       *i = (((((buf[0] << 8) + buf[1]) << 8 ) + buf[2]) << 8) + buf[3];
+        val = buf[0];
+        val = (val << 8) | buf[1];
+        val = (val << 8) | buf[2];
+        val = (val << 8) | buf[3];
+        *i = val;
        return 0;
     }
 }
 
 krb5_error_code
-krb5_fcc_read_ui_2(id, i)
+krb5_fcc_read_ui_2(context, id, i)
+   krb5_context context;
    krb5_ccache id;
    krb5_ui_2 *i;
 {
@@ -328,9 +355,9 @@ krb5_fcc_read_ui_2(id, i)
     
     if ((data->version == KRB5_FCC_FVNO_1) ||
        (data->version == KRB5_FCC_FVNO_2))
-       return krb5_fcc_read(id, (krb5_pointer) i, sizeof(krb5_ui_2));
+       return krb5_fcc_read(context, id, (krb5_pointer) i, sizeof(krb5_ui_2));
     else {
-       retval = krb5_fcc_read(id, buf, 2);
+       retval = krb5_fcc_read(context, id, buf, 2);
        if (retval)
            return retval;
        *i = (buf[0] << 8) + buf[1];
@@ -339,16 +366,18 @@ krb5_fcc_read_ui_2(id, i)
 }    
 
 krb5_error_code
-krb5_fcc_read_octet(id, i)
+krb5_fcc_read_octet(context, id, i)
+   krb5_context context;
    krb5_ccache id;
    krb5_octet *i;
 {
-    return krb5_fcc_read(id, (krb5_pointer) i, 1);
+    return krb5_fcc_read(context, id, (krb5_pointer) i, 1);
 }    
 
 
 krb5_error_code
-krb5_fcc_read_times(id, t)
+krb5_fcc_read_times(context, id, t)
+   krb5_context context;
    krb5_ccache id;
    krb5_ticket_times *t;
 {
@@ -358,21 +387,21 @@ krb5_fcc_read_times(id, t)
     
     if ((data->version == KRB5_FCC_FVNO_1) ||
        (data->version == KRB5_FCC_FVNO_2))
-       return krb5_fcc_read(id, (krb5_pointer) t, sizeof(krb5_ticket_times));
+       return krb5_fcc_read(context, id, (krb5_pointer) t, sizeof(krb5_ticket_times));
     else {
-       retval = krb5_fcc_read_int32(id, &i);
+       retval = krb5_fcc_read_int32(context, id, &i);
        CHECK(retval);
        t->authtime = i;
        
-       retval = krb5_fcc_read_int32(id, &i);
+       retval = krb5_fcc_read_int32(context, id, &i);
        CHECK(retval);
        t->starttime = i;
 
-       retval = krb5_fcc_read_int32(id, &i);
+       retval = krb5_fcc_read_int32(context, id, &i);
        CHECK(retval);
        t->endtime = i;
 
-       retval = krb5_fcc_read_int32(id, &i);
+       retval = krb5_fcc_read_int32(context, id, &i);
        CHECK(retval);
        t->renew_till = i;
     }
@@ -382,18 +411,19 @@ errout:
 }
 
 krb5_error_code
-krb5_fcc_read_authdata(id, a)
+krb5_fcc_read_authdata(context, id, a)
+   krb5_context context;
     krb5_ccache id;
     krb5_authdata ***a;
 {
      krb5_error_code kret;
-     krb5_int32 length;
+     krb5_int32 length, msize;
      int i;
 
      *a = 0;
 
      /* Read the number of components */
-     kret = krb5_fcc_read_int32(id, &length);
+     kret = krb5_fcc_read_int32(context, id, &length);
      CHECK(kret);
 
      if (length == 0)
@@ -402,44 +432,51 @@ krb5_fcc_read_authdata(id, a)
      /* Make *a able to hold length pointers to krb5_authdata structs
       * Add one extra for a null-terminated list
       */
-     *a = (krb5_authdata **) calloc(length+1, sizeof(krb5_authdata *));
+     msize = length+1;
+     if ((msize & VALID_UINT_BITS) != msize)    /* Overflow size_t??? */
+         return KRB5_CC_NOMEM;
+     *a = (krb5_authdata **) calloc((size_t) msize, sizeof(krb5_authdata *));
      if (*a == NULL)
          return KRB5_CC_NOMEM;
 
      for (i=0; i < length; i++) {
          (*a)[i] = (krb5_authdata *) malloc(sizeof(krb5_authdata));
          if ((*a)[i] == NULL) {
-             krb5_free_authdata(*a);
+             krb5_free_authdata(context, *a);
              return KRB5_CC_NOMEM;
          }       
-         kret = krb5_fcc_read_authdatum(id, (*a)[i]);
+         kret = krb5_fcc_read_authdatum(context, id, (*a)[i]);
          CHECK(kret);
      }
 
      return KRB5_OK;
  errout:
      if (*a)
-        krb5_free_authdata(*a);
+        krb5_free_authdata(context, *a);
      return kret;
 }
 
 krb5_error_code
-krb5_fcc_read_authdatum(id, a)
+krb5_fcc_read_authdatum(context, id, a)
+   krb5_context context;
     krb5_ccache id;
     krb5_authdata *a;
 {
     krb5_error_code kret;
     krb5_int32 int32;
-    int ret;
+    krb5_ui_2 ui2;
     
     a->magic = KV5M_AUTHDATA;
     a->contents = NULL;
 
-    kret = krb5_fcc_read_ui_2(id, &a->ad_type);
+    kret = krb5_fcc_read_ui_2(context, id, &ui2);
     CHECK(kret);
-    kret = krb5_fcc_read_int32(id, &int32);
+    a->ad_type = (krb5_authdatatype)ui2;
+    kret = krb5_fcc_read_int32(context, id, &int32);
     CHECK(kret);
-    a->length = int32;
+    if ((int32 & VALID_INT_BITS) != int32)     /* Overflow int??? */
+          return KRB5_CC_NOMEM;
+    a->length = (int) int32;
     
     if (a->length == 0 )
            return KRB5_OK;
@@ -448,7 +485,7 @@ krb5_fcc_read_authdatum(id, a)
     if (a->contents == NULL)
        return KRB5_CC_NOMEM;
 
-    kret = krb5_fcc_read(id, a->contents, a->length);
+    kret = krb5_fcc_read(context, id, a->contents, a->length);
     CHECK(kret);
     
      return KRB5_OK;