Fixes to compiler warnings in MSVC

firmware/lib/vboot_common.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Common functions between firmware and kernel verified boot.
  * (Firmware portion)
  */
 
 
 #include "vboot_common.h"
@@ skipping 94 matching lines @@
 }
 
 
 RSAPublicKey* PublicKeyToRSA(const VbPublicKey* key) {
   RSAPublicKey *rsa;
 
   if (kNumAlgorithms <= key->algorithm) {
     debug("Invalid algorithm.\n");
     return NULL;
   }
-  if (RSAProcessedKeySize(key->algorithm) != key->key_size) {
+  if (RSAProcessedKeySize((int)key->algorithm) != (int)key->key_size) {

[gauravsh, 2010/06/21 23:32:48]

so what is the data type for algorithm? I saw uint8_t used for RSAVerify(), it
is uint64_t in VbPublicKey (presumably for alignment), and it is an int here. 

We should be consistent here to easily trace overflow errors as this gets passed
around. 

     debug("Wrong key size for algorithm\n");
     return NULL;
   }
 
-  rsa = RSAPublicKeyFromBuf(GetPublicKeyDataC(key), key->key_size);
+  rsa = RSAPublicKeyFromBuf(GetPublicKeyDataC(key), (int)key->key_size);
   if (!rsa)
     return NULL;
 
-  rsa->algorithm = key->algorithm;
+  rsa->algorithm = (int)key->algorithm;
   return rsa;
 }
 
 
 int VerifyData(const uint8_t* data, const VbSignature *sig,
                const RSAPublicKey* key) {
 
   if (sig->sig_size != siglen_map[key->algorithm]) {
     debug("Wrong signature size for algorithm.\n");
     return 1;
@@ skipping 48 matching lines @@
     RSAPublicKey* rsa;
     int rv;
 
     sig = &block->key_block_signature;
 
     if (VerifySignatureInside(block, block->key_block_size, sig)) {
       debug("Key block signature off end of block\n");
       return VBOOT_KEY_BLOCK_INVALID;
     }
 
-    if (!((rsa = PublicKeyToRSA(key)))) {
+    rsa = PublicKeyToRSA(key);
+    if (!rsa) {
       debug("Invalid public key\n");
       return VBOOT_PUBLIC_KEY_INVALID;
     }
     rv = VerifyData((const uint8_t*)block, sig, rsa);
     RSAPublicKeyFree(rsa);
     if (rv)
       return VBOOT_KEY_BLOCK_SIGNATURE;
 
   } else {
     /* Check hash */
@@ skipping 128 matching lines @@
   /* Verify body signature is inside the block */
   if (VerifySignatureInside(preamble, preamble->preamble_size,
                             &preamble->body_signature)) {
     debug("Kernel body signature off end of preamble\n");
     return VBOOT_PREAMBLE_INVALID;
   }
 
   /* Success */
   return VBOOT_SUCCESS;
 }