![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chsend.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / chaosld|
Return to chsend.c CVS log | Up to [Research Unix] / researchv8dc / sys / chaosld |
1.1 root 1: /*
2: * C H S E N D
3: *
4: * Chaosnet line discipline - routines to deal with sending out packets.
5: *
6: *
7: * (c) Copyright 1985 Nirvonics, Inc.
8: *
9: * Written by Kurt Gollhardt
10: * Last update Thu Feb 28 14:42:57 1985
11: *
12: * This software is the property of Nirvonics, Inc.
13: * All rights reserved.
14: *
15: */
16:
17: #include "ch.h"
18: #if NCH > 0
19: #include "../h/param.h"
20: #include "../h/systm.h"
21: #include "../h/stream.h"
22: #include "../h/conf.h"
23: #include "../chaosld/types.h"
24: #include "../chaosld/constants.h"
25: #include "../chaosld/globals.h"
26: #include "../chaosld/chrouteld.h"
27:
28: /*
29: * Send a STS packet on this connection
30: * if allocation fails it is not sent
31: */
32: sendsts(conn)
33: register struct connection *conn;
34: {
35: register struct packet *pkt;
36:
37: if ((pkt = new_packet()) != NOPKT) {
38: setconn(conn, pkt);
39: setsts(conn, pkt);
40: sendctl(pkt);
41: }
42: }
43:
44: /*
45: * Send a SNS packet on this connection
46: * if allocation failed nothing is sent
47: */
48: sendsns(conn)
49: register struct connection *conn;
50: {
51: register struct packet *pkt;
52:
53: if ((pkt = new_packet()) != NOPKT) {
54: setconn(conn, pkt);
55: pkt->pk_op = SNSOP;
56: setack(conn, pkt);
57: sendctl(pkt);
58: }
59: }
60:
61: /*
62: * Send an open in response to an RFC
63: */
64:
65: sendopn(conn)
66: register struct connection *conn;
67: {
68: register struct packet *pkt;
69:
70: if ((pkt = new_packet()) != NOPKT) {
71: conn->cn_rsts = conn->cn_rwsize >> 1;
72: conn->cn_tlast = 0;
73: setconn(conn, pkt);
74: setsts(conn, pkt);
75: pkt->pk_op = OPNOP;
76: chld_write(conn, pkt);
77: }
78: }
79:
80: /*
81: * Sendctl - send a control packet that will not be acknowledged and
82: * will not be retransmitted (this actual packet).
83: * If anything is wrong (no path, bad subnet) we just throw it
84: * away. Remember, next is assumed to be == NOPKT.
85: */
86: sendctl(pkt)
87: register struct packet *pkt;
88: {
89: register struct chroute *r;
90:
91: debug(DSEND, (printf("Sending: %d ", pkt->pk_op), prpkt(pkt, "ctl"), printf("\n")));
92: ch_busy++;
93: put_packet(WR(ChaosQ), pkt);
94: --ch_busy;
95: }
96:
97: /*
98: * Senddata - send a list of controlled packets.
99: * Similar to sendctl, but stuffs time, handles a list, and marks
100: * the packets as transmitted.
101: */
102: senddata(pkt)
103: register struct packet *pkt;
104: {
105: register struct packet *nextpk;
106:
107: debug(DSEND, (printf("Sending: %d ", pkt->pk_op), prpkt(pkt, "data"), printf("\n")));
108: ch_busy++;
109: do {
110: pkt->time = Chclock;
111: nextpk = pkt->next;
112: copy_packet(WR(ChaosQ), pkt);
113: xmitdone(pkt);
114: } while ((pkt = nextpk) != NOPKT);
115: --ch_busy;
116: }
117:
118: /*
119: * Send the given RUT packet out on the given tranceiver, which has the given
120: * cost. If the "copy" flag is true, make a copy of the packet.
121: * Note that if copy is not set, the packet data gets modified.
122: */
123: sendrut(pkt, ifp, cost, copy)
124: register struct packet *pkt;
125: register struct chif *ifp;
126: unsigned short cost;
127: int copy;
128: {
129: register struct rut_data *rd;
130: struct rut_data *rdend;
131:
132: pkt->pk_saddr = ifp->my_addr;
133: pkt->pk_daddr.ch_subnet = ifp->my_addr.ch_subnet;
134:
135: rdend = (struct rut_data *)(pkt->data->rptr + pkt->pk_len);
136: for (rd = (struct rut_data *)pkt->data->rptr; rd < rdend; rd++)
137: rd->rd_cost += cost;
138:
139: ch_busy++;
140: if (copy) {
141: copy_packet(WR(ChaosQ), pkt);
142: for (rd = (struct rut_data *)pkt->data->rptr; rd < rdend; rd++)
143: rd->rd_cost -= cost;
144: } else
145: put_packet(WR(ChaosQ), pkt);
146: --ch_busy;
147: }
148:
149: /*
150: * Send a LOS in response to the given packet.
151: * Don't bother if the packet is itself a LOS or a CLS since the other
152: * end doesn't care anyway and would only return it again.
153: * Append the host name to the error message.
154: */
155: sendlos(pkt, str, msglen)
156: register struct packet *pkt;
157: char *str;
158: int msglen;
159: {
160: if (pkt->pk_op == LOSOP || pkt->pk_op == CLSOP)
161: free_packet(pkt);
162: else {
163: register struct block *bp;
164: register char *cp;
165: register int namelen;
166:
167: for (namelen = 0, cp = Chmyname; *cp++;)
168: ++namelen;
169:
170: free_pkdata(pkt);
171: append_packet(pkt, str, msglen);
172: append_packet(pkt, " (from ", 7);
173: append_packet(pkt, Chmyname, namelen);
174: append_packet(pkt, ")", 1);
175:
176: pkt->pk_op = LOSOP;
177: reflect(pkt);
178: }
179: }
180:
181: /*
182: * Send a control packet back to its source
183: */
184: reflect(pkt)
185: register struct packet *pkt;
186: {
187: register short temp;
188:
189: temp = pkt->pk_sidx.ci_idx;
190: pkt->pk_sidx = pkt->pk_didx;
191: pkt->pk_didx.ci_idx = temp;
192: temp = pkt->pk_saddr.ch_addr;
193: pkt->pk_saddr = pkt->pk_daddr;
194: pkt->pk_daddr.ch_addr = temp;
195: sendctl(pkt);
196: }
197:
198: /*
199: * Indicate that actual transmission of the current packet has been completed.
200: * Note that this merely means that we've sent it on to the routing line
201: * discipline, and there's no guarantee that it's really gone anywhere.
202: *
203: * If this is a controlled packet and the connection is open, put the packet
204: * on the queue of transmitted packets awaiting acknowledgements, otherwise
205: * throw away the packet.
206: */
207: xmitdone(pkt)
208: register struct packet *pkt;
209: {
210: register struct connection *conn;
211: register struct packet *npkt;
212:
213: ch_busy++;
214: if (CONTROLLED(pkt) && pkt->pk_sidx.ci_tidx < NCH &&
215: (conn = Chconn[pkt->pk_sidx.ci_tidx]) != NOCONN &&
216: pkt->pk_sidx.ci_idx == conn->cn_lidx.ci_idx &&
217: (conn->cn_state == CSOPEN || conn->cn_state == CSRFCSENT) &&
218: cmp_gt(pkt->pk_pkn, conn->cn_trecvd)) {
219: pkt->time = Chclock;
220: if ((npkt = conn->cn_thead) == NOPKT ||
221: cmp_lt(pkt->pk_pkn, npkt->pk_pkn)) {
222: pkt->next = npkt;
223: conn->cn_thead = pkt;
224: } else {
225: for(; npkt->next != NOPKT; npkt = npkt->next)
226: if(cmp_lt(pkt->pk_pkn, npkt->next->pk_pkn))
227: break;
228: pkt->next = npkt->next;
229: npkt->next = pkt;
230: }
231: if(pkt->next == NOPKT)
232: conn->cn_ttail = pkt;
233: } else
234: free_packet(pkt);
235: --ch_busy;
236: }
237:
238: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.