reactos/dll/3rdparty/libtirpc/src/auth_none.c

   1 /*
   2  * Copyright (c) 2009, Sun Microsystems, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  * - Redistributions of source code must retain the above copyright notice,
   8  *   this list of conditions and the following disclaimer.
   9  * - Redistributions in binary form must reproduce the above copyright notice,
  10  *   this list of conditions and the following disclaimer in the documentation
  11  *   and/or other materials provided with the distribution.
  12  * - Neither the name of Sun Microsystems, Inc. nor the names of its
  13  *   contributors may be used to endorse or promote products derived
  14  *   from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*
  30 #if defined(LIBC_SCCS) && !defined(lint)
  31 static char *sccsid = "@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro";
  32 static char *sccsid = "@(#)auth_none.c  2.1 88/07/29 4.0 RPCSRC";
  33 #endif
  34 //#include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD: src/lib/libc/rpc/auth_none.c,v 1.12 2002/03/22 23:18:35 obrien Exp $");
  36 */
  37
  38
  39 /*
  40  * auth_none.c
  41  * Creates a client authentication handle for passing "null"
  42  * credentials and verifiers to remote systems.
  43  *
  44  * Copyright (C) 1984, Sun Microsystems, Inc.
  45  */
  46
  47 /* NFSv4.1 client for Windows
  48  * Copyright © 2012 The Regents of the University of Michigan
  49  *
  50  * Olga Kornievskaia <aglo@umich.edu>
  51  * Casey Bodley <cbodley@umich.edu>
  52  *
  53  * This library is free software; you can redistribute it and/or modify it
  54  * under the terms of the GNU Lesser General Public License as published by
  55  * the Free Software Foundation; either version 2.1 of the License, or (at
  56  * your option) any later version.
  57  *
  58  * This library is distributed in the hope that it will be useful, but
  59  * without any warranty; without even the implied warranty of merchantability
  60  * or fitness for a particular purpose.  See the GNU Lesser General Public
  61  * License for more details.
  62  *
  63  * You should have received a copy of the GNU Lesser General Public License
  64  * along with this library; if not, write to the Free Software Foundation,
  65  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  66  */
  67
  68 #include <wintirpc.h>
  69 //#include <pthread.h>
  70 #include <reentrant.h>
  71 #include <assert.h>
  72 #include <stdlib.h>
  73 #include <rpc/types.h>
  74 #include <rpc/xdr.h>
  75 #include <rpc/auth.h>
  76
  77 #define MAX_MARSHAL_SIZE 20
  78
  79 /*
  80  * Authenticator operations routines
  81  */
  82
  83 static bool_t authnone_marshal (AUTH *, XDR *, u_int *);
  84 static void authnone_verf (AUTH *);
  85 static bool_t authnone_validate (AUTH *, struct opaque_auth *, u_int);
  86 static bool_t authnone_refresh (AUTH *, void *);
  87 static void authnone_destroy (AUTH *);
  88
  89 extern bool_t xdr_opaque_auth();
  90
  91 static struct auth_ops *authnone_ops();
  92
  93 static struct authnone_private {
  94         AUTH    no_client;
  95         char    marshalled_client[MAX_MARSHAL_SIZE];
  96         u_int   mcnt;
  97 } *authnone_private;
  98
  99 AUTH *
 100 authnone_create()
 101 {
 102         struct authnone_private *ap = authnone_private;
 103         XDR xdr_stream;
 104         XDR *xdrs;
 105         extern mutex_t authnone_lock;
 106
 107         mutex_lock(&authnone_lock);
 108         if (ap == 0) {
 109                 ap = (struct authnone_private *)calloc(1, sizeof (*ap));
 110                 if (ap == 0) {
 111                         mutex_unlock(&authnone_lock);
 112                         return (0);
 113                 }
 114                 authnone_private = ap;
 115         }
 116         if (!ap->mcnt) {
 117                 ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
 118                 ap->no_client.ah_ops = authnone_ops();
 119                 xdrs = &xdr_stream;
 120                 xdrmem_create(xdrs, ap->marshalled_client,
 121                     (u_int)MAX_MARSHAL_SIZE, XDR_ENCODE);
 122                 (void)xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
 123                 (void)xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
 124                 ap->mcnt = XDR_GETPOS(xdrs);
 125                 XDR_DESTROY(xdrs);
 126         }
 127         mutex_unlock(&authnone_lock);
 128         return (&ap->no_client);
 129 }
 130
 131 /*ARGSUSED*/
 132 static bool_t
 133 authnone_marshal(AUTH *client, XDR *xdrs, u_int *seq)
 134 {
 135         struct authnone_private *ap;
 136         bool_t dummy;
 137         extern mutex_t authnone_lock;
 138
 139         assert(xdrs != NULL);
 140
 141         ap = authnone_private;
 142         if (ap == NULL) {
 143                 mutex_unlock(&authnone_lock);
 144                 return (FALSE);
 145         }
 146         dummy = (*xdrs->x_ops->x_putbytes)(xdrs,
 147             ap->marshalled_client, ap->mcnt);
 148         mutex_unlock(&authnone_lock);
 149         return (dummy);
 150 }
 151
 152 /* All these unused parameters are required to keep ANSI-C from grumbling */
 153 /*ARGSUSED*/
 154 static void
 155 authnone_verf(AUTH *client)
 156 {
 157 }
 158
 159 /*ARGSUSED*/
 160 static bool_t
 161 authnone_validate(AUTH *client, struct opaque_auth *opaque, u_int seq)
 162 {
 163
 164         return (TRUE);
 165 }
 166
 167 /*ARGSUSED*/
 168 static bool_t
 169 authnone_refresh(AUTH *client, void *dummy)
 170 {
 171
 172         return (FALSE);
 173 }
 174
 175 /*ARGSUSED*/
 176 static void
 177 authnone_destroy(AUTH *client)
 178 {
 179 }
 180
 181 static int
 182 authnone_wrap(AUTH *auth, XDR *xdrs, xdrproc_t func, caddr_t args)
 183 {
 184     return ((*func)(xdrs, args));
 185 }
 186
 187 static int
 188 authnone_unwrap(AUTH *auth, XDR *xdrs, xdrproc_t func, caddr_t args, u_int seq)
 189 {
 190     return ((*func)(xdrs, args));
 191 }
 192
 193 static struct auth_ops *
 194 authnone_ops()
 195 {
 196         static struct auth_ops ops;
 197         extern mutex_t ops_lock;
 198
 199 /* VARIABLES PROTECTED BY ops_lock: ops */
 200
 201         mutex_lock(&ops_lock);
 202         if (ops.ah_nextverf == NULL) {
 203                 ops.ah_nextverf = authnone_verf;
 204                 ops.ah_marshal = authnone_marshal;
 205                 ops.ah_validate = authnone_validate;
 206                 ops.ah_refresh = authnone_refresh;
 207                 ops.ah_destroy = authnone_destroy;
 208         ops.ah_wrap = authnone_wrap;
 209         ops.ah_unwrap = authnone_unwrap;
 210         }
 211         mutex_unlock(&ops_lock);
 212         return (&ops);
 213 }