1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1988, 1992 The University of Utah and the Center
5 * for Software Science (CSS).
6 * Copyright (c) 1992, 1993
7 * The Regents of the University of California. All rights reserved.
8 *
9 * This code is derived from software contributed to Berkeley by
10 * the Center for Software Science of the University of Utah Computer
11 * Science Department. CSS requests users of this software to return
12 * to [email protected] any improvements that they make and grant
13 * CSS redistribution rights.
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following conditions
17 * are met:
18 * 1. Redistributions of source code must retain the above copyright
19 * notice, this list of conditions and the following disclaimer.
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
23 * 3. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 * from: @(#)utils.c 8.1 (Berkeley) 6/4/93
40 *
41 * From: Utah Hdr: utils.c 3.1 92/07/06
42 * Author: Jeff Forys, University of Utah CSS
43 */
44
45 #ifndef lint
46 #if 0
47 static const char sccsid[] = "@(#)utils.c 8.1 (Berkeley) 6/4/93";
48 #endif
49 #endif /* not lint */
50
51 #include <sys/param.h>
52 #include <sys/time.h>
53 #include <netinet/in.h>
54
55 #include <fcntl.h>
56 #include <signal.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <string.h>
60 #include <syslog.h>
61 #include <time.h>
62 #include <unistd.h>
63 #include "defs.h"
64
65 /*
66 ** DispPkt -- Display the contents of an RMPCONN packet.
67 **
68 ** Parameters:
69 ** rconn - packet to be displayed.
70 ** direct - direction packet is going (DIR_*).
71 **
72 ** Returns:
73 ** Nothing.
74 **
75 ** Side Effects:
76 ** None.
77 */
78 void
DispPkt(RMPCONN * rconn,int direct)79 DispPkt(RMPCONN *rconn, int direct)
80 {
81 static const char BootFmt[] = "\t\tRetCode:%u SeqNo:%x SessID:%x Vers:%u";
82 static const char ReadFmt[] = "\t\tRetCode:%u Offset:%x SessID:%x\n";
83
84 struct tm *tmp;
85 struct rmp_packet *rmp;
86 int i, omask;
87 u_int32_t t;
88
89 /*
90 * Since we will be working with RmpConns as well as DbgFp, we
91 * must block signals that can affect either.
92 */
93 omask = sigblock(sigmask(SIGHUP)|sigmask(SIGUSR1)|sigmask(SIGUSR2));
94
95 if (DbgFp == NULL) { /* sanity */
96 (void) sigsetmask(omask);
97 return;
98 }
99
100 /* display direction packet is going using '>>>' or '<<<' */
101 fputs((direct==DIR_RCVD)?"<<< ":(direct==DIR_SENT)?">>> ":"", DbgFp);
102
103 /* display packet timestamp */
104 tmp = localtime((time_t *)&rconn->tstamp.tv_sec);
105 fprintf(DbgFp, "%02d:%02d:%02d.%06ld ", tmp->tm_hour, tmp->tm_min,
106 tmp->tm_sec, rconn->tstamp.tv_usec);
107
108 /* display src or dst addr and information about network interface */
109 fprintf(DbgFp, "Addr: %s Intf: %s\n", EnetStr(rconn), IntfName);
110
111 rmp = &rconn->rmp;
112
113 /* display IEEE 802.2 Logical Link Control header */
114 (void) fprintf(DbgFp, "\t802.2 LLC: DSAP:%x SSAP:%x CTRL:%x\n",
115 rmp->hp_llc.dsap, rmp->hp_llc.ssap, ntohs(rmp->hp_llc.cntrl));
116
117 /* display HP extensions to 802.2 Logical Link Control header */
118 (void) fprintf(DbgFp, "\tHP Ext: DXSAP:%x SXSAP:%x\n",
119 ntohs(rmp->hp_llc.dxsap), ntohs(rmp->hp_llc.sxsap));
120
121 /*
122 * Display information about RMP packet using type field to
123 * determine what kind of packet this is.
124 */
125 switch(rmp->r_type) {
126 case RMP_BOOT_REQ: /* boot request */
127 (void) fprintf(DbgFp, "\tBoot Request:");
128 GETWORD(rmp->r_brq.rmp_seqno, t);
129 if (ntohs(rmp->r_brq.rmp_session) == RMP_PROBESID) {
130 if (WORDZE(rmp->r_brq.rmp_seqno))
131 fputs(" (Send Server ID)", DbgFp);
132 else
133 fprintf(DbgFp," (Send Filename #%u)",t);
134 }
135 (void) fputc('\n', DbgFp);
136 (void) fprintf(DbgFp, BootFmt, rmp->r_brq.rmp_retcode,
137 t, ntohs(rmp->r_brq.rmp_session),
138 ntohs(rmp->r_brq.rmp_version));
139 (void) fprintf(DbgFp, "\n\t\tMachine Type: ");
140 for (i = 0; i < RMP_MACHLEN; i++)
141 (void) fputc(rmp->r_brq.rmp_machtype[i], DbgFp);
142 DspFlnm(rmp->r_brq.rmp_flnmsize, &rmp->r_brq.rmp_flnm);
143 break;
144 case RMP_BOOT_REPL: /* boot reply */
145 fprintf(DbgFp, "\tBoot Reply:\n");
146 GETWORD(rmp->r_brpl.rmp_seqno, t);
147 (void) fprintf(DbgFp, BootFmt, rmp->r_brpl.rmp_retcode,
148 t, ntohs(rmp->r_brpl.rmp_session),
149 ntohs(rmp->r_brpl.rmp_version));
150 DspFlnm(rmp->r_brpl.rmp_flnmsize,&rmp->r_brpl.rmp_flnm);
151 break;
152 case RMP_READ_REQ: /* read request */
153 (void) fprintf(DbgFp, "\tRead Request:\n");
154 GETWORD(rmp->r_rrq.rmp_offset, t);
155 (void) fprintf(DbgFp, ReadFmt, rmp->r_rrq.rmp_retcode,
156 t, ntohs(rmp->r_rrq.rmp_session));
157 (void) fprintf(DbgFp, "\t\tNoOfBytes: %u\n",
158 ntohs(rmp->r_rrq.rmp_size));
159 break;
160 case RMP_READ_REPL: /* read reply */
161 (void) fprintf(DbgFp, "\tRead Reply:\n");
162 GETWORD(rmp->r_rrpl.rmp_offset, t);
163 (void) fprintf(DbgFp, ReadFmt, rmp->r_rrpl.rmp_retcode,
164 t, ntohs(rmp->r_rrpl.rmp_session));
165 (void) fprintf(DbgFp, "\t\tNoOfBytesSent: %zu\n",
166 rconn->rmplen - RMPREADSIZE(0));
167 break;
168 case RMP_BOOT_DONE: /* boot complete */
169 (void) fprintf(DbgFp, "\tBoot Complete:\n");
170 (void) fprintf(DbgFp, "\t\tRetCode:%u SessID:%x\n",
171 rmp->r_done.rmp_retcode,
172 ntohs(rmp->r_done.rmp_session));
173 break;
174 default: /* ??? */
175 (void) fprintf(DbgFp, "\tUnknown Type:(%d)\n",
176 rmp->r_type);
177 }
178 (void) fputc('\n', DbgFp);
179 (void) fflush(DbgFp);
180
181 (void) sigsetmask(omask); /* reset old signal mask */
182 }
183
184
185 /*
186 ** GetEtherAddr -- convert an RMP (Ethernet) address into a string.
187 **
188 ** An RMP BOOT packet has been received. Look at the type field
189 ** and process Boot Requests, Read Requests, and Boot Complete
190 ** packets. Any other type will be dropped with a warning msg.
191 **
192 ** Parameters:
193 ** addr - array of RMP_ADDRLEN bytes.
194 **
195 ** Returns:
196 ** Pointer to static string representation of `addr'.
197 **
198 ** Side Effects:
199 ** None.
200 **
201 ** Warnings:
202 ** - The return value points to a static buffer; it must
203 ** be copied if it's to be saved.
204 */
205 char *
GetEtherAddr(u_int8_t * addr)206 GetEtherAddr(u_int8_t *addr)
207 {
208 static char Hex[] = "0123456789abcdef";
209 static char etherstr[RMP_ADDRLEN*3];
210 int i;
211 char *cp;
212
213 /*
214 * For each byte in `addr', convert it to "<hexchar><hexchar>:".
215 * The last byte does not get a trailing `:' appended.
216 */
217 i = 0;
218 cp = etherstr;
219 for(;;) {
220 *cp++ = Hex[*addr >> 4 & 0xf];
221 *cp++ = Hex[*addr++ & 0xf];
222 if (++i == RMP_ADDRLEN)
223 break;
224 *cp++ = ':';
225 }
226 *cp = '\0';
227
228 return(etherstr);
229 }
230
231
232 /*
233 ** DispFlnm -- Print a string of bytes to DbgFp (often, a file name).
234 **
235 ** Parameters:
236 ** size - number of bytes to print.
237 ** flnm - address of first byte.
238 **
239 ** Returns:
240 ** Nothing.
241 **
242 ** Side Effects:
243 ** - Characters are sent to `DbgFp'.
244 */
245 void
DspFlnm(u_int size,char * flnm)246 DspFlnm(u_int size, char *flnm)
247 {
248 int i;
249
250 (void) fprintf(DbgFp, "\n\t\tFile Name (%u): <", size);
251 for (i = 0; i < size; i++)
252 (void) fputc(*flnm++, DbgFp);
253 (void) fputs(">\n", DbgFp);
254 }
255
256
257 /*
258 ** NewClient -- allocate memory for a new CLIENT.
259 **
260 ** Parameters:
261 ** addr - RMP (Ethernet) address of new client.
262 **
263 ** Returns:
264 ** Ptr to new CLIENT or NULL if we ran out of memory.
265 **
266 ** Side Effects:
267 ** - Memory will be malloc'd for the new CLIENT.
268 ** - If malloc() fails, a log message will be generated.
269 */
270 CLIENT *
NewClient(u_int8_t * addr)271 NewClient(u_int8_t *addr)
272 {
273 CLIENT *ctmp;
274
275 if ((ctmp = (CLIENT *) malloc(sizeof(CLIENT))) == NULL) {
276 syslog(LOG_ERR, "NewClient: out of memory (%s)",
277 GetEtherAddr(addr));
278 return(NULL);
279 }
280
281 memset(ctmp, 0, sizeof(CLIENT));
282 memmove(&ctmp->addr[0], addr, RMP_ADDRLEN);
283 return(ctmp);
284 }
285
286 /*
287 ** FreeClient -- free linked list of Clients.
288 **
289 ** Parameters:
290 ** None.
291 **
292 ** Returns:
293 ** Nothing.
294 **
295 ** Side Effects:
296 ** - All malloc'd memory associated with the linked list of
297 ** CLIENTS will be free'd; `Clients' will be set to NULL.
298 **
299 ** Warnings:
300 ** - This routine must be called with SIGHUP blocked.
301 */
302 void
FreeClients(void)303 FreeClients(void)
304 {
305 CLIENT *ctmp;
306
307 while (Clients != NULL) {
308 ctmp = Clients;
309 Clients = Clients->next;
310 FreeClient(ctmp);
311 }
312 }
313
314 /*
315 ** NewStr -- allocate memory for a character array.
316 **
317 ** Parameters:
318 ** str - null terminated character array.
319 **
320 ** Returns:
321 ** Ptr to new character array or NULL if we ran out of memory.
322 **
323 ** Side Effects:
324 ** - Memory will be malloc'd for the new character array.
325 ** - If malloc() fails, a log message will be generated.
326 */
327 char *
NewStr(char * str)328 NewStr(char *str)
329 {
330 char *stmp;
331
332 if ((stmp = (char *)malloc((unsigned) (strlen(str)+1))) == NULL) {
333 syslog(LOG_ERR, "NewStr: out of memory (%s)", str);
334 return(NULL);
335 }
336
337 (void) strcpy(stmp, str);
338 return(stmp);
339 }
340
341 /*
342 ** To save time, NewConn and FreeConn maintain a cache of one RMPCONN
343 ** in `LastFree' (defined below).
344 */
345
346 static RMPCONN *LastFree = NULL;
347
348 /*
349 ** NewConn -- allocate memory for a new RMPCONN connection.
350 **
351 ** Parameters:
352 ** rconn - initialization template for new connection.
353 **
354 ** Returns:
355 ** Ptr to new RMPCONN or NULL if we ran out of memory.
356 **
357 ** Side Effects:
358 ** - Memory may be malloc'd for the new RMPCONN (if not cached).
359 ** - If malloc() fails, a log message will be generated.
360 */
361 RMPCONN *
NewConn(RMPCONN * rconn)362 NewConn(RMPCONN *rconn)
363 {
364 RMPCONN *rtmp;
365
366 if (LastFree == NULL) { /* nothing cached; make a new one */
367 if ((rtmp = (RMPCONN *) malloc(sizeof(RMPCONN))) == NULL) {
368 syslog(LOG_ERR, "NewConn: out of memory (%s)",
369 EnetStr(rconn));
370 return(NULL);
371 }
372 } else { /* use the cached RMPCONN */
373 rtmp = LastFree;
374 LastFree = NULL;
375 }
376
377 /*
378 * Copy template into `rtmp', init file descriptor to `-1' and
379 * set ptr to next elem NULL.
380 */
381 memmove((char *)rtmp, (char *)rconn, sizeof(RMPCONN));
382 rtmp->bootfd = -1;
383 rtmp->next = NULL;
384
385 return(rtmp);
386 }
387
388 /*
389 ** FreeConn -- Free memory associated with an RMPCONN connection.
390 **
391 ** Parameters:
392 ** rtmp - ptr to RMPCONN to be free'd.
393 **
394 ** Returns:
395 ** Nothing.
396 **
397 ** Side Effects:
398 ** - Memory associated with `rtmp' may be free'd (or cached).
399 ** - File desc associated with `rtmp->bootfd' will be closed.
400 */
401 void
FreeConn(RMPCONN * rtmp)402 FreeConn(RMPCONN *rtmp)
403 {
404 /*
405 * If the file descriptor is in use, close the file.
406 */
407 if (rtmp->bootfd >= 0) {
408 (void) close(rtmp->bootfd);
409 rtmp->bootfd = -1;
410 }
411
412 if (LastFree == NULL) /* cache for next time */
413 rtmp = LastFree;
414 else /* already one cached; free this one */
415 free((char *)rtmp);
416 }
417
418 /*
419 ** FreeConns -- free linked list of RMPCONN connections.
420 **
421 ** Parameters:
422 ** None.
423 **
424 ** Returns:
425 ** Nothing.
426 **
427 ** Side Effects:
428 ** - All malloc'd memory associated with the linked list of
429 ** connections will be free'd; `RmpConns' will be set to NULL.
430 ** - If LastFree is != NULL, it too will be free'd & NULL'd.
431 **
432 ** Warnings:
433 ** - This routine must be called with SIGHUP blocked.
434 */
435 void
FreeConns(void)436 FreeConns(void)
437 {
438 RMPCONN *rtmp;
439
440 while (RmpConns != NULL) {
441 rtmp = RmpConns;
442 RmpConns = RmpConns->next;
443 FreeConn(rtmp);
444 }
445
446 if (LastFree != NULL) {
447 free((char *)LastFree);
448 LastFree = NULL;
449 }
450 }
451
452 /*
453 ** AddConn -- Add a connection to the linked list of connections.
454 **
455 ** Parameters:
456 ** rconn - connection to be added.
457 **
458 ** Returns:
459 ** Nothing.
460 **
461 ** Side Effects:
462 ** - RmpConn will point to new connection.
463 **
464 ** Warnings:
465 ** - This routine must be called with SIGHUP blocked.
466 */
467 void
AddConn(RMPCONN * rconn)468 AddConn(RMPCONN *rconn)
469 {
470 if (RmpConns != NULL)
471 rconn->next = RmpConns;
472 RmpConns = rconn;
473 }
474
475 /*
476 ** FindConn -- Find a connection in the linked list of connections.
477 **
478 ** We use the RMP (Ethernet) address as the basis for determining
479 ** if this is the same connection. According to the Remote Maint
480 ** Protocol, we can only have one connection with any machine.
481 **
482 ** Parameters:
483 ** rconn - connection to be found.
484 **
485 ** Returns:
486 ** Matching connection from linked list or NULL if not found.
487 **
488 ** Side Effects:
489 ** None.
490 **
491 ** Warnings:
492 ** - This routine must be called with SIGHUP blocked.
493 */
494 RMPCONN *
FindConn(RMPCONN * rconn)495 FindConn(RMPCONN *rconn)
496 {
497 RMPCONN *rtmp;
498
499 for (rtmp = RmpConns; rtmp != NULL; rtmp = rtmp->next)
500 if (bcmp((char *)&rconn->rmp.hp_hdr.saddr[0],
501 (char *)&rtmp->rmp.hp_hdr.saddr[0], RMP_ADDRLEN) == 0)
502 break;
503
504 return(rtmp);
505 }
506
507 /*
508 ** RemoveConn -- Remove a connection from the linked list of connections.
509 **
510 ** Parameters:
511 ** rconn - connection to be removed.
512 **
513 ** Returns:
514 ** Nothing.
515 **
516 ** Side Effects:
517 ** - If found, an RMPCONN will cease to exist and it will
518 ** be removed from the linked list.
519 **
520 ** Warnings:
521 ** - This routine must be called with SIGHUP blocked.
522 */
523 void
RemoveConn(RMPCONN * rconn)524 RemoveConn(RMPCONN *rconn)
525 {
526 RMPCONN *thisrconn, *lastrconn;
527
528 if (RmpConns == rconn) { /* easy case */
529 RmpConns = RmpConns->next;
530 FreeConn(rconn);
531 } else { /* must traverse linked list */
532 lastrconn = RmpConns; /* set back ptr */
533 thisrconn = lastrconn->next; /* set current ptr */
534 while (thisrconn != NULL) {
535 if (rconn == thisrconn) { /* found it */
536 lastrconn->next = thisrconn->next;
537 FreeConn(thisrconn);
538 break;
539 }
540 lastrconn = thisrconn;
541 thisrconn = thisrconn->next;
542 }
543 }
544 }
545