libexec/rbootd/utils.c

   1 /*
   2  * Copyright (c) 1988, 1992 The University of Utah and the Center
   3  *      for Software Science (CSS).
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * the Center for Software Science of the University of Utah Computer
   9  * Science Department.  CSS requests users of this software to return
  10  * to css-dist@cs.utah.edu any improvements that they make and grant
  11  * CSS redistribution rights.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  *      from: @(#)utils.c       8.1 (Berkeley) 6/4/93
  38  *
  39  * From: Utah Hdr: utils.c 3.1 92/07/06
  40  * Author: Jeff Forys, University of Utah CSS
  41  */
  42
  43 #ifndef lint
  44 #if 0
  45 static const char sccsid[] = "@(#)utils.c       8.1 (Berkeley) 6/4/93";
  46 #endif
  47 static const char rcsid[] =
  48   "$FreeBSD$";
  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
  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 *
 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
 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 *
 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
 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 *
 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 *
 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
 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
 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
 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 *
 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
 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 }