Print this page
5218 posix definition of NULL
correct unistd.h and iso/stddef_iso.h
update gate source affected
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/bnu/interface.c
+++ new/usr/src/cmd/bnu/interface.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License, Version 1.0 only
6 6 * (the "License"). You may not use this file except in compliance
7 7 * with the License.
8 8 *
9 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 * or http://www.opensolaris.org/os/licensing.
11 11 * See the License for the specific language governing permissions
12 12 * and limitations under the License.
13 13 *
14 14 * When distributing Covered Code, include this CDDL HEADER in each
15 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 16 * If applicable, add the following below this CDDL HEADER, with the
17 17 * fields enclosed by brackets "[]" replaced with your own identifying
18 18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 19 *
20 20 * CDDL HEADER END
21 21 */
22 22 /*
23 23 * Copyright 2014 Gary Mills
24 24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
25 25 * Use is subject to license terms.
26 26 */
27 27
28 28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 29 /* All Rights Reserved */
30 30
31 31 /*
32 32 * interface(label)
33 33 * provide alternate definitions for the I/O functions through global
34 34 * interfaces.
35 35 */
36 36 #include "uucp.h"
37 37
38 38 #ifdef TLI
39 39 #include <tiuser.h>
40 40 char *t_alloc();
41 41 int t_bind(), t_close(), t_connect(), t_free(), t_look(), t_open(), t_rcvdis();
42 42 int t_getinfo(), t_getstate(), t_look(), t_rcv(), t_snd(), t_sync(), t_unbind();
43 43 #endif /* TLI */
44 44
45 45 #ifdef DATAKIT
46 46 #include "dk.h"
47 47
48 48 static int dksetup();
49 49 static int dkteardown();
50 50 #endif /* DATAKIT */
51 51
52 52 EXTERN void sethup();
53 53 EXTERN int restline();
54 54 #if defined(__STDC__)
55 55 extern int ioctl(int, int, ...);
56 56 #else
57 57 extern int ioctl();
58 58 #endif
59 59 static int usetup(), uteardown();
60 60
61 61 GLOBAL ssize_t (*Read)() = read,
62 62 (*Write)() = write;
63 63 #if defined(__STDC__)
64 64 GLOBAL int (*Ioctl)(int, int, ...) = ioctl,
65 65 #else
66 66 GLOBAL int (*Ioctl)() = ioctl,
67 67 #endif
68 68 (*Setup)() = usetup,
69 69 (*Teardown)() = uteardown;
70 70
71 71 #ifdef TLI
72 72 EXTERN void tfaillog(), show_tlook();
73 73 static ssize_t tread(), twrite(); /* TLI i/o */
74 74 #ifdef __STDC__
75 75 static int tioctl(int, int, ...),
76 76 #else
77 77 static int tioctl(), /* TLI i/o control */
78 78 #endif
79 79 tsetup(), /* TLI setup without streams module */
80 80 tssetup(), /* TLI setup with streams module */
81 81 tteardown(); /* TLI teardown, works with either setup */
82 82 #endif /* TLI */
83 83 /*
84 84 * The IN_label in Interface[] imply different caller routines:
85 85 * e.g. tlicall().
86 86 * If so, the names here and the names in callers.c must match.
87 87 */
88 88
89 89 static
90 90 struct Interface {
91 91 char *IN_label; /* interface name */
92 92 ssize_t (*IN_read)(); /* read function */
93 93 ssize_t (*IN_write)(); /* write function */
94 94 #ifdef __STDC__
95 95 int (*IN_ioctl)(int, int, ...);
96 96 #else
97 97 int (*IN_ioctl)(); /* ioctl function */
98 98 #endif
99 99 int (*IN_setup)(); /* setup function, called before */
100 100 /* first i/o operation */
101 101 int (*IN_teardown)(); /* teardown function, called after */
102 102 /* last i/o operation */
103 103 } Interface[] = {
104 104 /* vanilla UNIX */
105 105 { "UNIX", read, write, ioctl, usetup, uteardown },
106 106 #ifdef TCP
107 107 /* TCP over sockets or UNET */
108 108 { "TCP", read, write, ioctl, usetup, uteardown },
109 109 #endif /* TCP */
110 110 #ifdef SYTEK
111 111 /* Sytek network */
112 112 { "Sytek", read, write, ioctl, usetup, uteardown },
113 113 #endif /* Sytek network */
114 114 #ifdef DIAL801
115 115 /* 801 auto dialers */
116 116 { "801", read, write, ioctl, usetup, uteardown },
117 117 #endif /* DIAL801 */
118 118 #ifdef DIAL801
119 119 /* 212 auto dialers */
120 120 { "212", read, write, ioctl, usetup, uteardown },
121 121 #endif /* DIAL801 */
122 122 #ifdef TLI
123 123 /* AT&T Transport Interface Library WITHOUT streams */
124 124 { "TLI", tread, twrite, tioctl, tsetup, tteardown },
125 125 #ifdef TLIS
126 126 /* AT&T Transport Interface Library WITH streams */
127 127 { "TLIS", read, write, tioctl, tssetup, uteardown },
128 128 #endif /* TLIS */
129 129 #endif /* TLI */
130 130 #ifdef DATAKIT
131 131 { "DK", read, write, ioctl, dksetup, dkteardown },
132 132 #endif /* DATAKIT */
133 133 #ifdef UNET
134 134 { "Unetserver", read, write, ioctl, usetup, uteardown },
135 135 #endif
136 136 { 0, 0, 0, 0, 0, 0 }
137 137 };
138 138
139 139
140 140 GLOBAL int
141 141 interface(label)
142 142 char *label;
143 143 {
144 144 register int i;
145 145
146 146 for (i = 0; Interface[i].IN_label; ++i) {
147 147 if (0 == strcmp(Interface[i].IN_label, label)) {
148 148 Read = Interface[i].IN_read;
149 149 Write = Interface[i].IN_write;
150 150 Ioctl = Interface[i].IN_ioctl;
151 151 Setup = Interface[i].IN_setup;
152 152 Teardown = Interface[i].IN_teardown;
153 153 DEBUG(5, "set interface %s\n", label);
154 154 return (0);
155 155 }
156 156 }
157 157 return (FAIL);
158 158 }
159 159
160 160 /*
161 161 * usetup - vanilla unix setup routine
162 162 */
163 163 static int
164 164 usetup(role, fdreadp, fdwritep)
165 165 int *fdreadp, *fdwritep;
166 166 {
167 167 if (role == SLAVE)
168 168 {
169 169 *fdreadp = 0;
170 170 *fdwritep = 1;
171 171 /* 2 has been re-opened to RMTDEBUG in main() */
172 172 }
173 173 return (SUCCESS);
174 174 }
175 175
176 176 /*
177 177 * uteardown - vanilla unix teardown routine
178 178 */
179 179 static int
180 180 uteardown(role, fdread, fdwrite)
181 181 {
182 182 int ret;
183 183 char *ttyn;
184 184
185 185 if (role == SLAVE) {
186 186 ret = restline();
187 187 DEBUG(4, "ret restline - %d\n", ret);
188 188 if (fdread != -1)
189 189 sethup(fdread);
190 190 }
191 191 if (fdread != -1) {
192 192 ttyn = ttyname(fdread);
193 193 if (ttyn != NULL && Dev_mode != 0)
194 194 chmod(ttyn, Dev_mode); /* can fail, but who cares? */
195 195 (void) close(fdread);
196 196 (void) close(fdwrite);
197 197 }
198 198 return (SUCCESS);
199 199 }
200 200
201 201 #ifdef DATAKIT
202 202 /*
203 203 * dksetup - DATAKIT setup routine
204 204 *
205 205 * Put line in block mode.
206 206 */
207 207
208 208 static int
209 209 dksetup(role, fdreadp, fdwritep)
210 210
211 211 int role;
212 212 int *fdreadp;
213 213 int *fdwritep;
214 214
215 215 {
216 216 static short dkrmode[3] = { DKR_BLOCK | DKR_TIME, 0, 0 };
217 217 int ret;
218 218
219 219 (void) usetup(role, fdreadp, fdwritep);
220 220 if ((ret = (*Ioctl)(*fdreadp, DIOCRMODE, dkrmode)) < 0) {
221 221 DEBUG(4, "dksetup: failed to set block mode. ret=%d,\n", ret);
222 222 DEBUG(4, "read fd=%d, ", *fdreadp);
223 223 DEBUG(4, "errno=%d\n", errno);
224 224 return (FAIL);
225 225 }
226 226 return (SUCCESS);
227 227 }
228 228
229 229 /*
230 230 * dkteardown - DATAKIT teardown routine
231 231 */
232 232 static int
233 233 dkteardown(role, fdread, fdwrite)
234 234 int role, fdread, fdwrite;
235 235 {
236 236 char *ttyn;
237 237
238 238 if (role == MASTER) {
239 239 ttyn = ttyname(fdread);
240 240 if (ttyn != NULL && Dev_mode != 0)
241 241 chmod(ttyn, Dev_mode); /* can fail, but who cares? */
242 242 }
243 243
244 244 /* must flush fd's for datakit */
245 245 /* else close can hang */
246 246 if (ioctl(fdread, DIOCFLUSH, NULL) != 0)
247 247 DEBUG(4, "dkteardown: DIOCFLUSH of input fd %d failed",
248 248 fdread);
249 249 if (ioctl(fdwrite, DIOCFLUSH, NULL) != 0)
250 250 DEBUG(4, "dkteardown: DIOCFLUSH of output fd %d failed",
251 251 fdwrite);
252 252
253 253 (void) close(fdread);
254 254 (void) close(fdwrite);
255 255 return (SUCCESS);
256 256 }
257 257 #endif /* DATAKIT */
258 258
259 259
260 260 #ifdef TLI
261 261 /*
262 262 * tread - tli read routine
263 263 */
264 264 static ssize_t
265 265 tread(fd, buf, nbytes)
266 266 int fd;
267 267 char *buf;
268 268 unsigned nbytes;
269 269 {
270 270 int rcvflags;
271 271
272 272 return ((ssize_t)t_rcv(fd, buf, nbytes, &rcvflags));
273 273 }
274 274
275 275 /*
276 276 * twrite - tli write routine
277 277 */
278 278 #define N_CHECK 100
279 279 static ssize_t
280 280 twrite(fd, buf, nbytes)
281 281 int fd;
282 282 char *buf;
283 283 unsigned nbytes;
284 284 {
285 285 register int i, ret;
286 286 static int n_writ, got_info;
287 287 static struct t_info info;
288 288
289 289 if (got_info == 0) {
290 290 if (t_getinfo(fd, &info) != 0) {
291 291 tfaillog(fd, "twrite: t_getinfo\n");
292 292 return (FAIL);
293 293 }
294 294 got_info = 1;
|
↓ open down ↓ |
294 lines elided |
↑ open up ↑ |
295 295 }
296 296
297 297 /* on every N_CHECKth call, check that are still in DATAXFER state */
298 298 if (++n_writ == N_CHECK) {
299 299 n_writ = 0;
300 300 if (t_getstate(fd) != T_DATAXFER)
301 301 return (FAIL);
302 302 }
303 303
304 304 if (info.tsdu <= 0 || nbytes <= info.tsdu)
305 - return (t_snd(fd, buf, nbytes, NULL));
305 + return (t_snd(fd, buf, nbytes, 0));
306 306
307 307 /* if get here, then there is a limit on transmit size */
308 308 /* (info.tsdu > 0) and buf exceeds it */
309 309 i = ret = 0;
310 310 while (nbytes >= info.tsdu) {
311 - if ((ret = t_snd(fd, &buf[i], info.tsdu, NULL)) != info.tsdu)
311 + if ((ret = t_snd(fd, &buf[i], info.tsdu, 0)) != info.tsdu)
312 312 return ((ret >= 0 ? (i + ret) : ret));
313 313 i += info.tsdu;
314 314 nbytes -= info.tsdu;
315 315 }
316 316 if (nbytes != 0) {
317 - if ((ret = t_snd(fd, &buf[i], nbytes, NULL)) != nbytes)
317 + if ((ret = t_snd(fd, &buf[i], nbytes, 0)) != nbytes)
318 318 return ((ssize_t)(ret >= 0 ? (i + ret) : ret));
319 319 i += nbytes;
320 320 }
321 321 return ((ssize_t)i);
322 322 }
323 323
324 324
325 325 /*
326 326 * tioctl - stub for tli ioctl routine
327 327 */
328 328 /*ARGSUSED*/
329 329 static int
330 330 #ifdef __STDC__
331 331 tioctl(int fd, int request, ...)
332 332 #else
333 333 tioctl(fd, request, arg)
334 334 int fd, request;
335 335 #endif
336 336 {
337 337 return (SUCCESS);
338 338 }
339 339
340 340 /*
341 341 * tsetup - tli setup routine
342 342 * note blatant assumption that *fdreadp == *fdwritep == 0
343 343 */
344 344 static int
345 345 tsetup(role, fdreadp, fdwritep)
346 346 int *fdreadp, *fdwritep;
347 347 {
348 348
349 349 if (role == SLAVE) {
350 350 *fdreadp = 0;
351 351 *fdwritep = 1;
352 352 /* 2 has been re-opened to RMTDEBUG in main() */
353 353 errno = t_errno = 0;
354 354 if (t_sync(*fdreadp) == -1 || t_sync(*fdwritep) == -1) {
355 355 tfaillog(*fdreadp, "tsetup: t_sync\n");
356 356 return (FAIL);
357 357 }
358 358 }
359 359 return (SUCCESS);
360 360 }
361 361
362 362 /*
363 363 * tteardown - tli shutdown routine
364 364 */
365 365 /*ARGSUSED*/
366 366 static int
367 367 tteardown(role, fdread, fdwrite)
368 368 {
369 369 (void) t_unbind(fdread);
370 370 (void) t_close(fdread);
371 371 return (SUCCESS);
372 372 }
373 373
374 374 #ifdef TLIS
375 375 /*
376 376 * tssetup - tli, with streams module, setup routine
377 377 * note blatant assumption that *fdreadp == *fdwritep
378 378 */
379 379 static int
380 380 tssetup(role, fdreadp, fdwritep)
381 381 int role;
382 382 int *fdreadp;
383 383 int *fdwritep;
384 384 {
385 385 if (role == SLAVE) {
386 386 *fdreadp = 0;
387 387 *fdwritep = 1;
388 388 /* 2 has been re-opened to RMTDEBUG in main() */
389 389 DEBUG(5, "tssetup: SLAVE mode: leaving ok\n%s", "");
390 390 return (SUCCESS);
391 391 }
392 392
393 393 DEBUG(4, "tssetup: MASTER mode: leaving ok\n%s", "");
394 394 return (SUCCESS);
395 395 }
396 396
397 397 /*
398 398 * Report why a TLI call failed.
399 399 */
400 400 GLOBAL void
401 401 tfaillog(fd, s)
402 402 int fd;
403 403 char *s;
404 404 {
405 405 char fmt[ BUFSIZ ];
406 406
407 407 if (0 < t_errno && t_errno < t_nerr) {
408 408 sprintf(fmt, "%s: %%s\n", s);
409 409 DEBUG(5, fmt, t_errlist[t_errno]);
410 410 logent(s, t_errlist[t_errno]);
411 411 if (t_errno == TSYSERR) {
412 412 strcpy(fmt, "tlicall: system error: %s\n");
413 413 DEBUG(5, fmt, strerror(errno));
414 414 } else if (t_errno == TLOOK) {
415 415 show_tlook(fd);
416 416 }
417 417 } else {
418 418 sprintf(fmt, "unknown tli error %d", t_errno);
419 419 logent(s, fmt);
420 420 sprintf(fmt, "%s: unknown tli error %d", s, t_errno);
421 421 DEBUG(5, fmt, 0);
422 422 sprintf(fmt, "%s: %%s\n", s);
423 423 DEBUG(5, fmt, strerror(errno));
424 424 }
425 425 }
426 426
427 427 GLOBAL void
428 428 show_tlook(fd)
429 429 int fd;
430 430 {
431 431 register int reason;
432 432 register char *msg;
433 433 extern int t_errno;
434 434 /*
435 435 * Find out the current state of the interface.
436 436 */
437 437 errno = t_errno = 0;
438 438 switch (reason = t_getstate(fd)) {
439 439 case T_UNBND: msg = "T_UNBIND"; break;
440 440 case T_IDLE: msg = "T_IDLE"; break;
441 441 case T_OUTCON: msg = "T_OUTCON"; break;
442 442 case T_INCON: msg = "T_INCON"; break;
443 443 case T_DATAXFER: msg = "T_DATAXFER"; break;
444 444 case T_OUTREL: msg = "T_OUTREL"; break;
445 445 case T_INREL: msg = "T_INREL"; break;
446 446 default: msg = NULL; break;
447 447 }
448 448 if (msg == NULL)
449 449 return;
450 450
451 451 DEBUG(5, "state is %s", msg);
452 452 switch (reason = t_look(fd)) {
453 453 case -1: msg = ""; break;
454 454 case 0: msg = "NO ERROR"; break;
455 455 case T_LISTEN: msg = "T_LISTEN"; break;
456 456 case T_CONNECT: msg = "T_CONNECT"; break;
457 457 case T_DATA: msg = "T_DATA"; break;
458 458 case T_EXDATA: msg = "T_EXDATA"; break;
459 459 case T_DISCONNECT: msg = "T_DISCONNECT"; break;
460 460 case T_ORDREL: msg = "T_ORDREL"; break;
461 461 case T_UDERR: msg = "T_UDERR"; break;
462 462 default: msg = "UNKNOWN ERROR"; break;
463 463 }
464 464 DEBUG(4, " reason is %s\n", msg);
465 465
466 466 if (reason == T_DISCONNECT)
467 467 {
468 468 struct t_discon *dropped;
469 469 if (((dropped =
470 470 (struct t_discon *)t_alloc(fd, T_DIS, T_ALL)) == 0) ||
471 471 (t_rcvdis(fd, dropped) == -1)) {
472 472 if (dropped)
473 473 t_free((char *)dropped, T_DIS);
474 474 return;
475 475 }
476 476 DEBUG(5, "disconnect reason #%d\n", dropped->reason);
477 477 t_free((char *)dropped, T_DIS);
478 478 }
479 479 }
480 480
481 481 #endif /* TLIS */
482 482
483 483 #endif /* TLI */
|
↓ open down ↓ |
156 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX