0
|
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 2005 Sun Microsystems, Inc. All rights reserved.
|
|
24 * Use is subject to license terms.
|
|
25 */
|
|
26
|
|
27
|
|
28 /*
|
|
29 * This code implements the Starfire Virtual Console host daemon
|
|
30 * (see cvcd(1M)). It accepts a connection from netcon_server
|
|
31 * and transfers console I/O to/from the SSP across the
|
|
32 * network via TLI. The I/O is sent to the cvcredir device
|
|
33 * on the host (see cvc(7) and cvcredir(7)). It also sends
|
|
34 * disconnect and break ioctl's to the kernel CVC drivers.
|
|
35 */
|
|
36
|
|
37 #pragma ident "@(#)cvcd.c 1.35 05/10/18 SMI"
|
|
38
|
|
39
|
|
40 #include <stdio.h>
|
|
41 #include <stdarg.h>
|
|
42 #include <syslog.h>
|
|
43 #include <stdlib.h>
|
|
44 #include <tiuser.h>
|
|
45 #include <sys/timod.h>
|
|
46 #include <fcntl.h>
|
|
47 #include <sys/param.h>
|
|
48 #include <sys/utsname.h>
|
|
49 #include <sys/stat.h>
|
|
50 #include <unistd.h>
|
|
51 #include <stropts.h>
|
|
52 #include <sys/conf.h>
|
|
53 #include <pwd.h>
|
|
54 #include <errno.h>
|
|
55 #include <sys/socket.h>
|
|
56 #include <arpa/inet.h>
|
|
57 #include <locale.h>
|
|
58 #include <termio.h>
|
|
59 #include <signal.h>
|
|
60 #include <sys/cvc.h>
|
|
61
|
|
62 #include <string.h>
|
|
63
|
|
64 #include <sys/ioctl.h>
|
|
65 #include <sys/file.h>
|
|
66 #include <sys/sockio.h>
|
|
67
|
|
68 #include <sys/tihdr.h>
|
|
69
|
|
70 #include <netdb.h>
|
|
71 #include <net/if.h>
|
|
72 #include <netinet/if_ether.h>
|
|
73
|
|
74 #include <inet/common.h>
|
|
75 #include <sys/systeminfo.h>
|
|
76
|
|
77 /* Process priority control */
|
|
78 #include <sys/priocntl.h>
|
|
79 #include <sys/tspriocntl.h>
|
|
80 #include <sys/rtpriocntl.h>
|
|
81
|
|
82 /*
|
|
83 * Misc. defines.
|
|
84 */
|
|
85 #define CONREF "connection request from illegal host"
|
|
86 #define SSPHOSTNAMEFILE "/etc/ssphostname"
|
|
87 #define NODENAME "/etc/nodename"
|
|
88 #define MAXIFS 256
|
|
89
|
|
90 /*
|
|
91 * Function prototypes
|
|
92 */
|
|
93 static void cvcd_connect(int fd, struct pollfd *);
|
|
94 static void cvcd_reject(int fd);
|
|
95 static void cvcd_read(struct pollfd *);
|
|
96 static void cvcd_write(char *data, int size);
|
|
97 static void cvcd_status(int fd);
|
|
98 static void cvcd_winch(int, char *, int);
|
|
99 static void cvcd_ioctl(int fd, int cmd);
|
|
100 static void cvcd_err(int code, char *format, ...);
|
|
101 static void usage(void);
|
|
102 static id_t schedinfo(char *name, short *maxpri);
|
|
103 static void cvcd_setopt(int fd, int name);
|
|
104
|
|
105 /*
|
|
106 * Globals
|
|
107 */
|
|
108 static int rconsfd; /* Console redirection driver */
|
|
109 static char progname[MAXPATHLEN];
|
|
110 static char ssphostname[MAXPATHLEN];
|
|
111 static int debug = 0;
|
|
112 static int connected = 0;
|
|
113 static int peercheck = 1;
|
|
114 static char nic_name[32];
|
|
115
|
|
116 int
|
|
117 main(int argc, char **argv)
|
|
118 {
|
|
119 int opt;
|
|
120 int tport = 0;
|
|
121 char *hostname;
|
|
122 struct utsname utsname;
|
|
123 struct t_info tinfo;
|
|
124 int cvcd_ssp;
|
|
125 int nfd;
|
|
126 struct pollfd *cvcd_pfd;
|
|
127 int i;
|
|
128 int j;
|
|
129 struct servent *se;
|
|
130 struct sockaddr_in *sin;
|
|
131 struct t_bind *reqb;
|
|
132 struct t_bind *retb;
|
|
133 struct t_optmgmt *topt, *tropt;
|
|
134 struct opthdr *sockopt;
|
|
135 int on = 1;
|
|
136 int tmperr = 0;
|
|
137 int event;
|
|
138 char prefix[256];
|
|
139 pcparms_t pcparms;
|
|
140 tsparms_t *tsparmsp;
|
|
141 id_t pid, tsID;
|
|
142 short tsmaxpri;
|
|
143 static int netcon_fail = 0;
|
|
144
|
|
145 (void) setlocale(LC_ALL, "");
|
|
146 (void) strcpy(progname, argv[0]);
|
|
147 (void) memset(ssphostname, 0, MAXPATHLEN);
|
|
148
|
|
149 if ((cvcd_ssp = open(SSPHOSTNAMEFILE, O_RDONLY)) < 0) {
|
|
150 /*
|
|
151 * If there is no /etc/ssphostname disable peer check after
|
|
152 * issuing warning.
|
|
153 */
|
|
154 tmperr = errno;
|
|
155 peercheck = 0;
|
|
156 } else {
|
|
157 if ((i = read(cvcd_ssp, ssphostname, MAXPATHLEN)) < 0) {
|
|
158 cvcd_err(LOG_ERR, "failed to read ssphostname");
|
|
159 }
|
|
160 /*
|
|
161 * The ssp-config(1M) command newline terminates the
|
|
162 * ssphostname in the /etc/ssphostname file
|
|
163 */
|
|
164 ssphostname[i-1] = '\0';
|
|
165 (void) close(cvcd_ssp);
|
|
166
|
|
167 (void) memset(nic_name, 0, sizeof (nic_name));
|
|
168 }
|
|
169
|
|
170 #if defined(DEBUG)
|
|
171 while ((opt = getopt(argc, argv, "dp:r:")) != EOF) {
|
|
172 #else
|
|
173 while ((opt = getopt(argc, argv, "r:")) != EOF) {
|
|
174 #endif /* DEBUG */
|
|
175 switch (opt) {
|
|
176
|
|
177 #if defined(DEBUG)
|
|
178 case 'd' : debug = 1;
|
|
179 break;
|
|
180
|
|
181 case 'p' : tport = atoi(optarg);
|
|
182 break;
|
|
183 #endif /* DEBUG */
|
|
184
|
|
185 case 'r' : (void) strcpy(ssphostname, optarg);
|
|
186 break;
|
|
187
|
|
188 default : usage();
|
|
189 exit(1);
|
|
190 }
|
|
191 }
|
|
192
|
|
193 if (uname(&utsname) == -1) {
|
|
194 perror("HOSTNAME not defined");
|
|
195 exit(1);
|
|
196 }
|
|
197 hostname = utsname.nodename;
|
|
198
|
|
199 /*
|
|
200 * hostname may still be NULL, depends on when cvcd was started
|
|
201 * in the boot sequence. If it is NULL, try one more time
|
|
202 * to get a hostname -> look in the /etc/nodename file.
|
|
203 */
|
|
204 if (!strlen(hostname)) {
|
|
205 /*
|
|
206 * try to get the hostname from the /etc/nodename file
|
|
207 * we reuse the utsname.nodename buffer here! hostname
|
|
208 * already points to it.
|
|
209 */
|
|
210 if ((nfd = open(NODENAME, O_RDONLY)) > 0) {
|
|
211 if ((i = read(nfd, utsname.nodename, SYS_NMLN)) <= 0) {
|
|
212 cvcd_err(LOG_WARNING,
|
|
213 "failed to acquire hostname");
|
|
214 }
|
|
215 utsname.nodename[i-1] = '\0';
|
|
216 (void) close(nfd);
|
|
217 }
|
|
218 }
|
|
219
|
|
220 /*
|
|
221 * Must be root.
|
|
222 */
|
|
223 if (debug == 0 && geteuid() != 0) {
|
|
224 fprintf(stderr, "cvcd: Must be root");
|
|
225 exit(1);
|
|
226 }
|
|
227
|
|
228 /*
|
|
229 * Daemonize...
|
|
230 */
|
|
231 if (debug == 0) {
|
|
232 for (i = 0; i < NOFILE; i++) {
|
|
233 (void) close(i);
|
|
234 }
|
|
235 (void) chdir("/");
|
|
236 (void) umask(0);
|
|
237 if (fork() != 0) {
|
|
238 exit(0);
|
|
239 }
|
|
240 (void) setpgrp();
|
|
241 (void) sprintf(prefix, "%s-(HOSTNAME:%s)", progname, hostname);
|
|
242 openlog(prefix, LOG_CONS | LOG_NDELAY, LOG_LOCAL0);
|
|
243 }
|
|
244 if (peercheck == 0) {
|
|
245 cvcd_err(LOG_ERR, "open(SSPHOSTNAMEFILE):%s",
|
|
246 strerror(tmperr));
|
|
247 }
|
|
248
|
|
249 cvcd_pfd = (struct pollfd *)malloc(3*sizeof (struct pollfd));
|
|
250 if (cvcd_pfd == (struct pollfd *)NULL) {
|
|
251 cvcd_err(LOG_ERR, "malloc:", strerror(errno));
|
|
252 exit(1);
|
|
253 }
|
|
254 (void) memset((void *)cvcd_pfd, 0, 3*sizeof (struct pollfd));
|
|
255 cvcd_pfd[0].fd = -1;
|
|
256 cvcd_pfd[1].fd = -1;
|
|
257 cvcd_pfd[2].fd = -1;
|
|
258
|
|
259 /* SPR 94004 */
|
|
260 (void) sigignore(SIGTERM);
|
|
261
|
|
262 /*
|
|
263 * SPR 83644: cvc and kadb are not compatible under heavy loads.
|
|
264 * Fix: will give cvcd highest TS priority at execution time.
|
|
265 */
|
|
266 pid = getpid();
|
|
267 pcparms.pc_cid = PC_CLNULL;
|
|
268 tsparmsp = (tsparms_t *)pcparms.pc_clparms;
|
|
269
|
|
270 /* Get scheduler properties for this PID */
|
|
271 if (priocntl(P_PID, pid, PC_GETPARMS, (caddr_t)&pcparms) == -1L) {
|
|
272 cvcd_err(LOG_ERR,
|
|
273 "cvcd: GETPARMS failed. Warning: can't get ",
|
|
274 "TS priorities.");
|
|
275 } else {
|
|
276 /* Get class IDs and maximum priorities for a TS process */
|
|
277 if ((tsID = schedinfo("TS", &tsmaxpri)) == -1) {
|
|
278 cvcd_err(LOG_ERR, "cvcd: Warning, can't get ",
|
|
279 "TS scheduler info.");
|
|
280 } else {
|
|
281 if (debug) { /* Print priority info */
|
|
282 if (pcparms.pc_cid == tsID) {
|
|
283 cvcd_err(LOG_DEBUG, "%s%d%s%d%s%d\n",
|
|
284 "cvcd:: PID:", pid,
|
|
285 ", TS priority:",
|
|
286 tsparmsp->ts_upri,
|
|
287 ", TS max_pri:", tsmaxpri);
|
|
288 }
|
|
289 }
|
|
290 /* Change proc's priority to maxtspri */
|
|
291 pcparms.pc_cid = tsID;
|
|
292 tsparmsp = (struct tsparms *)pcparms.pc_clparms;
|
|
293 tsparmsp->ts_upri = tsmaxpri;
|
|
294 tsparmsp->ts_uprilim = tsmaxpri;
|
|
295
|
|
296 if (priocntl(P_PID, pid, PC_SETPARMS,
|
|
297 (caddr_t)&pcparms) == -1L) {
|
|
298 cvcd_err(LOG_ERR, "cvcd: Warning, ",
|
|
299 "can't set TS maximum priority.");
|
|
300 }
|
|
301 /* Done */
|
|
302 if (debug) { /* Get new scheduler properties for PID */
|
|
303 if (priocntl(P_PID, pid, PC_GETPARMS,
|
|
304 (caddr_t)&pcparms) == -1L) {
|
|
305 cvcd_err(LOG_DEBUG, "GETPARMS failed");
|
|
306 exit(1);
|
|
307 } else {
|
|
308 cvcd_err(LOG_DEBUG, "%s%d%s%d%s%d\n",
|
|
309 "cvcd:: PID:", pid,
|
|
310 ", New TS priority:",
|
|
311 tsparmsp->ts_upri,
|
|
312 ", TS max_pri:", tsmaxpri);
|
|
313 }
|
|
314 }
|
|
315 }
|
|
316 }
|
|
317
|
|
318 if (debug == 1) {
|
|
319 cvcd_err(LOG_DEBUG, "tport = %d, debug = %d", tport, debug);
|
|
320 }
|
|
321
|
|
322 if (tport == 0) {
|
|
323 if ((se = getservbyname(CVCD_SERVICE, "tcp")) == NULL) {
|
|
324 cvcd_err(LOG_ERR, "getservbyname(%s) not found",
|
|
325 CVCD_SERVICE);
|
|
326 exit(1);
|
|
327 }
|
|
328 tport = se->s_port;
|
|
329 }
|
|
330
|
|
331 cvcd_ssp = t_open(TCP_DEV, O_RDWR, &tinfo);
|
|
332 if (cvcd_ssp == -1) {
|
|
333 cvcd_err(LOG_ERR, "t_open: %s", t_errlist[t_errno]);
|
|
334 exit(1);
|
|
335 }
|
|
336
|
|
337 /*
|
|
338 * Set the SO_REUSEADDR option for this TLI endpoint.
|
|
339 */
|
|
340 cvcd_setopt(cvcd_ssp, SO_REUSEADDR);
|
|
341
|
|
342 /*
|
|
343 * Set the SO_DONTROUTE option for this TLI endpoint, if
|
|
344 * /etc/ssphostname exists.
|
|
345 */
|
|
346 if (peercheck == 1)
|
|
347 cvcd_setopt(cvcd_ssp, SO_DONTROUTE);
|
|
348
|
|
349 /*
|
|
350 * Bind it.
|
|
351 */
|
|
352 if (((reqb = (struct t_bind *)t_alloc(cvcd_ssp, T_BIND, T_ALL))
|
|
353 == (struct t_bind *)NULL)) {
|
|
354 cvcd_err(LOG_ERR, "%s", t_errlist[t_errno]);
|
|
355 exit(1);
|
|
356 }
|
|
357 if (((retb = (struct t_bind *)t_alloc(cvcd_ssp, T_BIND, T_ALL))
|
|
358 == (struct t_bind *)NULL)) {
|
|
359 cvcd_err(LOG_ERR, "%s", t_errlist[t_errno]);
|
|
360 exit(1);
|
|
361 }
|
|
362 reqb->qlen = 1;
|
|
363 reqb->addr.len = sizeof (struct sockaddr_in);
|
|
364 sin = (struct sockaddr_in *)reqb->addr.buf;
|
|
365 (void) memset((void *)sin, 0, sizeof (struct sockaddr_in));
|
|
366 sin->sin_family = AF_INET;
|
|
367
|
|
368
|
|
369 sin->sin_addr.s_addr = htonl(INADDR_ANY);
|
|
370 sin->sin_port = htons(tport);
|
|
371 if (t_bind(cvcd_ssp, reqb, retb) == -1) {
|
|
372 cvcd_err(LOG_ERR, "t_bind: %s", t_errlist[t_errno]);
|
|
373 exit(1);
|
|
374 }
|
|
375 sin = (struct sockaddr_in *)retb->addr.buf;
|
|
376 if (sin->sin_port != htons(tport)) {
|
|
377 cvcd_err(LOG_ERR, "t_bind: bound to wrong port");
|
|
378 cvcd_err(LOG_ERR, "Wanted %d, got %d", tport,
|
|
379 ntohs(sin->sin_port));
|
|
380 exit(1);
|
|
381 }
|
|
382
|
|
383 t_free((char *)reqb, T_BIND);
|
|
384 t_free((char *)retb, T_BIND);
|
|
385
|
|
386
|
|
387 /*
|
|
388 * Wait for connect from OBP.
|
|
389 */
|
|
390 cvcd_pfd[2].fd = cvcd_ssp;
|
|
391 cvcd_pfd[2].events = POLLIN|POLLPRI;
|
|
392 if ((event = poll(&cvcd_pfd[2], 1, -1)) == -1) {
|
|
393 cvcd_err(LOG_ERR, "poll: %s", strerror(errno));
|
|
394 exit(1);
|
|
395 }
|
|
396 /*
|
|
397 * cvcd_connect sets global
|
|
398 * connected = 1 if successful.
|
|
399 */
|
|
400 cvcd_connect(cvcd_ssp, cvcd_pfd);
|
|
401
|
|
402 /*
|
|
403 * Now set up the Network Console redirection driver.
|
|
404 */
|
|
405 rconsfd = open(CVCREDIR_DEV, O_RDWR|O_NDELAY);
|
|
406 if (rconsfd < 0) {
|
|
407 cvcd_err(LOG_ERR, "open: %s", strerror(errno));
|
|
408 exit(1);
|
|
409 }
|
|
410
|
|
411 /*
|
|
412 * cvcd_pfd holds three file descriptors we need to poll from:
|
|
413 * 0 will be connected to in_cvcd; 1 is the CVC Redirection driver;
|
|
414 * and 2 is the listen endpoint for new connections.
|
|
415 */
|
|
416 cvcd_pfd[1].fd = rconsfd;
|
|
417 cvcd_pfd[1].events = POLLIN;
|
|
418 /*
|
|
419 * Loop through main service routine. We check for inbound in.cvcd
|
|
420 * connection and data xfer between host and in.cvcd.
|
|
421 */
|
|
422 for (;;) {
|
|
423
|
|
424 char buf[MAXPKTSZ];
|
|
425
|
|
426 /*
|
|
427 * Check for in_cvcd connect requests.
|
|
428 */
|
|
429 switch ((event = t_look(cvcd_ssp))) {
|
|
430 case -1 :
|
|
431 cvcd_err(LOG_ERR, "%s", t_errlist[t_errno]);
|
|
432 exit(1);
|
|
433 /* NOTREACHED */
|
|
434 break;
|
|
435 case 0 : /* Nothing to do */
|
|
436 break;
|
|
437 case T_LISTEN :
|
|
438 if (connected == 1) {
|
|
439 /*
|
|
440 * Someone already connected.
|
|
441 */
|
|
442 cvcd_reject(cvcd_ssp);
|
|
443 } else {
|
|
444 /*
|
|
445 * cvcd_connect sets global
|
|
446 * connected = 1 if successful.
|
|
447 */
|
|
448 cvcd_connect(cvcd_ssp, cvcd_pfd);
|
|
449
|
|
450 /*
|
|
451 * Re-open the cvcredir driver if
|
|
452 * the netcon_fail is true. This
|
|
453 * indicates there was a previous
|
|
454 * network connection that got closed.
|
|
455 */
|
|
456 if (netcon_fail) {
|
|
457 rconsfd = open(CVCREDIR_DEV,
|
|
458 O_RDWR|O_NDELAY);
|
|
459 if (rconsfd < 0) {
|
|
460 cvcd_err(LOG_ERR,
|
|
461 "open: %s",
|
|
462 strerror(errno));
|
|
463 exit(1);
|
|
464 }
|
|
465 cvcd_pfd[1].fd = rconsfd;
|
|
466 cvcd_pfd[1].events = POLLIN;
|
|
467 netcon_fail = 0;
|
|
468 }
|
|
469 }
|
|
470 break;
|
|
471 default :
|
|
472 cvcd_err(LOG_ERR,
|
|
473 "Illegal event %d for cvcd_ssp", event);
|
|
474 exit(1);
|
|
475 }
|
|
476 /*
|
|
477 * Take a look for console I/O or connect request.
|
|
478 */
|
|
479 if ((event = poll(cvcd_pfd, 3, -1)) == -1) {
|
|
480 cvcd_err(LOG_ERR, "poll: %s", strerror(errno));
|
|
481 exit(1);
|
|
482 }
|
|
483
|
|
484 /*
|
|
485 * The following for loop is to detect any bad
|
|
486 * things(ie hangup,errors,invalid fd) have happened
|
|
487 * to the file descriptors we're interested in.
|
|
488 * If so, disconnect current network console connection.
|
|
489 */
|
|
490 for (j = 0; j < 3; j++) {
|
|
491 if (cvcd_pfd[j].revents & (POLLERR|POLLHUP|POLLNVAL)) {
|
|
492 cvcd_err(LOG_WARNING,
|
|
493 "poll: status on %s fd:%s%s%s",
|
|
494 ((j == 2) ? "listen" :
|
|
495 ((j == 0) ? "network" : "redir")),
|
|
496 (cvcd_pfd[j].revents & POLLERR) ?
|
|
497 " error" : "",
|
|
498 (cvcd_pfd[j].revents & POLLHUP) ?
|
|
499 " hangup" : "",
|
|
500 (cvcd_pfd[j].revents & POLLNVAL) ?
|
|
501 " bad fd" : "");
|
|
502
|
|
503 (void) t_close(cvcd_pfd[0].fd);
|
|
504 cvcd_pfd[0].fd = -1;
|
|
505
|
|
506 (void) close(cvcd_pfd[1].fd);
|
|
507 cvcd_pfd[1].fd = -1;
|
|
508 connected = 0;
|
|
509 netcon_fail = 1;
|
|
510 break;
|
|
511 }
|
|
512 }
|
|
513
|
|
514 /*
|
|
515 * Check if dummy netcon_fail flag is set, if set returns
|
|
516 * to the beginning of the main service routine.
|
|
517 */
|
|
518 if (netcon_fail)
|
|
519 continue;
|
|
520
|
|
521 if (event != 0) {
|
|
522 if (cvcd_pfd[0].revents == POLLIN) {
|
|
523 /*
|
|
524 * Process cvcd_ssp data and commands.
|
|
525 */
|
|
526 cvcd_read(cvcd_pfd);
|
|
527 }
|
|
528 if (cvcd_pfd[1].revents == POLLIN) {
|
|
529 int s;
|
|
530
|
|
531 if ((s = read(rconsfd, buf, MAXPKTSZ)) == -1) {
|
|
532 cvcd_err(LOG_ERR, "read: %s",
|
|
533 strerror(errno));
|
|
534 exit(1);
|
|
535 }
|
|
536 if ((s > 0) && (connected == 1)) {
|
|
537 if (write(cvcd_pfd[0].fd, buf, s) !=
|
|
538 s) {
|
|
539 cvcd_err(LOG_ERR,
|
|
540 "lost data output");
|
|
541 }
|
|
542 }
|
|
543 }
|
|
544 }
|
|
545 } /* End forever loop */
|
|
546
|
|
547 #ifdef lint
|
|
548 /* NOTREACHED */
|
|
549 return (1);
|
|
550 #endif /* lint */
|
|
551 }
|
|
552
|
|
553 static void
|
|
554 cvcd_reject(int fd)
|
|
555 {
|
|
556 struct t_call *tcall;
|
|
557
|
|
558 tcall = (struct t_call *)t_alloc(fd, T_CALL, T_ALL);
|
|
559 if (tcall == (struct t_call *)NULL) {
|
|
560 cvcd_err(LOG_ERR, "cvcd_reject: t_alloc: %s",
|
|
561 t_errlist[t_errno]);
|
|
562 return;
|
|
563 }
|
|
564 if (t_listen(fd, tcall) == -1) {
|
|
565 if (t_errno == TNODATA) {
|
|
566 cvcd_err(LOG_ERR, "cvcd_reject: No client data!");
|
|
567 }
|
|
568 cvcd_err(LOG_ERR, "cvcd_reject: t_listen: %s",
|
|
569 t_errlist[t_errno]);
|
|
570 t_free((char *)tcall, T_CALL);
|
|
571 return;
|
|
572 }
|
|
573 if (t_snddis(fd, tcall) < 0) {
|
|
574 cvcd_err(LOG_ERR, "cvcd_reject: t_snddis: %s",
|
|
575 t_errlist[t_errno]);
|
|
576 }
|
|
577 t_free((char *)tcall, T_CALL);
|
|
578 }
|
|
579
|
|
580 static void
|
|
581 cvcd_connect(int fd, struct pollfd *pfd)
|
|
582 {
|
|
583 struct t_call *tcall;
|
|
584 int newfd;
|
|
585 struct sockaddr_in *peer;
|
|
586 int badpeer = 1;
|
|
587 struct hostent *he;
|
|
588 struct netbuf netbuf;
|
|
589 char addr[100];
|
|
590 ulong_t tmpaddr; /* network byte order */
|
|
591 char **pp;
|
|
592
|
|
593 tcall = (struct t_call *)t_alloc(fd, T_CALL, T_ALL);
|
|
594 if (tcall == (struct t_call *)NULL) {
|
|
595 cvcd_err(LOG_ERR, "cvcd_connect: t_alloc: %s",
|
|
596 t_errlist[t_errno]);
|
|
597 return;
|
|
598 }
|
|
599 if (t_listen(fd, tcall) == -1) {
|
|
600 if (t_errno == TNODATA) {
|
|
601 cvcd_err(LOG_ERR, "cvcd_connect: No client data!");
|
|
602 }
|
|
603 cvcd_err(LOG_ERR, "cnctip_connect: t_listen: %s",
|
|
604 t_errlist[t_errno]);
|
|
605 t_free((char *)tcall, T_CALL);
|
|
606 return;
|
|
607 }
|
|
608 if (pfd[0].fd != -1) {
|
|
609 cvcd_err(LOG_ERR, "cvcd_connect: no free file descriptors!");
|
|
610 t_free((char *)tcall, T_CALL);
|
|
611 return;
|
|
612 }
|
|
613 newfd = t_open(TCP_DEV, O_RDWR|O_NDELAY, NULL);
|
|
614 if (newfd == -1) {
|
|
615 cvcd_err(LOG_ERR, "cvcd_connect: t_open: %s",
|
|
616 t_errlist[t_errno]);
|
|
617 t_free((char *)tcall, T_CALL);
|
|
618 return;
|
|
619 }
|
|
620 if (t_accept(fd, newfd, tcall) < 0) {
|
|
621 cvcd_err(LOG_ERR, "cvcd_connect: t_accept: %s",
|
|
622 t_errlist[t_errno]);
|
|
623 t_close(newfd);
|
|
624 t_free((char *)tcall, T_CALL);
|
|
625 return;
|
|
626 }
|
|
627 t_free((char *)tcall, T_CALL);
|
|
628
|
|
629 /*
|
|
630 * If /etc/ssphostname doesnt exists, dont bother verifying
|
|
631 * peer since we cant do gethostbyname.
|
|
632 */
|
|
633 if (peercheck == 1) {
|
|
634 he = gethostbyname(ssphostname);
|
|
635 if (he == NULL) {
|
|
636 cvcd_err(LOG_ERR, "gethostbyname: %s",
|
|
637 strerror(h_errno));
|
|
638 cvcd_err(LOG_ERR, "unable to get SSP name %s!",
|
|
639 ssphostname);
|
|
640 exit(1);
|
|
641 }
|
|
642 /*
|
|
643 * Verify peer is from specified host by comparing the
|
|
644 * address (in network byte order) of the TLI endpoint
|
|
645 * and the address (in network byte order) of the ssp
|
|
646 * (using the hostname found in /etc/ssphostname).
|
|
647 */
|
|
648 (void) memset(addr, 0, 100);
|
|
649 netbuf.buf = addr;
|
|
650 netbuf.len = 0;
|
|
651 netbuf.maxlen = 100;
|
|
652 if (ioctl(newfd, TI_GETPEERNAME, &netbuf) < 0) {
|
|
653 cvcd_err(LOG_ERR, "ioctl(TI_GETPEERNAME): %s",
|
|
654 strerror(errno));
|
|
655 t_close(newfd);
|
|
656 return;
|
|
657 }
|
|
658
|
|
659 /*
|
|
660 * cvcd doesn't check multi-homed ssphostname
|
|
661 * properly (only checks 1st address)
|
|
662 */
|
|
663 peer = (struct sockaddr_in *)addr;
|
|
664 for (pp = he->h_addr_list; *pp != 0; pp++) {
|
|
665 tmpaddr = htonl(*(ulong_t *)*pp);
|
|
666 if (memcmp(&peer->sin_addr.s_addr, &tmpaddr,
|
|
667 he->h_length) == 0) {
|
|
668 badpeer = 0;
|
|
669 break;
|
|
670 }
|
|
671 }
|
|
672
|
|
673 if (badpeer) {
|
|
674 cvcd_err(LOG_ERR, CONREF);
|
|
675 cvcd_err(LOG_ERR, "remote host = %s.",
|
|
676 inet_ntoa(peer->sin_addr));
|
|
677 t_close(newfd);
|
|
678 return;
|
|
679 }
|
|
680 }
|
|
681 pfd[0].fd = newfd;
|
|
682 pfd[0].events = POLLIN;
|
|
683 connected = 1;
|
|
684 }
|
|
685
|
|
686 /*
|
|
687 * Read in data from client.
|
|
688 */
|
|
689 static void
|
|
690 cvcd_read(struct pollfd *pd)
|
|
691 {
|
|
692 register char *data;
|
|
693 register int fd = pd[0].fd;
|
|
694 char buf[MAXPKTSZ];
|
|
695 int flags = 0;
|
|
696
|
|
697 data = buf;
|
|
698
|
|
699 if (pd[0].revents & POLLIN) {
|
|
700 int n;
|
|
701
|
|
702 if ((n = t_rcv(fd, data, MAXPKTSZ, &flags)) == -1) {
|
|
703 cvcd_err(LOG_ERR, "cvcd_read: t_rcv: %s",
|
|
704 t_errlist[t_errno]);
|
|
705 (void) t_close(pd[0].fd);
|
|
706 pd[0].fd = -1;
|
|
707 connected = 0;
|
|
708 return;
|
|
709 }
|
|
710 if (flags & T_EXPEDITED) {
|
|
711 if (n != 1) {
|
|
712 cvcd_err(LOG_ERR,
|
|
713 "cvcd_read: %d bytes EXD!!",
|
|
714 n);
|
|
715 }
|
|
716 /*
|
|
717 * Deal with cvcd_ssp_commands.
|
|
718 */
|
|
719 switch (data[n-1]) {
|
|
720 case CVC_CONN_BREAK :
|
|
721 cvcd_ioctl(rconsfd, CVC_BREAK);
|
|
722 break;
|
|
723
|
|
724 case CVC_CONN_DIS :
|
|
725 (void) t_close(pd[0].fd);
|
|
726 pd[0].fd = -1;
|
|
727 cvcd_ioctl(rconsfd, CVC_DISCONNECT);
|
|
728 connected = 0;
|
|
729 break;
|
|
730
|
|
731 case CVC_CONN_STAT :
|
|
732 cvcd_status(fd);
|
|
733 break;
|
|
734
|
|
735 default :
|
|
736 cvcd_err(LOG_ERR,
|
|
737 "Illegal cmd 0x%x", buf[n-1]);
|
|
738 break;
|
|
739 }
|
|
740 } else {
|
|
741 if (((data[0] & 0377) == 0377) &&
|
|
742 ((data[1] & 0377) == 0377)) {
|
|
743 /*
|
|
744 * Pass on window size changes (TIOCSWINSZ).
|
|
745 */
|
|
746 cvcd_winch(rconsfd, data, n);
|
|
747 (void) memset(data, 0, n);
|
|
748 } else {
|
|
749 cvcd_write(buf, n);
|
|
750 }
|
|
751 }
|
|
752 }
|
|
753
|
|
754 }
|
|
755
|
|
756 static void
|
|
757 cvcd_ioctl(int fd, int flags)
|
|
758 {
|
|
759 struct strioctl cmd;
|
|
760
|
|
761 cmd.ic_cmd = flags;
|
|
762 cmd.ic_timout = 0;
|
|
763 cmd.ic_len = 0;
|
|
764 cmd.ic_dp = NULL;
|
|
765
|
|
766 if (ioctl(fd, I_STR, &cmd) == -1) {
|
|
767 cvcd_err(LOG_ERR, "cvcd_ioctl: %s", strerror(errno));
|
|
768 exit(1);
|
|
769 }
|
|
770 }
|
|
771
|
|
772
|
|
773 /* ARGSUSED */
|
|
774 static void
|
|
775 cvcd_status(int fd)
|
|
776 {
|
|
777 }
|
|
778
|
|
779
|
|
780 /*
|
|
781 * Write input to console - called from cvcd_read.
|
|
782 */
|
|
783 static void
|
|
784 cvcd_write(char *data, int size)
|
|
785 {
|
|
786 int n;
|
|
787
|
|
788 if ((n = write(rconsfd, data, size)) == -1) {
|
|
789 cvcd_err(LOG_ERR, "cvcd_write: write: %s", strerror(errno));
|
|
790 exit(1);
|
|
791 }
|
|
792 if (n != size) {
|
|
793 cvcd_err(LOG_ERR, "cvcd_write: wrote %d of %d bytes", n, size);
|
|
794 }
|
|
795 }
|
|
796
|
|
797 static void
|
|
798 usage()
|
|
799 {
|
|
800 #if defined(DEBUG)
|
|
801 (void) printf("%s [-d] [-p port]\n", progname);
|
|
802 #else
|
|
803 (void) printf("%s -r [ssp host]\n", progname);
|
|
804 #endif /* DEBUG */
|
|
805 }
|
|
806
|
|
807 /*
|
|
808 * cvcd_err ()
|
|
809 *
|
|
810 * Description:
|
|
811 * Log messages via syslog daemon.
|
|
812 *
|
|
813 * Input:
|
|
814 * code - logging code
|
|
815 * format - messages to log
|
|
816 *
|
|
817 * Output:
|
|
818 * void
|
|
819 *
|
|
820 */
|
|
821 static void
|
|
822 cvcd_err(int code, char *format, ...)
|
|
823 {
|
|
824 va_list varg_ptr;
|
|
825 char buf[MAXPKTSZ];
|
|
826
|
|
827 va_start(varg_ptr, format);
|
|
828 (void) vsprintf(buf, format, varg_ptr);
|
|
829 va_end(varg_ptr);
|
|
830
|
|
831 if (debug == 0)
|
|
832 syslog(code, buf);
|
|
833 else
|
|
834 (void) fprintf(stderr, "%s: %s\n", progname, buf);
|
|
835 }
|
|
836
|
|
837 /*
|
|
838 * Handle a "control" request (signaled by magic being present)
|
|
839 * in the data stream. For now, we are only willing to handle
|
|
840 * window size changes.
|
|
841 */
|
|
842 void
|
|
843 cvcd_winch(int pty, char *cp, int n)
|
|
844 {
|
|
845 struct winsize w;
|
|
846
|
|
847 if (n < 4+sizeof (w) || cp[2] != 's' || cp[3] != 's')
|
|
848 return;
|
|
849 (void) memcpy(&w, cp + 4, sizeof (w));
|
|
850 w.ws_row = ntohs(w.ws_row);
|
|
851 w.ws_col = ntohs(w.ws_col);
|
|
852 w.ws_xpixel = ntohs(w.ws_xpixel);
|
|
853 w.ws_ypixel = ntohs(w.ws_ypixel);
|
|
854 (void) ioctl(pty, TIOCSWINSZ, &w);
|
|
855 }
|
|
856
|
|
857
|
|
858 /*
|
|
859 * Return class ID and maximum priority of it.
|
|
860 * Input:
|
|
861 * name: is class name (either TS or RT).
|
|
862 * maxpri: maximum priority for the class, returned in *maxpri.
|
|
863 * Output:
|
|
864 * pc_cid: class ID
|
|
865 */
|
|
866 static id_t
|
|
867 schedinfo(char *name, short *maxpri)
|
|
868 {
|
|
869 pcinfo_t info;
|
|
870 tsinfo_t *tsinfop;
|
|
871 rtinfo_t *rtinfop;
|
|
872
|
|
873 (void) strcpy(info.pc_clname, name);
|
|
874 if (priocntl(0L, 0L, PC_GETCID, (caddr_t)&info) == -1L) {
|
|
875 return (-1);
|
|
876 }
|
|
877 if (strcmp(name, "TS") == 0) { /* Time Shared */
|
|
878 tsinfop = (struct tsinfo *)info.pc_clinfo;
|
|
879 *maxpri = tsinfop->ts_maxupri;
|
|
880 } else if (strcmp(name, "RT") == 0) { /* Real Time */
|
|
881 rtinfop = (struct rtinfo *)info.pc_clinfo;
|
|
882 *maxpri = rtinfop->rt_maxpri;
|
|
883 } else {
|
|
884 return (-1);
|
|
885 }
|
|
886 return (info.pc_cid);
|
|
887 }
|
|
888
|
|
889
|
|
890 /*
|
|
891 * set the tli options for the given endpoint represented by fd
|
|
892 */
|
|
893 static void
|
|
894 cvcd_setopt(int fd, int name)
|
|
895 {
|
|
896 struct t_optmgmt *topt, *tropt;
|
|
897 struct opthdr *sockopt;
|
|
898 int on = 1;
|
|
899
|
|
900 topt = (struct t_optmgmt *)t_alloc(fd, T_OPTMGMT, 0);
|
|
901 if (topt == NULL) {
|
|
902 cvcd_err(LOG_ERR, "t_alloc: %s", t_errlist[t_errno]);
|
|
903 exit(1);
|
|
904 }
|
|
905 tropt = (struct t_optmgmt *)t_alloc(fd, T_OPTMGMT, 0);
|
|
906 if (tropt == NULL) {
|
|
907 cvcd_err(LOG_ERR, "t_alloc: %s", t_errlist[t_errno]);
|
|
908 exit(1);
|
|
909 }
|
|
910 topt->opt.buf = (char *)malloc(sizeof (struct opthdr) + sizeof (int));
|
|
911 topt->opt.maxlen = 0;
|
|
912 topt->opt.len = sizeof (struct opthdr) + sizeof (int);
|
|
913 topt->flags = T_NEGOTIATE;
|
|
914 sockopt = (struct opthdr *)topt->opt.buf;
|
|
915 sockopt->level = SOL_SOCKET;
|
|
916 sockopt->name = name;
|
|
917 sockopt->len = sizeof (int);
|
|
918 (void) memcpy((char *)(topt->opt.buf + sizeof (struct opthdr)),
|
|
919 (char *)&on, sizeof (on));
|
|
920 tropt->opt.buf = (char *)malloc(sizeof (struct opthdr) + sizeof (int));
|
|
921 tropt->opt.maxlen = sizeof (struct opthdr) + sizeof (int);
|
|
922
|
|
923 if (t_optmgmt(fd, topt, tropt) == -1) {
|
|
924 t_error("t_optmgmt");
|
|
925 exit(1);
|
|
926 }
|
|
927
|
|
928 t_free((char *)topt, T_OPTMGMT);
|
|
929 t_free((char *)tropt, T_OPTMGMT);
|
|
930 }
|