root/net/ceph/auth_none.c

DEFINITIONS

1. reset
2. destroy
3. is_authenticated
4. should_authenticate
5. ceph_auth_none_build_authorizer
6. build_request
7. handle_reply
8. ceph_auth_none_destroy_authorizer
9. ceph_auth_none_create_authorizer
10. ceph_auth_none_init

   1 // SPDX-License-Identifier: GPL-2.0
   2 
   3 #include <linux/ceph/ceph_debug.h>
   4 
   5 #include <linux/err.h>
   6 #include <linux/module.h>
   7 #include <linux/random.h>
   8 #include <linux/slab.h>
   9 
  10 #include <linux/ceph/decode.h>
  11 #include <linux/ceph/auth.h>
  12 
  13 #include "auth_none.h"
  14 
  15 static void reset(struct ceph_auth_client *ac)
  16 {
  17         struct ceph_auth_none_info *xi = ac->private;
  18 
  19         xi->starting = true;
  20 }
  21 
  22 static void destroy(struct ceph_auth_client *ac)
  23 {
  24         kfree(ac->private);
  25         ac->private = NULL;
  26 }
  27 
  28 static int is_authenticated(struct ceph_auth_client *ac)
  29 {
  30         struct ceph_auth_none_info *xi = ac->private;
  31 
  32         return !xi->starting;
  33 }
  34 
  35 static int should_authenticate(struct ceph_auth_client *ac)
  36 {
  37         struct ceph_auth_none_info *xi = ac->private;
  38 
  39         return xi->starting;
  40 }
  41 
  42 static int ceph_auth_none_build_authorizer(struct ceph_auth_client *ac,
  43                                            struct ceph_none_authorizer *au)
  44 {
  45         void *p = au->buf;
  46         void *const end = p + sizeof(au->buf);
  47         int ret;
  48 
  49         ceph_encode_8_safe(&p, end, 1, e_range);
  50         ret = ceph_auth_entity_name_encode(ac->name, &p, end);
  51         if (ret < 0)
  52                 return ret;
  53 
  54         ceph_encode_64_safe(&p, end, ac->global_id, e_range);
  55         au->buf_len = p - (void *)au->buf;
  56         dout("%s built authorizer len %d\n", __func__, au->buf_len);
  57         return 0;
  58 
  59 e_range:
  60         return -ERANGE;
  61 }
  62 
  63 static int build_request(struct ceph_auth_client *ac, void *buf, void *end)
  64 {
  65         return 0;
  66 }
  67 
  68 /*
  69  * the generic auth code decode the global_id, and we carry no actual
  70  * authenticate state, so nothing happens here.
  71  */
  72 static int handle_reply(struct ceph_auth_client *ac, int result,
  73                         void *buf, void *end)
  74 {
  75         struct ceph_auth_none_info *xi = ac->private;
  76 
  77         xi->starting = false;
  78         return result;
  79 }
  80 
  81 static void ceph_auth_none_destroy_authorizer(struct ceph_authorizer *a)
  82 {
  83         kfree(a);
  84 }
  85 
  86 /*
  87  * build an 'authorizer' with our entity_name and global_id.  it is
  88  * identical for all services we connect to.
  89  */
  90 static int ceph_auth_none_create_authorizer(
  91         struct ceph_auth_client *ac, int peer_type,
  92         struct ceph_auth_handshake *auth)
  93 {
  94         struct ceph_none_authorizer *au;
  95         int ret;
  96 
  97         au = kmalloc(sizeof(*au), GFP_NOFS);
  98         if (!au)
  99                 return -ENOMEM;
 100 
 101         au->base.destroy = ceph_auth_none_destroy_authorizer;
 102 
 103         ret = ceph_auth_none_build_authorizer(ac, au);
 104         if (ret) {
 105                 kfree(au);
 106                 return ret;
 107         }
 108 
 109         auth->authorizer = (struct ceph_authorizer *) au;
 110         auth->authorizer_buf = au->buf;
 111         auth->authorizer_buf_len = au->buf_len;
 112         auth->authorizer_reply_buf = au->reply_buf;
 113         auth->authorizer_reply_buf_len = sizeof (au->reply_buf);
 114 
 115         return 0;
 116 }
 117 
 118 static const struct ceph_auth_client_ops ceph_auth_none_ops = {
 119         .name = "none",
 120         .reset = reset,
 121         .destroy = destroy,
 122         .is_authenticated = is_authenticated,
 123         .should_authenticate = should_authenticate,
 124         .build_request = build_request,
 125         .handle_reply = handle_reply,
 126         .create_authorizer = ceph_auth_none_create_authorizer,
 127 };
 128 
 129 int ceph_auth_none_init(struct ceph_auth_client *ac)
 130 {
 131         struct ceph_auth_none_info *xi;
 132 
 133         dout("ceph_auth_none_init %p\n", ac);
 134         xi = kzalloc(sizeof(*xi), GFP_NOFS);
 135         if (!xi)
 136                 return -ENOMEM;
 137 
 138         xi->starting = true;
 139 
 140         ac->protocol = CEPH_AUTH_NONE;
 141         ac->private = xi;
 142         ac->ops = &ceph_auth_none_ops;
 143         return 0;
 144 }