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 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30
31 #pragma ident "%Z%%M% %I% %E% SMI" /* SVr4 1.8 */
32
33 /*
34 * This module establishes a unique connection on
35 * a STREAMS-based pipe.
36 */
37 #include <sys/types.h>
38 #include <sys/sysmacros.h>
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/errno.h>
42 #include <sys/signal.h>
43 #include <sys/user.h>
44 #include <sys/fstyp.h>
45 #include <sys/stropts.h>
46 #include <sys/stream.h>
47 #include <sys/strsubr.h>
48 #include <sys/vnode.h>
49 #include <sys/file.h>
50 #include <sys/fs/fifonode.h>
51 #include <sys/debug.h>
52 #include <sys/ddi.h>
53
54 /*
55 * This is the loadable module wrapper.
56 */
57 #include <sys/conf.h>
58 #include <sys/modctl.h>
59
60 extern struct streamtab conninfo;
61
62 static struct fmodsw fsw = {
63 "connld",
64 &conninfo,
65 D_NEW | D_MP
66 };
67
68 /*
69 * Module linkage information for the kernel.
70 */
71
72 static struct modlstrmod modlstrmod = {
73 &mod_strmodops, "Streams-based pipes", &fsw
74 };
75
76 static struct modlinkage modlinkage = {
77 MODREV_1, (void *)&modlstrmod, NULL
78 };
79
80 int
81 _init()
82 {
83 return (mod_install(&modlinkage));
84 }
85
86 int
87 _fini()
88 {
89 return (mod_remove(&modlinkage));
90 }
91
92 int
93 _info(struct modinfo *modinfop)
94 {
95 return (mod_info(&modlinkage, modinfop));
96 }
97
98 /*
99 * Define local and external routines.
100 */
101 int connopen(queue_t *, dev_t *, int, int, cred_t *);
102 int connclose(queue_t *, int, cred_t *);
103 int connput(queue_t *, mblk_t *);
104
105 /*
106 * Define STREAMS header information.
107 */
108 static struct module_info conn_info = {
109 1003,
110 "connld",
111 0,
112 INFPSZ,
113 STRHIGH,
114 STRLOW
115 };
116 static struct qinit connrinit = {
117 connput,
118 NULL,
119 connopen,
120 connclose,
121 NULL,
122 &conn_info,
123 NULL
124 };
125 static struct qinit connwinit = {
126 connput,
127 NULL,
128 NULL,
129 NULL,
130 NULL,
131 &conn_info,
132 NULL
133 };
134 struct streamtab conninfo = {
135 &connrinit,
136 &connwinit
137 };
138
139 /*
140 * For each invocation of connopen(), create a new pipe. One end of the pipe
141 * is sent to the process on the other end of this STREAM. The vnode for
142 * the other end is returned to the open() system call as the vnode for
143 * the opened object.
144 *
145 * On the first invocation of connopen(), a flag is set and the routine
146 * returns 0, since the first open corresponds to the pushing of the module.
147 */
148 /*ARGSUSED*/
149 int
150 connopen(queue_t *rqp, dev_t *devp, int flag, int sflag, cred_t *crp)
151 {
152 int error = 0;
153 vnode_t *streamvp;
154 fifonode_t *streamfnp;
155
156 if ((streamvp = strq2vp(rqp)) == NULL) {
157 return (EINVAL);
158 }
159
160 /*
161 * CONNLD is only allowed to be pushed onto a "pipe" that has both
162 * of its ends open.
163 */
164 if (streamvp->v_type != VFIFO) {
165 error = EINVAL;
166 goto out;
167 }
168
169 streamfnp = VTOF(streamvp);
170
171 if (!(streamfnp->fn_flag & ISPIPE) ||
172 streamfnp->fn_dest->fn_open == 0) {
173 error = EPIPE;
174 goto out;
175 }
176
177 /*
178 * If this is the first time CONNLD was opened while on this stream,
179 * it is being pushed. Therefore, set a flag and return 0.
180 */
181 if (rqp->q_ptr == 0) {
182 if (streamfnp->fn_flag & FIFOCONNLD) {
183 error = ENXIO;
184 goto out;
185 }
186 rqp->q_ptr = (caddr_t)1;
187 streamfnp->fn_flag |= FIFOCONNLD;
188 qprocson(rqp);
189 }
190 out:
191 VN_RELE(streamvp);
192 return (error);
193 }
194
195 /*ARGSUSED*/
196 int
197 connclose(queue_t *q, int cflag, cred_t *crp)
198 {
199 vnode_t *streamvp;
200 fifonode_t *streamfnp;
201
202 qprocsoff(q);
203 streamvp = strq2vp(q);
204
205 ASSERT(streamvp != NULL);
206 ASSERT(streamvp->v_type == VFIFO);
207
208 streamfnp = VTOF(streamvp);
209 streamfnp->fn_flag &= ~FIFOCONNLD;
210 VN_RELE(streamvp);
211 return (0);
212 }
213
214 /*
215 * Use same put procedure for write and read queues.
216 */
217 int
218 connput(queue_t *q, mblk_t *bp)
219 {
220 putnext(q, bp);
221 return (0);
222 }