![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to adsp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netat|
Return to adsp.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: #define RESOLVE_DBG
26: #include <adsp_local.h>
27: #include "adsp_ioctl.h"
28:
29: #ifdef notdefn
30: struct adsp_debug adsp_dtable[1025];
31: int ad_entry = 0;
32: #endif
33:
34: extern atlock_t adspgen_lock;
35:
36: adspAllocateCCB(gref)
37: register gref_t *gref; /* READ queue */
38: {
39: gbuf_t *ccb_mp;
40: register CCBPtr sp;
41:
42: if (!(ccb_mp = gbuf_alloc(sizeof(CCB), PRI_LO))) {
43: return (0);
44: }
45: bzero((caddr_t) gbuf_rptr(ccb_mp), sizeof(CCB));
46: gbuf_wset(ccb_mp,sizeof(CCB));
47: gref->info = (caddr_t) ccb_mp;
48: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
49:
50: sp->pid = gref->pid; /* save the caller process pointer */
51: sp->gref = gref; /* save a back pointer to the WRITE queue */
52: sp->sp_mp = ccb_mp; /* and its message block */
53: ATLOCKINIT(sp->lock);
54: ATLOCKINIT(sp->lockClose);
55: ATLOCKINIT(sp->lockRemove);
56: return 1;
57: }
58:
59: adspRelease(gref)
60: register gref_t *gref; /* READ queue */
61: {
62: register CCBPtr sp;
63: register gbuf_t *mp;
64: int s, l;
65:
66: ATDISABLE(l, adspgen_lock);
67: if (gref->info) {
68: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
69: ATDISABLE(s, sp->lock);
70: ATENABLE(s, adspgen_lock);
71: /* Tells completion routine of close */
72: /* packet to remove us. */
73:
74: if (sp->state == sPassive || sp->state == sClosed ||
75: sp->state == sOpening || sp->state == sListening) {
76: ATENABLE(l, sp->lock);
77: if (sp->state == sListening)
78: CompleteQueue(&sp->opb, errAborted);
79: sp->removing = 1; /* Prevent allowing another dspClose. */
80: DoClose(sp, errAborted, 0); /* will remove CCB */
81: return 0;
82: } else { /* sClosing & sOpen */
83: sp->state = sClosing;
84: }
85: ATENABLE(l, sp->lock);
86:
87: if (CheckOkToClose(sp)) { /* going to close */
88: sp->sendCtl = B_CTL_CLOSE; /* Send close advice */
89: } else {
90: CheckSend(sp); /* try one more time to send out data */
91: if (sp->state != sClosed)
92: sp->sendCtl = B_CTL_CLOSE; /* Setup to send close advice */
93: }
94: CheckSend(sp); /* and force out the close */
95: ATDISABLE(s, sp->lock);
96: sp->removing = 1; /* Prevent allowing another dspClose. */
97: sp->state = sClosed;
98: ATENABLE(s, sp->lock);
99: DoClose(sp, errAborted, 0); /* to closed and remove CCB */
100: } else
101: ATENABLE(l, adspgen_lock);
102: }
103:
104:
105:
106:
107: adspWriteHandler(gref, mp)
108: gref_t *gref; /* WRITE queue */
109: gbuf_t *mp;
110: {
111:
112: register ioc_t *iocbp;
113: register struct adspcmd *ap;
114: int error, flag;
115: void *sp;
116:
117: switch(gbuf_type(mp)) {
118: case MSG_DATA:
119: if (gref->info == 0) {
120: gbuf_freem(mp);
121: return(STR_IGNORE);
122: }
123: /*
124: * Fill in the global stuff
125: */
126: ap = (struct adspcmd *)gbuf_rptr(mp);
127: ap->gref = gref;
128: ap->ioc = 0;
129: ap->mp = mp;
130: sp = (void *)gbuf_rptr(((gbuf_t *)gref->info));
131: switch(ap->csCode) {
132: case dspWrite:
133: if (error = adspWrite(sp, ap))
134: gbuf_freem(mp);
135: return(STR_IGNORE);
136: case dspAttention:
137: if (error = adspAttention(sp, ap))
138: gbuf_freem(mp);
139: return(STR_IGNORE);
140: }
141: case MSG_IOCTL:
142: if (gref->info == 0) {
143: adspioc_ack(EPROTO, mp, gref);
144: return(STR_IGNORE);
145: }
146: iocbp = (ioc_t *) gbuf_rptr(mp);
147: if (ADSP_IOCTL(iocbp->ioc_cmd)) {
148: iocbp->ioc_count = sizeof(*ap) - 1;
149: if (gbuf_cont(mp) == 0) {
150: adspioc_ack(EINVAL, mp, gref);
151: return(STR_IGNORE);
152: }
153: ap = (struct adspcmd *) gbuf_rptr(gbuf_cont(mp));
154: ap->gref = gref;
155: ap->ioc = (caddr_t) mp;
156: ap->mp = gbuf_cont(mp); /* request head */
157: ap->ioResult = 0;
158:
159: if ((gref->info == 0) && ((iocbp->ioc_cmd != ADSPOPEN) &&
160: (iocbp->ioc_cmd != ADSPCLLISTEN))) {
161: ap->ioResult = errState;
162:
163: adspioc_ack(EINVAL, mp, gref);
164: return(STR_IGNORE);
165: }
166: }
167: sp = (void *)gbuf_rptr(((gbuf_t *)gref->info));
168: switch(iocbp->ioc_cmd) {
169: case ADSPOPEN:
170: case ADSPCLLISTEN:
171: ap->socket = ((CCBPtr)sp)->localSocket;
172: flag = (adspMode(ap) == ocAccept) ? 1 : 0;
173: if (flag && ap->socket) {
174: if (adspDeassignSocket((CCBPtr)sp) >= 0)
175: ap->socket = 0;
176: }
177: if ((ap->socket == 0) &&
178: ((ap->socket = (at_socket)adspAssignSocket(gref, flag)) == 0)) {
179: adspioc_ack(EADDRNOTAVAIL, mp, gref);
180: return(STR_IGNORE);
181: }
182: ap->csCode = iocbp->ioc_cmd == ADSPOPEN ? dspInit : dspCLInit;
183: if ((error =
184: adspInit(sp, ap)) == 0) {
185: switch(ap->csCode) {
186: case dspInit:
187: /* and open the connection */
188: ap->csCode = dspOpen;
189: error = adspOpen(sp, ap);
190: break;
191: case dspCLInit:
192: /* ADSPCLLISTEN */
193: ap->csCode = dspCLListen;
194: error = adspCLListen(sp, ap);
195: break;
196: }
197: }
198: if (error)
199: adspioc_ack(error, mp, gref); /* if this failed req complete */
200: return(STR_IGNORE);
201: case ADSPCLOSE:
202: ap->csCode = dspClose;
203: if (error = adspClose(sp, ap)) {
204: adspioc_ack(error, mp, gref);
205: break;
206: }
207: break;
208: case ADSPCLREMOVE:
209: ap->csCode = dspCLRemove;
210: error = adspClose(sp, ap);
211: adspioc_ack(error, mp, gref);
212: return(STR_IGNORE);
213: case ADSPCLDENY:
214: ap->csCode = dspCLDeny;
215: if (error = adspCLDeny(sp, ap)) {
216: adspioc_ack(error, mp, gref);
217: }
218: return(STR_IGNORE);
219: case ADSPSTATUS:
220: ap->csCode = dspStatus;
221: if (error = adspStatus(sp, ap)) {
222: adspioc_ack(error, mp, gref);
223: }
224: return(STR_IGNORE);
225: case ADSPREAD:
226: ap->csCode = dspRead;
227: if (error = adspRead(sp, ap)) {
228: adspioc_ack(error, mp, gref);
229: }
230: return(STR_IGNORE);
231: case ADSPATTENTION:
232: ap->csCode = dspAttention;
233: if (error = adspReadAttention(sp, ap)) {
234: adspioc_ack(error, mp, gref);
235: }
236: return(STR_IGNORE);
237: case ADSPOPTIONS:
238: ap->csCode = dspOptions;
239: if (error = adspOptions(sp, ap)) {
240: adspioc_ack(error, mp, gref);
241: }
242: return(STR_IGNORE);
243: case ADSPRESET:
244: ap->csCode = dspReset;
245: if (error = adspReset(sp, ap)) {
246: adspioc_ack(error, mp, gref);
247: }
248: return(STR_IGNORE);
249: case ADSPNEWCID:
250: ap->csCode = dspNewCID;
251: if (error = adspNewCID(sp, ap)) {
252: adspioc_ack(error, mp, gref);
253: }
254: return(STR_IGNORE);
255: default:
256: return(STR_PUTNEXT); /* pass it on down */
257: }
258: return(STR_IGNORE);
259: case MSG_PROTO:
260: default:
261: gbuf_freem(mp);
262: }
263: }
264:
265:
266: adspReadHandler(gref, mp)
267: gref_t *gref;
268: gbuf_t *mp;
269: {
270: int error;
271:
272: switch(gbuf_type(mp)) {
273: case MSG_DATA:
274: if (error = adspPacket(gref, mp)) {
275: gbuf_freem(mp);
276: }
277: break;
278:
279: case MSG_IOCTL:
280: default:
281: return(STR_PUTNEXT);
282: break;
283: }
284: return(STR_IGNORE);
285: }
286:
287: /*
288: * adsp_sendddp()
289: *
290: * Description:
291: * This procedure a formats a DDP datagram header and calls the
292: * DDP module to queue it for routing and transmission according to
293: * the DDP parameters. We always take control of the datagram;
294: * if there is an error we free it, otherwise we pass it to the next
295: * layer. We don't need to set the src address fileds because the
296: * DDP layer fills these in for us.
297: *
298: * Calling Sequence:
299: * ret_status = adsp_sendddp(q, sp, mp, length, dstnetaddr, ddptype);
300: *
301: * Formal Parameters:
302: * sp Caller stream pointer
303: * mp gbuf_t chain containing the datagram to transmit
304: * The first mblk contains the ADSP header and space
305: * for the DDP header.
306: * length size of data portion of datagram
307: * dstnetaddr address of 4-byte destination internet address
308: * ddptype DDP protocol to assign to the datagram
309: *
310: * Completion Status:
311: * 0 Procedure successful completed.
312: * EMSGSIZE Specified datagram length is too big.
313: *
314: * Side Effects:
315: * NONE
316: */
317:
318: adsp_sendddp(sp, mp, length, dstnetaddr, ddptype)
319: CCBPtr sp;
320: gbuf_t *mp;
321: int length;
322: AddrUnion *dstnetaddr;
323: int ddptype;
324: {
325: DDPX_FRAME *ddp;
326: gbuf_t *mlist = mp;
327:
328: if (mp == 0)
329: return EINVAL;
330:
331: if (length > DDP_DATA_SIZE) {
332: gbuf_freel(mlist);
333: return EMSGSIZE;
334: }
335:
336: while (mp) {
337:
338: if (length == 0)
339: length = gbuf_msgsize(mp) - DDPL_FRAME_LEN;
340: /* Set up the DDP header */
341:
342: ddp = (DDPX_FRAME *) gbuf_rptr(mp);
343: UAS_ASSIGN(ddp->ddpx_length, (length + DDPL_FRAME_LEN));
344: UAS_ASSIGN(ddp->ddpx_cksm, 0);
345: if (sp) {
346: if (sp->useCheckSum)
347: UAS_ASSIGN(ddp->ddpx_cksm, 1);
348: }
349:
350: NET_NET(ddp->ddpx_dnet, dstnetaddr->a.net);
351: ddp->ddpx_dnode = dstnetaddr->a.node;
352: ddp->ddpx_source = sp ? sp->localSocket : ddp->ddpx_dest;
353: ddp->ddpx_dest = dstnetaddr->a.socket;
354:
355: ddp->ddpx_type = ddptype;
356: length = 0;
357: mp = gbuf_next(mp);
358:
359: }
360:
361: DDP_OUTPUT(mlist);
362: return 0;
363: }
364:
365: void NotifyUser(sp)
366: register CCBPtr sp;
367:
368: {
369: /*
370: pidsig(sp->pid, SIGIO);
371: */
372: }
373:
374: void UrgentUser(sp)
375: register CCBPtr sp;
376: {
377: /*
378: pidsig(sp->pid, SIGURG);
379: */
380: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.