NFS: Fix a compile glitch on 64-bit systems

[safe/jmp/linux-2.6] / fs / ecryptfs / keystore.c

diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index 558d538..b550dea 100644 (file)
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -26,7 +26,6 @@
  */
 
 #include <linux/string.h>
-#include <linux/sched.h>
 #include <linux/syscalls.h>
 #include <linux/pagemap.h>
 #include <linux/key.h>
@@ -607,13 +606,13 @@ parse_tag_1_packet(struct ecryptfs_crypt_stat *crypt_stat,
        (*new_auth_tok)->session_key.flags |=
                ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
        (*new_auth_tok)->token_type = ECRYPTFS_PRIVATE_KEY;
-       ECRYPTFS_SET_FLAG((*new_auth_tok)->flags, ECRYPTFS_PRIVATE_KEY);
+       (*new_auth_tok)->flags |= ECRYPTFS_PRIVATE_KEY;
        /* TODO: Why are we setting this flag here? Don't we want the
         * userspace to decrypt the session key? */
-       ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
-                           ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
-       ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
-                           ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
+       (*new_auth_tok)->session_key.flags &=
+               ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
+       (*new_auth_tok)->session_key.flags &=
+               ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
        list_add(&auth_tok_list_item->list, auth_tok_list);
        goto out;
 out_free:
@@ -793,10 +792,10 @@ parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
        (*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
        /* TODO: Parametarize; we might actually want userspace to
         * decrypt the session key. */
-       ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
-                           ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
-       ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
-                           ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
+       (*new_auth_tok)->session_key.flags &=
+                           ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
+       (*new_auth_tok)->session_key.flags &=
+                           ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
        list_add(&auth_tok_list_item->list, auth_tok_list);
        goto out;
 out_free:
@@ -941,8 +940,7 @@ static int decrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
        int rc = 0;
 
        password_s_ptr = &auth_tok->token.password;
-       if (ECRYPTFS_CHECK_FLAG(password_s_ptr->flags,
-                               ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET))
+       if (password_s_ptr->flags & ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET)
                ecryptfs_printk(KERN_DEBUG, "Session key encryption key "
                                "set; skipping key generation\n");
        ecryptfs_printk(KERN_DEBUG, "Session key encryption key (size [%d])"
@@ -1024,7 +1022,7 @@ static int decrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
        auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
        memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
               auth_tok->session_key.decrypted_key_size);
-       ECRYPTFS_SET_FLAG(crypt_stat->flags, ECRYPTFS_KEY_VALID);
+       crypt_stat->flags |= ECRYPTFS_KEY_VALID;
        ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
        if (ecryptfs_verbosity > 0)
                ecryptfs_dump_hex(crypt_stat->key,
@@ -1127,8 +1125,7 @@ int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
                                        sig_tmp_space, tag_11_contents_size);
                        new_auth_tok->token.password.signature[
                                ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
-                       ECRYPTFS_SET_FLAG(crypt_stat->flags,
-                                         ECRYPTFS_ENCRYPTED);
+                       crypt_stat->flags |= ECRYPTFS_ENCRYPTED;
                        break;
                case ECRYPTFS_TAG_1_PACKET_TYPE:
                        rc = parse_tag_1_packet(crypt_stat,
@@ -1142,8 +1139,7 @@ int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
                                goto out_wipe_list;
                        }
                        i += packet_size;
-                       ECRYPTFS_SET_FLAG(crypt_stat->flags,
-                                         ECRYPTFS_ENCRYPTED);
+                       crypt_stat->flags |= ECRYPTFS_ENCRYPTED;
                        break;
                case ECRYPTFS_TAG_11_PACKET_TYPE:
                        ecryptfs_printk(KERN_WARNING, "Invalid packet set "
@@ -1209,8 +1205,7 @@ int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
        }
 leave_list:
        rc = -ENOTSUPP;
-       if ((ECRYPTFS_CHECK_FLAG(candidate_auth_tok->flags,
-                                ECRYPTFS_PRIVATE_KEY))) {
+       if (candidate_auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
                memcpy(&(candidate_auth_tok->token.private_key),
                       &(chosen_auth_tok->token.private_key),
                       sizeof(struct ecryptfs_private_key));
@@ -1643,6 +1638,8 @@ out:
        return rc;
 }
 
+struct kmem_cache *ecryptfs_key_record_cache;
+
 /**
  * ecryptfs_generate_key_packet_set
  * @dest: Virtual address from which to write the key record set
@@ -1669,50 +1666,55 @@ ecryptfs_generate_key_packet_set(char *dest_base,
                &ecryptfs_superblock_to_private(
                        ecryptfs_dentry->d_sb)->mount_crypt_stat;
        size_t written;
-       struct ecryptfs_key_record key_rec;
+       struct ecryptfs_key_record *key_rec;
        int rc = 0;
 
        (*len) = 0;
+       key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL);
+       if (!key_rec) {
+               rc = -ENOMEM;
+               goto out;
+       }
        if (mount_crypt_stat->global_auth_tok) {
                auth_tok = mount_crypt_stat->global_auth_tok;
                if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
                        rc = write_tag_3_packet((dest_base + (*len)),
                                                max, auth_tok,
-                                               crypt_stat, &key_rec,
+                                               crypt_stat, key_rec,
                                                &written);
                        if (rc) {
                                ecryptfs_printk(KERN_WARNING, "Error "
                                                "writing tag 3 packet\n");
-                               goto out;
+                               goto out_free;
                        }
                        (*len) += written;
                        /* Write auth tok signature packet */
                        rc = write_tag_11_packet(
                                (dest_base + (*len)),
                                (max - (*len)),
-                               key_rec.sig, ECRYPTFS_SIG_SIZE, &written);
+                               key_rec->sig, ECRYPTFS_SIG_SIZE, &written);
                        if (rc) {
                                ecryptfs_printk(KERN_ERR, "Error writing "
                                                "auth tok signature packet\n");
-                               goto out;
+                               goto out_free;
                        }
                        (*len) += written;
                } else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
                        rc = write_tag_1_packet(dest_base + (*len),
                                                max, auth_tok,
                                                crypt_stat,mount_crypt_stat,
-                                               &key_rec, &written);
+                                               key_rec, &written);
                        if (rc) {
                                ecryptfs_printk(KERN_WARNING, "Error "
                                                "writing tag 1 packet\n");
-                               goto out;
+                               goto out_free;
                        }
                        (*len) += written;
                } else {
                        ecryptfs_printk(KERN_WARNING, "Unsupported "
                                        "authentication token type\n");
                        rc = -EINVAL;
-                       goto out;
+                       goto out_free;
                }
        } else
                BUG();
@@ -1722,6 +1724,9 @@ ecryptfs_generate_key_packet_set(char *dest_base,
                ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
                rc = -EIO;
        }
+
+out_free:
+       kmem_cache_free(ecryptfs_key_record_cache, key_rec);
 out:
        if (rc)
                (*len) = 0;