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 *
_tx_alloc(int fd,int struct_type,int fields,int api_semantics)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
_alloc_buf(struct netbuf * buf,t_scalar_t n,int fields,int api_semantics,boolean_t option)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