1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 23 /* 24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 /* 30 * Portions of this source code were derived from Berkeley 31 * 4.3 BSD under license from the Regents of the University of 32 * California. 33 */ 34 35 #pragma ident "%Z%%M% %I% %E% SMI" 36 37 /* 38 * svc_raw.c, This a toy for simple testing and timing. 39 * Interface to create an rpc client and server in the same UNIX process. 40 * This lets us similate rpc and get rpc (round trip) overhead, without 41 * any interference from the kernal. 42 * 43 */ 44 45 #include "mt.h" 46 #include "rpc_mt.h" 47 #include <stdlib.h> 48 #include <rpc/rpc.h> 49 #include <sys/types.h> 50 #include <rpc/raw.h> 51 #include <syslog.h> 52 53 #ifndef UDPMSGSIZE 54 #define UDPMSGSIZE 8800 55 #endif 56 57 /* 58 * This is the "network" that we will be moving data over 59 */ 60 static struct svc_raw_private { 61 char *raw_buf; /* should be shared with the cl handle */ 62 SVCXPRT *server; 63 XDR xdr_stream; 64 char verf_body[MAX_AUTH_BYTES]; 65 } *svc_raw_private; 66 67 static struct xp_ops *svc_raw_ops(); 68 extern mutex_t svcraw_lock; 69 70 71 72 SVCXPRT * 73 svc_raw_create(void) 74 { 75 struct svc_raw_private *srp; 76 bool_t flag1 = FALSE, flag2 = FALSE; 77 78 /* VARIABLES PROTECTED BY svcraw_lock: svc_raw_private, srp */ 79 (void) mutex_lock(&svcraw_lock); 80 srp = svc_raw_private; 81 if (srp == NULL) { 82 srp = calloc(1, sizeof (*srp)); 83 if (srp == NULL) { 84 syslog(LOG_ERR, "svc_raw_create: out of memory"); 85 (void) mutex_unlock(&svcraw_lock); 86 return (NULL); 87 } 88 flag1 = TRUE; 89 if (_rawcombuf == NULL) { 90 _rawcombuf = calloc(UDPMSGSIZE, sizeof (char)); 91 if (_rawcombuf == NULL) { 92 free(srp); 93 syslog(LOG_ERR, "svc_raw_create: " 94 "out of memory"); 95 (void) mutex_unlock(&svcraw_lock); 96 return (NULL); 97 } 98 flag2 = TRUE; 99 } 100 srp->raw_buf = _rawcombuf; /* Share it with the client */ 101 svc_raw_private = srp; 102 } 103 if ((srp->server = svc_xprt_alloc()) == NULL) { 104 if (flag2) 105 free(svc_raw_private->raw_buf); 106 if (flag1) 107 free(svc_raw_private); 108 (void) mutex_unlock(&svcraw_lock); 109 return (NULL); 110 } 111 /* 112 * By convention, using FD_SETSIZE as the psuedo file descriptor 113 */ 114 srp->server->xp_fd = FD_SETSIZE; 115 srp->server->xp_port = 0; 116 srp->server->xp_ops = svc_raw_ops(); 117 srp->server->xp_verf.oa_base = srp->verf_body; 118 xdrmem_create(&srp->xdr_stream, srp->raw_buf, UDPMSGSIZE, XDR_DECODE); 119 xprt_register(srp->server); 120 (void) mutex_unlock(&svcraw_lock); 121 return (srp->server); 122 } 123 124 /*ARGSUSED*/ 125 static enum xprt_stat 126 svc_raw_stat(SVCXPRT *xprt) 127 { 128 return (XPRT_IDLE); 129 } 130 131 /*ARGSUSED*/ 132 static bool_t 133 svc_raw_recv(SVCXPRT *xprt, struct rpc_msg *msg) 134 { 135 struct svc_raw_private *srp; 136 XDR *xdrs; 137 138 (void) mutex_lock(&svcraw_lock); 139 srp = svc_raw_private; 140 if (srp == NULL) { 141 (void) mutex_unlock(&svcraw_lock); 142 return (FALSE); 143 } 144 (void) mutex_unlock(&svcraw_lock); 145 146 xdrs = &srp->xdr_stream; 147 xdrs->x_op = XDR_DECODE; 148 (void) XDR_SETPOS(xdrs, 0); 149 return (xdr_callmsg(xdrs, msg)); 150 } 151 152 /*ARGSUSED*/ 153 static bool_t 154 svc_raw_reply(SVCXPRT *xprt, struct rpc_msg *msg) 155 { 156 struct svc_raw_private *srp; 157 XDR *xdrs; 158 159 (void) mutex_lock(&svcraw_lock); 160 srp = svc_raw_private; 161 if (srp == NULL) { 162 (void) mutex_unlock(&svcraw_lock); 163 return (FALSE); 164 } 165 (void) mutex_unlock(&svcraw_lock); 166 167 xdrs = &srp->xdr_stream; 168 xdrs->x_op = XDR_ENCODE; 169 (void) XDR_SETPOS(xdrs, 0); 170 return (xdr_replymsg(xdrs, msg)); 171 } 172 173 /*ARGSUSED*/ 174 static bool_t 175 svc_raw_getargs(SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr) 176 { 177 struct svc_raw_private *srp; 178 179 (void) mutex_lock(&svcraw_lock); 180 srp = svc_raw_private; 181 if (srp == NULL) { 182 (void) mutex_unlock(&svcraw_lock); 183 return (FALSE); 184 } 185 (void) mutex_unlock(&svcraw_lock); 186 return ((*xdr_args)(&srp->xdr_stream, args_ptr)); 187 } 188 189 /*ARGSUSED*/ 190 static bool_t 191 svc_raw_freeargs(SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr) 192 { 193 struct svc_raw_private *srp; 194 XDR *xdrs; 195 196 (void) mutex_lock(&svcraw_lock); 197 srp = svc_raw_private; 198 if (srp == NULL) { 199 (void) mutex_unlock(&svcraw_lock); 200 return (FALSE); 201 } 202 (void) mutex_unlock(&svcraw_lock); 203 204 xdrs = &srp->xdr_stream; 205 xdrs->x_op = XDR_FREE; 206 return ((*xdr_args)(xdrs, args_ptr)); 207 } 208 209 /*ARGSUSED*/ 210 static void 211 svc_raw_destroy(SVCXPRT *xprt) 212 { 213 } 214 215 /*ARGSUSED*/ 216 static bool_t 217 svc_raw_control(SVCXPRT *xprt, const uint_t rq, void *in) 218 { 219 switch (rq) { 220 case SVCGET_XID: /* fall through for now */ 221 default: 222 return (FALSE); 223 } 224 } 225 226 static struct xp_ops * 227 svc_raw_ops(void) 228 { 229 static struct xp_ops ops; 230 extern mutex_t ops_lock; 231 232 /* VARIABLES PROTECTED BY ops_lock: ops */ 233 234 (void) mutex_lock(&ops_lock); 235 if (ops.xp_recv == NULL) { 236 ops.xp_recv = svc_raw_recv; 237 ops.xp_stat = svc_raw_stat; 238 ops.xp_getargs = svc_raw_getargs; 239 ops.xp_reply = svc_raw_reply; 240 ops.xp_freeargs = svc_raw_freeargs; 241 ops.xp_destroy = svc_raw_destroy; 242 ops.xp_control = svc_raw_control; 243 } 244 (void) mutex_unlock(&ops_lock); 245 return (&ops); 246 } 247