process.c revision 1.5
1 /* $NetBSD: process.c,v 1.5 1997/10/16 23:25:19 lukem Exp $ */ 2 3 /* 4 * Copyright (c) 1993-95 Mats O Jansson. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Mats O Jansson. 17 * 4. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __RCSID("$NetBSD: process.c,v 1.5 1997/10/16 23:25:19 lukem Exp $"); 35 #endif 36 37 #include "os.h" 38 #include "cmp.h" 39 #include "common.h" 40 #include "dl.h" 41 #include "file.h" 42 #include "get.h" 43 #include "mopdef.h" 44 #include "nmadef.h" 45 #include "pf.h" 46 #include "print.h" 47 #include "put.h" 48 #include "rc.h" 49 50 extern u_char buf[]; 51 extern int DebugFlag; 52 53 struct dllist dllist[MAXDL]; /* dump/load list */ 54 extern char dl_mcst[]; /* Dump/Load Multicast */ 55 extern char rc_mcst[]; /* Remote Console Multicast */ 56 57 void mopNextLoad __P((u_char *, u_char *, u_char, int)); 58 void mopProcessDL __P((FILE *, struct if_info *, u_char *, int *, 59 u_char *, u_char *, int, u_short)); 60 void mopProcessRC __P((FILE *, struct if_info *, u_char *, int *, 61 u_char *, u_char *, int, u_short)); 62 void mopProcessInfo __P((u_char *, int *, u_short, struct dllist *, int)); 63 void mopSendASV __P((u_char *, u_char *, struct if_info *, int)); 64 void mopStartLoad __P((u_char *, u_char *, struct dllist *, int)); 65 66 void 67 mopProcessInfo(pkt, index, moplen, dl_rpr, trans) 68 u_char *pkt; 69 int *index; 70 u_short moplen; 71 struct dllist *dl_rpr; 72 int trans; 73 { 74 u_short itype,tmps; 75 u_char ilen ,tmpc,device; 76 u_char uc1,uc2,uc3,*ucp; 77 78 device = 0; 79 80 switch(trans) { 81 case TRANS_ETHER: 82 moplen = moplen + 16; 83 break; 84 case TRANS_8023: 85 moplen = moplen + 14; 86 break; 87 } 88 89 itype = mopGetShort(pkt,index); 90 91 while (*index < (int)(moplen)) { 92 ilen = mopGetChar(pkt,index); 93 switch (itype) { 94 case 0: 95 tmpc = mopGetChar(pkt,index); 96 *index = *index + tmpc; 97 break; 98 case MOP_K_INFO_VER: 99 uc1 = mopGetChar(pkt,index); 100 uc2 = mopGetChar(pkt,index); 101 uc3 = mopGetChar(pkt,index); 102 break; 103 case MOP_K_INFO_MFCT: 104 tmps = mopGetShort(pkt,index); 105 break; 106 case MOP_K_INFO_CNU: 107 ucp = pkt + *index; *index = *index + 6; 108 break; 109 case MOP_K_INFO_RTM: 110 tmps = mopGetShort(pkt,index); 111 break; 112 case MOP_K_INFO_CSZ: 113 tmps = mopGetShort(pkt,index); 114 break; 115 case MOP_K_INFO_RSZ: 116 tmps = mopGetShort(pkt,index); 117 break; 118 case MOP_K_INFO_HWA: 119 ucp = pkt + *index; *index = *index + 6; 120 break; 121 case MOP_K_INFO_TIME: 122 ucp = pkt + *index; *index = *index + 10; 123 break; 124 case MOP_K_INFO_SOFD: 125 device = mopGetChar(pkt,index); 126 break; 127 case MOP_K_INFO_SFID: 128 tmpc = mopGetChar(pkt,index); 129 ucp = pkt + *index; *index = *index + tmpc; 130 break; 131 case MOP_K_INFO_PRTY: 132 tmpc = mopGetChar(pkt,index); 133 break; 134 case MOP_K_INFO_DLTY: 135 tmpc = mopGetChar(pkt,index); 136 break; 137 case MOP_K_INFO_DLBSZ: 138 tmps = mopGetShort(pkt,index); 139 dl_rpr->dl_bsz = tmps; 140 break; 141 default: 142 if (((device = NMA_C_SOFD_LCS) || /* DECserver 100 */ 143 (device = NMA_C_SOFD_DS2) || /* DECserver 200 */ 144 (device = NMA_C_SOFD_DP2) || /* DECserver 250 */ 145 (device = NMA_C_SOFD_DS3)) && /* DECserver 300 */ 146 ((itype > 101) && (itype < 107))) 147 { 148 switch (itype) { 149 case 102: 150 ucp = pkt + *index; 151 *index = *index + ilen; 152 break; 153 case 103: 154 ucp = pkt + *index; 155 *index = *index + ilen; 156 break; 157 case 104: 158 tmps = mopGetShort(pkt,index); 159 break; 160 case 105: 161 ucp = pkt + *index; 162 *index = *index + ilen; 163 break; 164 case 106: 165 ucp = pkt + *index; 166 *index = *index + ilen; 167 break; 168 }; 169 } else { 170 ucp = pkt + *index; *index = *index + ilen; 171 }; 172 } 173 itype = mopGetShort(pkt,index); 174 } 175 } 176 177 void 178 mopSendASV(dst, src, ii, trans) 179 u_char *dst,*src; 180 struct if_info *ii; 181 int trans; 182 { 183 u_char pkt[200], *p; 184 int index; 185 u_char mopcode = MOP_K_CODE_ASV; 186 u_short newlen = 0,ptype = MOP_K_PROTO_DL; 187 188 index = 0; 189 mopPutHeader(pkt, &index, dst, src, ptype, trans); 190 191 p = &pkt[index]; 192 mopPutChar(pkt,&index,mopcode); 193 194 mopPutLength(pkt, trans, index); 195 newlen = mopGetLength(pkt, trans); 196 197 if ((DebugFlag == DEBUG_ONELINE)) { 198 mopPrintOneline(stdout, pkt, trans); 199 } 200 201 if ((DebugFlag >= DEBUG_HEADER)) { 202 mopPrintHeader(stdout, pkt, trans); 203 mopPrintMopHeader(stdout, pkt, trans); 204 } 205 206 if ((DebugFlag >= DEBUG_INFO)) { 207 mopDumpDL(stdout, pkt, trans); 208 } 209 210 if (pfWrite(ii->fd, pkt, index, trans) != index) { 211 if (DebugFlag) { 212 (void)fprintf(stderr, "error pfWrite()\n"); 213 } 214 } 215 } 216 217 void 218 mopStartLoad(dst, src, dl_rpr, trans) 219 u_char *dst,*src; 220 struct dllist *dl_rpr; 221 int trans; 222 { 223 int len; 224 int i, slot; 225 u_char pkt[BUFSIZE], *p; 226 int index; 227 u_char mopcode = MOP_K_CODE_MLD; 228 u_short newlen,ptype = MOP_K_PROTO_DL; 229 230 slot = -1; 231 232 /* Look if we have a non terminated load, if so, use it's slot */ 233 234 for (i = 0; i < MAXDL; i++) { 235 if (dllist[i].status != DL_STATUS_FREE) { 236 if (mopCmpEAddr(dllist[i].eaddr,dst) == 0) { 237 slot = i; 238 } 239 } 240 } 241 242 /* If no slot yet, then find first free */ 243 244 if (slot == -1) { 245 for (i = 0; i < MAXDL; i++) { 246 if (dllist[i].status == DL_STATUS_FREE) { 247 if (slot == -1) { 248 slot = i; 249 memmove((char *)dst, 250 (char *)dllist[i].eaddr, 6); 251 } 252 } 253 } 254 } 255 256 /* If no slot yet, then return. No slot is free */ 257 258 if (slot == -1) 259 return; 260 261 /* Ok, save info from RPR */ 262 263 dllist[slot] = *dl_rpr; 264 dllist[slot].status = DL_STATUS_READ_IMGHDR; 265 266 /* Get Load and Transfer Address. */ 267 268 GetFileInfo(dllist[slot].ldfd, 269 &dllist[slot].loadaddr, 270 &dllist[slot].xferaddr, 271 &dllist[slot].aout, 272 &dllist[slot].a_text, &dllist[slot].a_text_fill, 273 &dllist[slot].a_data, &dllist[slot].a_data_fill, 274 &dllist[slot].a_bss, &dllist[slot].a_bss_fill); 275 276 dllist[slot].nloadaddr = dllist[slot].loadaddr; 277 dllist[slot].lseek = lseek(dllist[slot].ldfd,0L,SEEK_CUR); 278 dllist[slot].a_lseek = 0; 279 280 dllist[slot].count = 0; 281 if (dllist[slot].dl_bsz >= 1492) 282 dllist[slot].dl_bsz = 1492; 283 if (dllist[slot].dl_bsz == 1030) /* VS/uVAX 2000 needs this */ 284 dllist[slot].dl_bsz = 1000; 285 if (trans == TRANS_8023) 286 dllist[slot].dl_bsz = dllist[slot].dl_bsz - 8; 287 288 index = 0; 289 mopPutHeader(pkt, &index, dst, src, ptype, trans); 290 p = &pkt[index]; 291 mopPutChar (pkt,&index,mopcode); 292 293 mopPutChar (pkt,&index,dllist[slot].count); 294 mopPutLong (pkt,&index,dllist[slot].loadaddr); 295 296 len = mopFileRead(&dllist[slot],&pkt[index]); 297 298 dllist[slot].nloadaddr = dllist[slot].loadaddr + len; 299 index = index + len; 300 301 mopPutLength(pkt, trans, index); 302 newlen = mopGetLength(pkt, trans); 303 304 if ((DebugFlag == DEBUG_ONELINE)) { 305 mopPrintOneline(stdout, pkt, trans); 306 } 307 308 if ((DebugFlag >= DEBUG_HEADER)) { 309 mopPrintHeader(stdout, pkt, trans); 310 mopPrintMopHeader(stdout, pkt, trans); 311 } 312 313 if ((DebugFlag >= DEBUG_INFO)) { 314 mopDumpDL(stdout, pkt, trans); 315 } 316 317 if (pfWrite(dllist[slot].ii->fd, pkt, index, trans) != index) { 318 if (DebugFlag) { 319 (void)fprintf(stderr, "error pfWrite()\n"); 320 } 321 } 322 323 dllist[slot].status = DL_STATUS_SENT_MLD; 324 } 325 326 void 327 mopNextLoad(dst, src, new_count, trans) 328 u_char *dst,*src,new_count; 329 int trans; 330 { 331 int len; 332 int i, slot; 333 u_char pkt[BUFSIZE], *p; 334 int index, pindex; 335 char line[100]; 336 u_short newlen = 0,ptype = MOP_K_PROTO_DL; 337 u_char mopcode; 338 339 slot = -1; 340 341 for (i = 0; i < MAXDL; i++) { 342 if (dllist[i].status != DL_STATUS_FREE) { 343 if (mopCmpEAddr(dst,dllist[i].eaddr) == 0) 344 slot = i; 345 } 346 } 347 348 /* If no slot yet, then return. No slot is free */ 349 350 if (slot == -1) 351 return; 352 353 if ((new_count == ((dllist[slot].count+1) % 256))) { 354 dllist[slot].loadaddr = dllist[slot].nloadaddr; 355 dllist[slot].count = new_count; 356 } else { 357 return; 358 } 359 360 if (dllist[slot].status == DL_STATUS_SENT_PLT) { 361 close(dllist[slot].ldfd); 362 dllist[slot].ldfd = 0; 363 dllist[slot].status = DL_STATUS_FREE; 364 sprintf(line, 365 "%x:%x:%x:%x:%x:%x Load completed", 366 dst[0],dst[1],dst[2],dst[3],dst[4],dst[5]); 367 syslog(LOG_INFO, line); 368 return; 369 } 370 371 dllist[slot].lseek = lseek(dllist[slot].ldfd,0L,SEEK_CUR); 372 373 if (dllist[slot].dl_bsz >= 1492) 374 dllist[slot].dl_bsz = 1492; 375 376 index = 0; 377 mopPutHeader(pkt, &index, dst, src, ptype, trans); 378 p = &pkt[index]; 379 mopcode = MOP_K_CODE_MLD; 380 pindex = index; 381 mopPutChar (pkt,&index,mopcode); 382 mopPutChar (pkt,&index,dllist[slot].count); 383 mopPutLong (pkt,&index,dllist[slot].loadaddr); 384 385 len = mopFileRead(&dllist[slot],&pkt[index]); 386 387 if (len > 0 ) { 388 389 dllist[slot].nloadaddr = dllist[slot].loadaddr + len; 390 index = index + len; 391 392 mopPutLength(pkt, trans, index); 393 newlen = mopGetLength(pkt, trans); 394 395 } else { 396 if (len == 0) { 397 index = pindex; 398 mopcode = MOP_K_CODE_PLT; 399 mopPutChar (pkt,&index,mopcode); 400 mopPutChar (pkt,&index,dllist[slot].count); 401 mopPutChar (pkt,&index,MOP_K_PLTP_HSN); 402 mopPutChar (pkt,&index,3); 403 mopPutMulti(pkt,&index,"ipc",3); 404 mopPutChar (pkt,&index,MOP_K_PLTP_HSA); 405 mopPutChar (pkt,&index,6); 406 mopPutMulti(pkt,&index,src,6); 407 mopPutChar (pkt,&index,MOP_K_PLTP_HST); 408 mopPutTime (pkt,&index, 0); 409 mopPutChar (pkt,&index,0); 410 mopPutLong (pkt,&index,dllist[slot].xferaddr); 411 412 mopPutLength(pkt, trans, index); 413 newlen = mopGetLength(pkt, trans); 414 415 dllist[slot].status = DL_STATUS_SENT_PLT; 416 } else { 417 dllist[slot].status = DL_STATUS_FREE; 418 return; 419 } 420 } 421 422 if ((DebugFlag == DEBUG_ONELINE)) { 423 mopPrintOneline(stdout, pkt, trans); 424 } 425 426 if ((DebugFlag >= DEBUG_HEADER)) { 427 mopPrintHeader(stdout, pkt, trans); 428 mopPrintMopHeader(stdout, pkt, trans); 429 } 430 431 if ((DebugFlag >= DEBUG_INFO)) { 432 mopDumpDL(stdout, pkt, trans); 433 } 434 435 if (pfWrite(dllist[slot].ii->fd, pkt, index, trans) != index) { 436 if (DebugFlag) { 437 (void)fprintf(stderr, "error pfWrite()\n"); 438 } 439 } 440 } 441 442 void 443 mopProcessDL(fd, ii, pkt, index, dst, src, trans, len) 444 FILE *fd; 445 struct if_info *ii; 446 u_char *pkt; 447 int *index; 448 u_char *dst, *src; 449 int trans; 450 u_short len; 451 { 452 u_char tmpc; 453 u_short moplen; 454 u_char pfile[17], mopcode; 455 char filename[FILENAME_MAX]; 456 char line[100]; 457 int i,nfd,iindex; 458 struct dllist dl,*dl_rpr; 459 u_char rpr_pgty,load; 460 461 if ((DebugFlag == DEBUG_ONELINE)) { 462 mopPrintOneline(stdout, pkt, trans); 463 } 464 465 if ((DebugFlag >= DEBUG_HEADER)) { 466 mopPrintHeader(stdout, pkt, trans); 467 mopPrintMopHeader(stdout, pkt, trans); 468 } 469 470 if ((DebugFlag >= DEBUG_INFO)) { 471 mopDumpDL(stdout, pkt, trans); 472 } 473 474 moplen = mopGetLength(pkt, trans); 475 mopcode = mopGetChar(pkt,index); 476 477 switch (mopcode) { 478 case MOP_K_CODE_MLT: 479 break; 480 case MOP_K_CODE_DCM: 481 break; 482 case MOP_K_CODE_MLD: 483 break; 484 case MOP_K_CODE_ASV: 485 break; 486 case MOP_K_CODE_RMD: 487 break; 488 case MOP_K_CODE_RPR: 489 490 tmpc = mopGetChar(pkt,index); /* Device Type */ 491 492 tmpc = mopGetChar(pkt,index); /* Format Version */ 493 if ((tmpc != MOP_K_RPR_FORMAT) && 494 (tmpc != MOP_K_RPR_FORMAT_V3)) { 495 (void)fprintf(stderr,"mopd: Unknown RPR Format (%d) from ",tmpc); 496 mopPrintHWA(stderr,src); 497 (void)fprintf(stderr,"\n"); 498 } 499 500 rpr_pgty = mopGetChar(pkt,index); /* Program Type */ 501 502 tmpc = mopGetChar(pkt,index); /* Software ID Len */ 503 for (i = 0; i < tmpc; i++) { 504 pfile[i] = mopGetChar(pkt,index); 505 pfile[i+1] = '\0'; 506 } 507 508 if (tmpc == 0) { 509 /* In a normal implementation of a MOP Loader this */ 510 /* would cause a question to NML (DECnet) if this */ 511 /* node is known and if so what image to load. But */ 512 /* we don't have DECnet so we don't have anybody */ 513 /* to ask. My solution is to use the ethernet addr */ 514 /* as filename. Implementing a database would be */ 515 /* overkill. */ 516 sprintf(pfile,"%02x%02x%02x%02x%02x%02x%c", 517 src[0],src[1],src[2],src[3],src[4],src[5],0); 518 } 519 520 tmpc = mopGetChar(pkt,index); /* Processor */ 521 522 iindex = *index; 523 dl_rpr = &dl; 524 memset(dl_rpr, 0, sizeof(*dl_rpr)); 525 dl_rpr->ii = ii; 526 memmove((char *)(dl_rpr->eaddr), (char *)src, 6); 527 mopProcessInfo(pkt,index,moplen,dl_rpr,trans); 528 529 sprintf(filename,"%s/%s.SYS", MOP_FILE_PATH, pfile); 530 if ((mopCmpEAddr(dst,dl_mcst) == 0)) { 531 if ((nfd = open(filename, O_RDONLY, 0)) != -1) { 532 close(nfd); 533 mopSendASV(src, ii->eaddr, ii, trans); 534 sprintf(line, 535 "%x:%x:%x:%x:%x:%x (%d) Do you have %s? (Yes)", 536 src[0],src[1],src[2], 537 src[3],src[4],src[5],trans,pfile); 538 } else { 539 sprintf(line, 540 "%x:%x:%x:%x:%x:%x (%d) Do you have %s? (No)", 541 src[0],src[1],src[2], 542 src[3],src[4],src[5],trans,pfile); 543 } 544 syslog(LOG_INFO, line); 545 } else { 546 if ((mopCmpEAddr(dst,ii->eaddr) == 0)) { 547 dl_rpr->ldfd = open(filename, O_RDONLY, 0); 548 mopStartLoad(src, ii->eaddr, dl_rpr, trans); 549 sprintf(line, 550 "%x:%x:%x:%x:%x:%x Send me %s", 551 src[0],src[1],src[2], 552 src[3],src[4],src[5],pfile); 553 syslog(LOG_INFO, line); 554 } 555 } 556 557 break; 558 case MOP_K_CODE_RML: 559 560 load = mopGetChar(pkt,index); /* Load Number */ 561 562 tmpc = mopGetChar(pkt,index); /* Error */ 563 564 if ((mopCmpEAddr(dst,ii->eaddr) == 0)) { 565 mopNextLoad(src, ii->eaddr, load, trans); 566 } 567 568 break; 569 case MOP_K_CODE_RDS: 570 break; 571 case MOP_K_CODE_MDD: 572 break; 573 case MOP_K_CODE_CCP: 574 break; 575 case MOP_K_CODE_PLT: 576 break; 577 default: 578 break; 579 } 580 } 581 582 void 583 mopProcessRC(fd, ii, pkt, index, dst, src, trans, len) 584 FILE *fd; 585 struct if_info *ii; 586 u_char *pkt; 587 int *index; 588 u_char *dst, *src; 589 int trans; 590 u_short len; 591 { 592 u_char tmpc; 593 u_short tmps, moplen = 0; 594 u_char mopcode; 595 struct dllist dl,*dl_rpr; 596 597 if ((DebugFlag == DEBUG_ONELINE)) { 598 mopPrintOneline(stdout, pkt, trans); 599 } 600 601 if ((DebugFlag >= DEBUG_HEADER)) { 602 mopPrintHeader(stdout, pkt, trans); 603 mopPrintMopHeader(stdout, pkt, trans); 604 } 605 606 if ((DebugFlag >= DEBUG_INFO)) { 607 mopDumpRC(stdout, pkt, trans); 608 } 609 610 moplen = mopGetLength(pkt, trans); 611 mopcode = mopGetChar(pkt,index); 612 613 switch (mopcode) { 614 case MOP_K_CODE_RID: 615 break; 616 case MOP_K_CODE_BOT: 617 break; 618 case MOP_K_CODE_SID: 619 620 tmpc = mopGetChar(pkt,index); /* Reserved */ 621 622 if ((DebugFlag >= DEBUG_INFO)) { 623 (void)fprintf(stderr, "Reserved : %02x\n",tmpc); 624 } 625 626 tmps = mopGetShort(pkt,index); /* Receipt # */ 627 if ((DebugFlag >= DEBUG_INFO)) { 628 (void)fprintf(stderr, "Receipt Nbr : %04x\n",tmpc); 629 } 630 631 dl_rpr = &dl; 632 memset(dl_rpr, 0, sizeof(*dl_rpr)); 633 dl_rpr->ii = ii; 634 memmove((char *)(dl_rpr->eaddr), (char *)src, 6); 635 mopProcessInfo(pkt,index,moplen,dl_rpr,trans); 636 637 break; 638 case MOP_K_CODE_RQC: 639 break; 640 case MOP_K_CODE_CNT: 641 break; 642 case MOP_K_CODE_RVC: 643 break; 644 case MOP_K_CODE_RLC: 645 break; 646 case MOP_K_CODE_CCP: 647 break; 648 case MOP_K_CODE_CRA: 649 break; 650 default: 651 break; 652 } 653 } 654 655
Indexes created Wed Sep 24 05:09:52 GMT 2025