xref: /titanic_44/usr/src/lib/libnsl/nsl/t_alloc.c (revision 3ee6e1231b28188bebd1d5bb4a32a673f5820322)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
23 /*	  All Rights Reserved  	*/
24 
25 /*
26  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 #include "mt.h"
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <stropts.h>
34 #include <sys/stream.h>
35 #define	_SUN_TPI_VERSION 2
36 #include <sys/tihdr.h>
37 #include <sys/timod.h>
38 #include <xti.h>
39 #include <stdio.h>
40 #include <errno.h>
41 #include <ucred.h>
42 #include <signal.h>
43 #include "tx.h"
44 
45 /*
46  * Function protoypes
47  */
48 static int _alloc_buf(struct netbuf *buf, t_scalar_t n, int fields,
49     int api_semantics, boolean_t option);
50 
51 char *
52 _tx_alloc(int fd, int struct_type, int fields, int api_semantics)
53 {
54 	struct strioctl strioc;
55 	struct T_info_ack info;
56 	union structptrs {
57 		char	*caddr;
58 		struct t_bind *bind;
59 		struct t_call *call;
60 		struct t_discon *dis;
61 		struct t_optmgmt *opt;
62 		struct t_unitdata *udata;
63 		struct t_uderr *uderr;
64 		struct t_info *info;
65 	} p;
66 	unsigned int dsize;
67 	struct _ti_user *tiptr;
68 	int retval, sv_errno;
69 	t_scalar_t optsize;
70 
71 	if ((tiptr = _t_checkfd(fd, 0, api_semantics)) == NULL)
72 		return (NULL);
73 	sig_mutex_lock(&tiptr->ti_lock);
74 
75 	/*
76 	 * Get size info for T_ADDR, T_OPT, and T_UDATA fields
77 	 */
78 	info.PRIM_type = T_INFO_REQ;
79 	strioc.ic_cmd = TI_GETINFO;
80 	strioc.ic_timout = -1;
81 	strioc.ic_len = (int)sizeof (struct T_info_req);
82 	strioc.ic_dp = (char *)&info;
83 	do {
84 		retval = ioctl(fd, I_STR, &strioc);
85 	} while (retval < 0 && errno == EINTR);
86 
87 	if (retval < 0) {
88 		sv_errno = errno;
89 		sig_mutex_unlock(&tiptr->ti_lock);
90 		t_errno = TSYSERR;
91 		errno = sv_errno;
92 		return (NULL);
93 	}
94 
95 	if (strioc.ic_len != (int)sizeof (struct T_info_ack)) {
96 		t_errno = TSYSERR;
97 		sig_mutex_unlock(&tiptr->ti_lock);
98 		errno = EIO;
99 		return (NULL);
100 	}
101 
102 
103 	/*
104 	 * Malloc appropriate structure and the specified
105 	 * fields within each structure.  Initialize the
106 	 * 'buf' and 'maxlen' fields of each.
107 	 */
108 	switch (struct_type) {
109 
110 	case T_BIND:
111 		if ((p.bind = calloc(1, sizeof (struct t_bind))) == NULL)
112 			goto errout;
113 		if (fields & T_ADDR) {
114 			if (_alloc_buf(&p.bind->addr,
115 			    info.ADDR_size,
116 			    fields, api_semantics, B_FALSE) < 0)
117 				goto errout;
118 		}
119 		sig_mutex_unlock(&tiptr->ti_lock);
120 		return ((char *)p.bind);
121 
122 	case T_CALL:
123 		if ((p.call = calloc(1, sizeof (struct t_call))) == NULL)
124 			goto errout;
125 		if (fields & T_ADDR) {
126 			if (_alloc_buf(&p.call->addr,
127 			    info.ADDR_size,
128 			    fields, api_semantics, B_FALSE) < 0)
129 				goto errout;
130 		}
131 		if (fields & T_OPT) {
132 			if (info.OPT_size >= 0 && _T_IS_XTI(api_semantics))
133 				/* compensate for XTI level options */
134 				optsize = info.OPT_size +
135 				    TX_XTI_LEVEL_MAX_OPTBUF;
136 			else
137 				optsize = info.OPT_size;
138 			if (_alloc_buf(&p.call->opt, optsize,
139 			    fields, api_semantics, B_TRUE) < 0)
140 				goto errout;
141 		}
142 		if (fields & T_UDATA) {
143 			dsize = _T_MAX((int)info.CDATA_size,
144 			    (int)info.DDATA_size);
145 			if (_alloc_buf(&p.call->udata, (t_scalar_t)dsize,
146 			    fields, api_semantics, B_FALSE) < 0)
147 				goto errout;
148 		}
149 		sig_mutex_unlock(&tiptr->ti_lock);
150 		return ((char *)p.call);
151 
152 	case T_OPTMGMT:
153 		if ((p.opt = calloc(1, sizeof (struct t_optmgmt))) == NULL)
154 			goto errout;
155 		if (fields & T_OPT) {
156 			if (info.OPT_size >= 0 && _T_IS_XTI(api_semantics))
157 				/* compensate for XTI level options */
158 				optsize = info.OPT_size +
159 				    TX_XTI_LEVEL_MAX_OPTBUF;
160 			else
161 				optsize = info.OPT_size;
162 			if (_alloc_buf(&p.opt->opt, optsize,
163 			    fields, api_semantics, B_TRUE) < 0)
164 				goto errout;
165 		}
166 		sig_mutex_unlock(&tiptr->ti_lock);
167 		return ((char *)p.opt);
168 
169 	case T_DIS:
170 		if ((p.dis = calloc(1, sizeof (struct t_discon))) == NULL)
171 			goto errout;
172 		if (fields & T_UDATA) {
173 			if (_alloc_buf(&p.dis->udata, info.DDATA_size,
174 			    fields, api_semantics, B_FALSE) < 0)
175 				goto errout;
176 		}
177 		sig_mutex_unlock(&tiptr->ti_lock);
178 		return ((char *)p.dis);
179 
180 	case T_UNITDATA:
181 		if ((p.udata = calloc(1, sizeof (struct t_unitdata))) == NULL)
182 			goto errout;
183 		if (fields & T_ADDR) {
184 			if (_alloc_buf(&p.udata->addr, info.ADDR_size,
185 			    fields, api_semantics, B_FALSE) < 0)
186 				goto errout;
187 		}
188 		if (fields & T_OPT) {
189 			if (info.OPT_size >= 0 && _T_IS_XTI(api_semantics))
190 				/* compensate for XTI level options */
191 				optsize = info.OPT_size +
192 				    TX_XTI_LEVEL_MAX_OPTBUF;
193 			else
194 				optsize = info.OPT_size;
195 			if (_alloc_buf(&p.udata->opt, optsize,
196 			    fields, api_semantics, B_TRUE) < 0)
197 				goto errout;
198 		}
199 		if (fields & T_UDATA) {
200 			if (_alloc_buf(&p.udata->udata, info.TSDU_size,
201 			    fields, api_semantics, B_FALSE) < 0)
202 				goto errout;
203 		}
204 		sig_mutex_unlock(&tiptr->ti_lock);
205 		return ((char *)p.udata);
206 
207 	case T_UDERROR:
208 		if ((p.uderr = calloc(1, sizeof (struct t_uderr))) == NULL)
209 			goto errout;
210 		if (fields & T_ADDR) {
211 			if (_alloc_buf(&p.uderr->addr, info.ADDR_size,
212 			    fields, api_semantics, B_FALSE) < 0)
213 				goto errout;
214 		}
215 		if (fields & T_OPT) {
216 			if (info.OPT_size >= 0 && _T_IS_XTI(api_semantics))
217 				/* compensate for XTI level options */
218 				optsize = info.OPT_size +
219 				    TX_XTI_LEVEL_MAX_OPTBUF;
220 			else
221 				optsize = info.OPT_size;
222 			if (_alloc_buf(&p.uderr->opt, optsize,
223 			    fields, api_semantics, B_FALSE) < 0)
224 				goto errout;
225 		}
226 		sig_mutex_unlock(&tiptr->ti_lock);
227 		return ((char *)p.uderr);
228 
229 	case T_INFO:
230 		if ((p.info = calloc(1, sizeof (struct t_info))) == NULL)
231 			goto errout;
232 		sig_mutex_unlock(&tiptr->ti_lock);
233 		return ((char *)p.info);
234 
235 	default:
236 		if (_T_IS_XTI(api_semantics)) {
237 			t_errno = TNOSTRUCTYPE;
238 			sig_mutex_unlock(&tiptr->ti_lock);
239 		} else {	/* TX_TLI_API */
240 			t_errno = TSYSERR;
241 			sig_mutex_unlock(&tiptr->ti_lock);
242 			errno = EINVAL;
243 		}
244 		return (NULL);
245 	}
246 
247 	/*
248 	 * Clean up. Set t_errno to TSYSERR.
249 	 * If it is because memory could not be allocated
250 	 * then errno already should have been set to
251 	 * ENOMEM
252 	 */
253 errout:
254 	if (p.caddr)
255 		(void) t_free(p.caddr, struct_type);
256 
257 	t_errno = TSYSERR;
258 	sig_mutex_unlock(&tiptr->ti_lock);
259 	return (NULL);
260 }
261 
262 static int
263 _alloc_buf(struct netbuf *buf, t_scalar_t n, int fields, int api_semantics,
264     boolean_t option)
265 {
266 	switch (n) {
267 	case T_INFINITE /* -1 */:
268 		if (_T_IS_XTI(api_semantics)) {
269 			buf->buf = NULL;
270 			buf->maxlen = 0;
271 			if (fields != T_ALL) {
272 				/*
273 				 * Do not return error
274 				 * if T_ALL is used.
275 				 */
276 				errno = EINVAL;
277 				return (-1);
278 			}
279 		} else if (option) { /* TX_TLI_API */
280 			static size_t infalloc;
281 
282 			/*
283 			 * retain TLI behavior; ucred_t can vary in size,
284 			 * we need to make sure that we can receive one.
285 			 */
286 			if (infalloc == 0) {
287 				size_t uc = ucred_size();
288 				if (uc < 1024/2)
289 					infalloc = 1024;
290 				else
291 					infalloc = uc + 1024/2;
292 			}
293 			if ((buf->buf = calloc(1, infalloc)) == NULL) {
294 				errno = ENOMEM;
295 				return (-1);
296 			} else
297 				buf->maxlen = infalloc;
298 		} else {	/* TX_TLI_API */
299 			/*
300 			 * retain TLI behavior
301 			 */
302 			if ((buf->buf = calloc(1, 1024)) == NULL) {
303 				errno = ENOMEM;
304 				return (-1);
305 			} else
306 				buf->maxlen = 1024;
307 		}
308 		break;
309 
310 	case 0:
311 		buf->buf = NULL;
312 		buf->maxlen = 0;
313 		break;
314 
315 	case T_INVALID /* -2 */:
316 		if (_T_IS_XTI(api_semantics)) {
317 			buf->buf = NULL;
318 			buf->maxlen = 0;
319 			if (fields != T_ALL) {
320 				/*
321 				 * Do not return error
322 				 * if T_ALL is used.
323 				 */
324 				errno = EINVAL;
325 				return (-1);
326 			}
327 		} else {	/* TX_TLI_API */
328 			/*
329 			 * retain TLI behavior
330 			 */
331 			buf->buf = NULL;
332 			buf->maxlen = 0;
333 		}
334 		break;
335 
336 	default:
337 		if ((buf->buf = calloc(1, (size_t)n)) == NULL) {
338 			errno = ENOMEM;
339 			return (-1);
340 		} else
341 			buf->maxlen = n;
342 		break;
343 	}
344 	return (0);
345 }
346