src/dps8/dps8

/* */
This source file includes following definitions.
hash32s
mgp_show_nunits
mgp_set_nunits
mgp_show_device_name
mgp_set_device_name
mgp_reset
mgpAttach
mgpDetach
mgp_init
get_ddcw
cmd_name
mgp_cmd
mgp_iom_cmd
mgp_process_event
pktype_name
chop_name
valid_chaos_host_address
copy_packet9_to_cbridge8
copy_cbridge8_to_packet9
mgp_checksum_raw
mgp_checksum
parse_packet_header
unparse_packet_header
dumppkt
mgp_init_dev_state
mgp_wants_to_read
find_free_conn
find_conn_for
make_cbridge_pkt
make_rfc_pkt
cbridge_open_socket
close_conn
cbridge_send_packet
handle_packet
handle_close
handle_lose
handle_connect
handle_mgp_packet
make_mgp_header
make_mgp_packet
make_status_packet
make_noop_packet
make_open_packet
make_connect_packet
receive_cbridge_opcode
poll_from_cbridge
   1 /*
   2  * vim: filetype=c:tabstop=4:ai:expandtab
   3  * SPDX-License-Identifier: ICU
   4  * scspell-id: 35c9cf5c-ebbf-11ed-8d34-80ee73e9b8e7
   5  *
   6  * ---------------------------------------------------------------------------
   7  *
   8  * Copyright (c) 2007-2013 Michael Mondy
   9  * Copyright (c) 2015-2018 Charles Anthony
  10  * Copyright (c) 2023 Björn Victor
  11  * Copyright (c) 2021-2025 The DPS8M Development Team
  12  *
  13  * This software is made available under the terms of the ICU License.
  14  * See the LICENSE.md file at the top-level directory of this distribution.
  15  *
  16  * ---------------------------------------------------------------------------
  17  */
  18 
  19 // Defining USE_SOCKET_DEV_APPROACH to 1 means taking "the socket_dev
  20 // approach", meaning the Read operation doesn't really do much, but
  21 // instead the event/poll loop (see mgp_process_event) does the actual
  22 // reading. This doesn't seem to work very well, basically nothing
  23 // gets read.
  24 
  25 // Defining USE_SOCKET_DEV_APPROACH to 0 means the Read operation does
  26 // the reading, returning IOM_CMD_DISCONNECT to signal that there is
  27 // something in the buffer. Additionally the event/poll loop
  28 // (mgp_process_event) checks if there is anything to read and in that
  29 // case explicitly does send_terminate_interrupt(). This works a
  30 // little bit better, as some things are actually read, but not
  31 // sufficiently well.
  32 
  33 #define USE_SOCKET_DEV_APPROACH 0
  34 
  35 #include <stdio.h>
  36 #include <ctype.h>
  37 #include <unistd.h>
  38 #include <stdint.h>
  39 #include <time.h>
  40 
  41 #include <sys/types.h>
  42 #include <sys/un.h>
  43 #include <sys/select.h>
  44 #include <sys/time.h>
  45 
  46 #include "dps8.h"
  47 #include "dps8_sir.h"
  48 #include "dps8_iom.h"
  49 #include "dps8_mgp.h"
  50 #include "dps8_sys.h"
  51 #include "dps8_cable.h"
  52 #include "dps8_cpu.h"
  53 #include "dps8_faults.h"
  54 #include "dps8_scu.h"
  55 #include "dps8_utils.h"
  56 
  57 #if defined(NO_LOCALE)
  58 # define xstrerror_l strerror
  59 #endif
  60 
  61 #if defined(FREE)
  62 # undef FREE
  63 #endif /* if defined(FREE) */
  64 #define FREE(p) do  \
  65   {                 \
  66     free((p));      \
  67     (p) = NULL;     \
  68   } while(0)
  69 
  70 #if defined(WITH_MGP_DEV)
  71 
  72 # define DBG_CTR  1
  73 
  74 static void mgp_init_dev_state(void);
  75 static void dumppkt(char *hdr, word36 *buf, uint words);
  76 static int  handle_mgp_packet(word36 *buf, uint words);
  77 static int  poll_from_cbridge(word36 *buf, uint words, uint probe_only);
  78 static void mgp_wants_to_read(uint iom_unit_idx, uint chan);
  79 
  80 # define MAX_CONNS  64
  81 
  82 struct conn_table
  83 {
  84   int skt;                    /* socket to cbridge                     */
  85   u_short remote_addr;        /* remote address (from connect/cbridge) */
  86   char *contact_name;         /* contact name (likewise)               */
  87   u_short local_id;           /* local id                              */
  88   u_short multics_proc;
  89   u_char pkt_last_received;   /* from Multics */
  90   u_char pkt_last_sent;       /* to Multics   */
  91 };
  92 
  93 struct mgp_dev_state
  94 {
  95   u_char first_frame_received;
  96   u_char frame_last_received; /* from Multics                             */
  97   u_char frame_last_sent;     /* to Multics                               */
  98   u_char send_noop;           /* set to make sure NOOP is sent to Multics */
  99   short read_index;           /* conn we last read from, for round-robin  */
 100   u_char want_to_read;        /* flag that Multics wants to read          */
 101   uint read_unit_idx;
 102   uint read_unit_chan;
 103   struct conn_table conns[MAX_CONNS];
 104 } mgp_dev_state;
 105 
 106 static struct mgp_state
 107   {
 108     char device_name[MAX_DEV_NAME_LEN];
 109   } mgp_state[N_MGP_UNITS_MAX];
 110 
 111 # define N_MGP_UNITS  2 // default
 112 
 113 # define UNIT_FLAGS \
 114         ( UNIT_FIX | UNIT_ATTABLE | UNIT_ROABLE | UNIT_DISABLE | UNIT_IDLE )
 115 
 116 UNIT mgp_unit[N_MGP_UNITS_MAX] = {
 117   {
 118     UDATA(NULL, UNIT_FLAGS, 0),
 119     0,   0,   0,   0,   0,
 120     NULL,  NULL,  NULL,  NULL
 121   }
 122 };
 123 
 124 static inline uint32_t
 125 hash32s(const void *buf, size_t len, uint32_t h)
     /*  */
 126 {
 127   const unsigned char *p = buf;
 128 
 129   for (size_t i = 0; i < len; i++)
 130     h = h * 31 + p[i];
 131 
 132   h ^= h >> 17;
 133   h *= UINT32_C(0xed5ad4bb);
 134   h ^= h >> 11;
 135   h *= UINT32_C(0xac4c1b51);
 136   h ^= h >> 15;
 137   h *= UINT32_C(0x31848bab);
 138   h ^= h >> 14;
 139 
 140   return h;
 141 }
 142 
 143 # define MGP_UNIT_IDX(uptr)  (( uptr ) - mgp_unit )
 144 
 145 static DEBTAB mgp_dt[] = {
 146      { "NOTIFY", DBG_NOTIFY, NULL },
 147      { "INFO",   DBG_INFO,   NULL },
 148      { "ERR",    DBG_ERR,    NULL },
 149      { "WARN",   DBG_WARN,   NULL },
 150      { "DEBUG",  DBG_DEBUG,  NULL },
 151      { "ALL",    DBG_ALL,    NULL }, // Don't move as it messes up DBG message
 152      { NULL,     0,          NULL }
 153 };
 154 
 155 static t_stat
 156 mgp_show_nunits(UNUSED FILE *st, UNUSED UNIT *uptr, UNUSED int val,
     /*  */
 157                 UNUSED const void *desc)
 158 {
 159   sim_printf("Number of MGP units in system is %d\r\n", mgp_dev.numunits);
 160 
 161   return SCPE_OK;
 162 }
 163 
 164 static t_stat
 165 mgp_set_nunits(UNUSED UNIT *uptr, UNUSED int32 value, const char *cptr,
     /*  */
 166                UNUSED void *desc)
 167 {
 168   if (!cptr)
 169     {
 170       return SCPE_ARG;
 171     }
 172 
 173   int n = atoi(cptr);
 174   if (n < 1 || n > N_MGP_UNITS_MAX)
 175     {
 176       return SCPE_ARG;
 177     }
 178 
 179   mgp_dev.numunits = (uint32)n;
 180 
 181   return SCPE_OK;
 182 }
 183 
 184 static t_stat
 185 mgp_show_device_name(UNUSED FILE *st, UNIT *uptr, UNUSED int val,
     /*  */
 186                      UNUSED const void *desc)
 187 {
 188   int n = (int)MGP_UNIT_IDX(uptr);
 189 
 190   if (n < 0 || n >= N_MGP_UNITS_MAX)
 191     {
 192       return SCPE_ARG;
 193     }
 194 
 195   if (mgp_state[n].device_name[1] != 0)
 196     {
 197       sim_printf("name     : %s", mgp_state[n].device_name);
 198     }
 199   else
 200     {
 201       sim_printf("name     : MGP%d", n);
 202     }
 203 
 204   return SCPE_OK;
 205 }
 206 
 207 static t_stat
 208 mgp_set_device_name(UNIT *uptr, UNUSED int32 value, const char *cptr,
     /*  */
 209                     UNUSED void *desc)
 210 {
 211   int n = (int)MGP_UNIT_IDX(uptr);
 212 
 213   if (n < 0 || n >= N_MGP_UNITS_MAX)
 214     {
 215       return SCPE_ARG;
 216     }
 217 
 218   if (cptr)
 219     {
 220       strncpy(mgp_state[n].device_name, cptr, MAX_DEV_NAME_LEN - 1);
 221       mgp_state[n].device_name[MAX_DEV_NAME_LEN - 1] = 0;
 222     }
 223   else
 224     {
 225       mgp_state[n].device_name[0] = 0;
 226     }
 227 
 228   return SCPE_OK;
 229 }
 230 
 231 # define UNIT_WATCH  UNIT_V_UF
 232 
 233 static MTAB mgp_mod[] = {
 234 # if !defined(SPEED)
 235   { UNIT_WATCH, 1, "WATCH",   "WATCH",   0, 0, NULL, NULL },
 236   { UNIT_WATCH, 0, "NOWATCH", "NOWATCH", 0, 0, NULL, NULL },
 237 # endif /* if !defined(SPEED) */
 238   {
 239     MTAB_XTD | MTAB_VDV | MTAB_NMO | MTAB_VALR, /* Mask               */
 240     0,                                          /* Match              */
 241     "NUNITS",                                   /* Print string       */
 242     "NUNITS",                                   /* Match string       */
 243     mgp_set_nunits,                             /* Validation routine */
 244     mgp_show_nunits,                            /* Display routine    */
 245     "Number of MGP units in the system",        /* Value descriptor   */
 246     NULL                                        /* Help               */
 247   },
 248   {
 249     MTAB_XTD | MTAB_VUN | MTAB_VALR | MTAB_NC,  /* Mask               */
 250     0,                                          /* Match              */
 251     "NAME",                                     /* Print string       */
 252     "NAME",                                     /* Match string       */
 253     mgp_set_device_name,                        /* Validation routine */
 254     mgp_show_device_name,                       /* Display routine    */
 255     "Set the device name",                      /* Value descriptor   */
 256     NULL                                        /* Help               */
 257   },
 258   MTAB_eol
 259 };
 260 
 261 static t_stat
 262 mgp_reset(UNUSED DEVICE *dptr)
     /*  */
 263 {
 264   // mgpResetRX (0);
 265   // mgpResetTX (0);
 266 
 267   return SCPE_OK;
 268 }
 269 
 270 static t_stat
 271 mgpAttach(UNIT *uptr, const char *cptr)
     /*  */
 272 {
 273   if (!cptr)
 274     {
 275       return SCPE_ARG;
 276     }
 277 
 278   // If we're already attached, then detach ...
 279   if (( uptr->flags & UNIT_ATT ) != 0)
 280     {
 281       detach_unit(uptr);
 282     }
 283 
 284   uptr->flags |= UNIT_ATT;
 285 
 286   return SCPE_OK;
 287 }
 288 
 289 // Detach (connect) ...
 290 static t_stat
 291 mgpDetach(UNIT *uptr)
     /*  */
 292 {
 293   if (( uptr->flags & UNIT_ATT ) == 0)
 294     {
 295       return SCPE_OK;
 296     }
 297 
 298   uptr->flags &= ~(unsigned int)UNIT_ATT;
 299 
 300   return SCPE_OK;
 301 }
 302 
 303 DEVICE mgp_dev = {
 304   "MGP",       /* Name                */
 305   mgp_unit,    /* Units               */
 306   NULL,        /* Registers           */
 307   mgp_mod,     /* Modifiers           */
 308   N_MGP_UNITS, /* #units              */
 309   10,          /* Address radix       */
 310   24,          /* Address width       */
 311   1,           /* Address increment   */
 312   8,           /* Data radix          */
 313   36,          /* Data width          */
 314   NULL,        /* Examine             */
 315   NULL,        /* Deposit             */
 316   mgp_reset,   /* Reset               */
 317   NULL,        /* Boot                */
 318   mgpAttach,   /* Attach              */
 319   mgpDetach,   /* Detach              */
 320   NULL,        /* Context             */
 321   DEV_DEBUG,   /* Flags               */
 322   0,           /* Debug control flags */
 323   mgp_dt,      /* Debug flag names    */
 324   NULL,        /* Memory size change  */
 325   NULL,        /* Logical name        */
 326   NULL,        /* Help                */
 327   NULL,        /* Attach help         */
 328   NULL,        /* Attach context      */
 329   NULL,        /* Description         */
 330   NULL         /* End                 */
 331 };
 332 
 333 /*
 334  * mgp_init()
 335  */
 336 
 337 // Once-only initialization
 338 
 339 void
 340 mgp_init(void)
     /*  */
 341 {
 342   (void)memset(mgp_state, 0, sizeof ( mgp_state ));
 343   // Init the other state too
 344   mgp_init_dev_state();
 345 }
 346 
 347 static iom_cmd_rc_t
 348 get_ddcw(iom_chan_data_t *p, uint iom_unit_idx, uint chan, bool *ptro,
     /*  */
 349          uint expected_tally, uint *tally)
 350 {
 351 # if defined(TESTING)
 352   cpu_state_t * cpup = _cpup;
 353 # endif
 354   bool  send, uff;
 355   int   rc = iom_list_service(iom_unit_idx, chan, ptro, &send, &uff);
 356 
 357   if (rc < 0)
 358     {
 359       p->stati = 05001; // BUG: arbitrary error code; config switch
 360       sim_warn("%s list service failed\r\n", __func__);
 361 
 362       return IOM_CMD_ERROR;
 363     }
 364 
 365   if (uff)
 366     {
 367       sim_warn("%s ignoring uff\r\n", __func__); // XXX
 368     }
 369 
 370   if (!send)
 371     {
 372       sim_warn("%s nothing to send\r\n", __func__);
 373       p->stati = 05001; // BUG: arbitrary error code; config switch
 374 
 375       return IOM_CMD_ERROR;
 376     }
 377 
 378   if (IS_IDCW(p) || IS_TDCW(p))
 379     {
 380       sim_warn("%s expected DDCW\r\n", __func__);
 381       p->stati = 05001; // BUG: arbitrary error code; config switch
 382 
 383       return IOM_CMD_ERROR;
 384     }
 385 
 386   *tally = p->DDCW_TALLY;
 387 
 388   if (*tally == 0)
 389     {
 390       sim_debug(DBG_DEBUG, &mgp_dev,
 391                 "%s: Tally of zero interpreted as 010000(4096)\r\n", __func__);
 392       *tally = 4096;
 393     }
 394 
 395   sim_debug(DBG_DEBUG, &mgp_dev,
 396             "%s: Tally %d (%o)\r\n", __func__, *tally, *tally);
 397 
 398   if (expected_tally && *tally != expected_tally)
 399     {
 400       sim_warn("mgp_dev call expected tally of %d; got %d\r\n",
 401                expected_tally, *tally);
 402       p->stati = 05001; // BUG: arbitrary error code; config switch
 403 
 404       return IOM_CMD_ERROR;
 405     }
 406 
 407   return IOM_CMD_PROCEED;
 408 }
 409 
 410 static char *
 411 cmd_name(int code)
     /*  */
 412 {
 413   // Where can I find documentation for these?
 414   switch (code)
 415     {
 416     case 000:
 417       return "Request status";
 418 
 419     case 001:
 420       return "Read";
 421 
 422     case 011:
 423       return "Write";
 424 
 425     case 020:
 426       return "Host switch down";
 427 
 428     case 040:
 429       return "Reset status";
 430 
 431     case 042:
 432       return "Disable Bus Back";
 433 
 434     case 043:
 435       return "Enable Bus Back";
 436 
 437     case 060:
 438       return "Host switch up";
 439 
 440     default:
 441       return "Unknown";
 442     }
 443 }
 444 
 445 static iom_cmd_rc_t
 446 mgp_cmd(uint iom_unit_idx, uint chan)
     /*  */
 447 {
 448 # if defined(TESTING)
 449   cpu_state_t * cpup = _cpup;
 450 # endif
 451   iom_chan_data_t *p = &iom_chan_data[iom_unit_idx][chan];
 452 
 453   sim_debug(DBG_TRACE, &mgp_dev,
 454             "mgp_cmd CHAN_CMD %o DEV_CODE %o DEV_CMD %o COUNT %o\r\n",
 455             p->IDCW_CHAN_CMD, p->IDCW_DEV_CODE, p->IDCW_DEV_CMD, p->IDCW_COUNT);
 456 
 457   // Not IDCW?
 458   if (IS_NOT_IDCW(p))
 459     {
 460       sim_warn("%s: Unexpected IOTx\r\n", __func__);
 461 
 462       return IOM_CMD_ERROR;
 463     }
 464 
 465   bool ptro;
 466 
 467   sim_printf("mgp_cmd %#o (%s)\r\n",
 468              p->IDCW_DEV_CMD, cmd_name(p->IDCW_DEV_CMD));
 469 
 470   switch (p->IDCW_DEV_CMD)
 471     {
 472     case 000: // CMD 00 Request status
 473     {
 474       p->stati = 04000;
 475       sim_printf("mgp request status\r\n");
 476     }
 477     break;
 478 
 479     case 001: // CMD 01 Read
 480     {
 481       sim_debug(DBG_DEBUG, &mgp_dev, "%s: mgp_dev_$read\r\n", __func__);
 482 
 483       const uint    expected_tally = 0;
 484       uint          tally;
 485       iom_cmd_rc_t  rc
 486         = get_ddcw(p, iom_unit_idx, chan, &ptro, expected_tally, &tally);
 487       if (rc)
 488         {
 489           return rc;
 490         }
 491 
 492       word36  buffer[4096];  /* tally size is max 4096 bytes */
 493       uint    words_processed;
 494       iom_indirect_data_service(
 495         iom_unit_idx, chan, buffer, &words_processed, false);
 496 
 497       sim_printf("mgp_cmd: Read unit %#x chan %#x (%d)\r\n",
 498                  iom_unit_idx, chan, chan);
 499 
 500       /*
 501        * Command pending, don't send terminate interrupt
 502        */
 503 
 504       rc = IOM_CMD_PENDING;
 505 
 506       mgp_wants_to_read(iom_unit_idx, chan);
 507 # if !USE_SOCKET_DEV_APPROACH
 508       int v;
 509       if (( v = poll_from_cbridge(buffer, words_processed, 0)) < 0)
 510         {
 511           // nothing to read
 512           sim_printf("%s: nothing to read\r\n", __func__);
 513         }
 514       else
 515         {
 516           // something was read
 517           if (v > 0)
 518             {
 519               sim_printf("%s: read something, rc IOM_CMD_DISCONNECT\r\n",
 520                          __func__);
 521               rc = IOM_CMD_DISCONNECT; /* so send terminate interrupt */
 522             }
 523 
 524           dumppkt("Read", buffer, words_processed);
 525         }
 526 # endif /* if !USE_SOCKET_DEV_APPROACH */
 527 
 528       iom_indirect_data_service(
 529         iom_unit_idx, chan, buffer, &words_processed, true);
 530 
 531 
 532 
 533 
 534 
 535 
 536 
 537 
 538 
 539       p->stati = 04000; /* bogus status, since we're
 540                          * not sending terminate interrupt */
 541       return rc;
 542     }
 543     /*NOTREACHED*/ /* unreachable */
 544     break;
 545 
 546     case 011: // CMD 11 Write
 547     {
 548       sim_debug(DBG_DEBUG, &mgp_dev, "%s: mgp_dev_$write\r\n", __func__);
 549 
 550       const uint    expected_tally = 0;
 551       uint          tally;
 552       iom_cmd_rc_t  rc
 553         = get_ddcw(p, iom_unit_idx, chan, &ptro, expected_tally, &tally);
 554 
 555       word36  buffer[4096];  /* tally size is max 4096 bytes */
 556       uint    words_processed;
 557       iom_indirect_data_service(
 558         iom_unit_idx, chan, buffer, &words_processed, false);
 559 
 560       sim_printf("mgp_cmd: Write unit %#x chan %#x (%d)\r\n",
 561                  iom_unit_idx, chan, chan);
 562       dumppkt("Write", buffer, words_processed);
 563 
 564       int v = handle_mgp_packet(buffer, words_processed);
 565       sim_printf("%s: handle_mgp_packet returned %d\r\n", __func__, v);
 566 
 567 
 568 
 569 
 570 
 571 
 572 
 573 
 574 
 575 
 576       rc        = IOM_CMD_DISCONNECT; /* send terminate interrupt */
 577       p->stati  = 04000;
 578 
 579 
 580 
 581 
 582       iom_indirect_data_service(
 583         iom_unit_idx, chan, buffer, &words_processed, true);
 584 
 585       return rc;
 586     }
 587     /*NOTREACHED*/ /* unreachable */
 588     break;
 589 
 590     case 020: // CMD 20 Host switch down
 591     {
 592       p->stati = 04000;
 593       sim_printf("mgp host switch down\r\n");
 594     }
 595     break;
 596 
 597     case 040: // CMD 40 Reset status
 598     {
 599       p->stati = 04000;
 600       // is called repeatedly causing system console to be unusable
 601       // sim_printf ("mgp reset status\r\n");
 602     }
 603     break;
 604 
 605     case 042: // CMD 42 Disable Bus Back
 606     {
 607       p->stati = 04000;
 608       sim_printf("mgp disable bus back\r\n");
 609     }
 610     break;
 611 
 612     case 043: // CMD 43 Enable Bus Back
 613     {
 614       p->stati = 04000;
 615       sim_printf("mgp enable bus back\r\n");
 616     }
 617     break;
 618 
 619     case 060: // CMD 60 Host switch up
 620     {
 621       p->stati = 04000;
 622       sim_printf("mgp host switch up\r\n");
 623     }
 624     break;
 625 
 626     default:
 627     {
 628       if (p->IDCW_DEV_CMD != 051) // ignore bootload console probe
 629         {
 630           sim_warn("%s: MGP unrecognized device command  %02o\r\n",
 631             __func__, p->IDCW_DEV_CMD);
 632         }
 633 
 634       p->stati       = 04501; // cmd reject, invalid opcode
 635       p->chanStatus  = chanStatIncorrectDCW;
 636     }
 637       return IOM_CMD_ERROR;
 638     }
 639 
 640   if (p->IDCW_CHAN_CMD == 0)
 641     {
 642       return IOM_CMD_DISCONNECT; // don't do DCW list
 643     }
 644 
 645   return IOM_CMD_PROCEED;
 646 }
 647 
 648 //  3 == command pending
 649 //  2 == did command
 650 //  1 == ignored command
 651 //  0 == ok
 652 // -1 == problem
 653 
 654 iom_cmd_rc_t
 655 mgp_iom_cmd(uint iom_unit_idx, uint chan)
     /*  */
 656 {
 657   iom_chan_data_t *p = &iom_chan_data[iom_unit_idx][chan];
 658 
 659   // Is it an IDCW?
 660   if (IS_IDCW(p))
 661     {
 662       return mgp_cmd(iom_unit_idx, chan);
 663     }
 664 
 665   sim_printf("%s expected IDCW\r\n", __func__);
 666 
 667   return IOM_CMD_ERROR;
 668 }
 669 
 670 void
 671 mgp_process_event(void)
     /*  */
 672 {
 673 # if USE_SOCKET_DEV_APPROACH
 674   if (mgp_dev_state.want_to_read)
 675     {
 676       uint iom_unit_idx = mgp_dev_state.read_unit_idx;
 677       uint chan         = mgp_dev_state.read_unit_chan;
 678       // This is normally 128 or 129, needs 4 for header + 488/4 data = 128
 679       word36 buffer[128];
 680       uint words_processed = 128;
 681       (void)memset(buffer, 0, sizeof(buffer));
 682 
 683       int v = poll_from_cbridge(buffer, words_processed, 0);
 684       // mgp_dev_state.want_to_read = 0;
 685       if (v <= 0)
 686         {
 687           // nothing to read
 688           // sim_printf("%s: nothing to read\r\n", __func__);
 689         }
 690       else if (v > 0)
 691         {
 692           sim_printf("%s: read something (%d) for unit %d chan %d\r\n", __func__,
 693                      v, iom_unit_idx, chan);
 694           dumppkt("Read", buffer, words_processed);
 695           iom_indirect_data_service(
 696               iom_unit_idx, chan, buffer, &words_processed, true);
 697           send_terminate_interrupt(iom_unit_idx, chan);
 698         }
 699     }
 700 # else
 701   int v = poll_from_cbridge(NULL, 0, 1);
 702   if (v > 0)
 703     {
 704       uint iom_unit_idx = mgp_dev_state.read_unit_idx;
 705       uint chan         = mgp_dev_state.read_unit_chan;
 706       if (iom_chan_data[iom_unit_idx][chan].in_use != false )
 707         {
 708           // And avoid complaints
 709           sim_printf("%s: poll %d, terminate interrupt unit \"%s\": iom "
 710                      "unit %#x, chan %#x\r\n", __func__, v,
 711                      mgp_state[iom_unit_idx].device_name,
 712                      iom_unit_idx, chan);
 713           send_terminate_interrupt(iom_unit_idx, chan);
 714         }
 715     }
 716 # endif /* if USE_SOCKET_DEV_APPROACH */
 717 }
 718 
 719 # define CBRIDGE_PACKET_SOCKET        "/tmp/chaos_packet"
 720 # define CBRIDGE_PACKET_HEADER_SIZE   4
 721 # define CH_PK_MAX_DATALEN            488
 722 
 723 // Chaosnet opcodes
 724 enum
 725 {
 726   CHOP_RFC = 1,
 727   CHOP_OPN,
 728   CHOP_CLS,
 729   CHOP_FWD,
 730   CHOP_ANS,
 731   CHOP_SNS,
 732   CHOP_STS,
 733   CHOP_RUT,
 734   CHOP_LOS,
 735   CHOP_LSN,
 736   CHOP_MNT,
 737   CHOP_EOF,
 738   CHOP_UNC,
 739   CHOP_BRD,
 740   CHOP_ACK  = 0177, // Note: extension for the NCP Packet socket
 741   CHOP_DAT  = 0200,
 742   CHOP_DWD  = 0300
 743 };
 744 
 745 enum mgp_pktypes
 746 {
 747   pktype_NOOP = 1,
 748   pktype_CONNECT,
 749   pktype_OPEN,
 750   pktype_CLOSE,
 751   pktype_LOSE,
 752   pktype_STATUS,
 753   pktype_SEND_STATUS,
 754   pktype_ORDER,
 755   pktype_DATA = 255
 756 };
 757 
 758 static char *pktype_names[] = {
 759   "NULL", "NOOP",   "CONNECT",     "OPEN",  "CLOSE",
 760   "LOSE", "STATUS", "SEND_STATUS", "ORDER", NULL
 761   };
 762 
 763 static char *chop_names[] = {
 764   "NIL", "RFC", "OPN", "CLS", "FWD", "ANS", "SNS", "STS",
 765   "RUT", "LOS", "LSN", "MNT", "EOF", "UNC", "BRD"
 766   };
 767 
 768 static char *
 769 pktype_name(uint t)
     /*  */
 770 {
 771   if (( t > 0 ) && ( t <= pktype_ORDER ))
 772     {
 773       return pktype_names[t];
 774     }
 775   else if (t == pktype_DATA)
 776     {
 777       return "DATA";
 778     }
 779   else
 780     {
 781       return NULL;
 782     }
 783 }
 784 
 785 static char *
 786 chop_name(uint c)
     /*  */
 787 {
 788   if (( c > 0 ) && ( c <= CHOP_BRD ))
 789     {
 790       return chop_names[c];
 791     }
 792   else if (c == CHOP_ACK)
 793     {
 794       return "ACK";
 795     }
 796   else if (c >= 0200)  //-V536  /* Decimal: 128; Octal: 0200 */
 797     {
 798       return "DAT";
 799     }
 800   else
 801     {
 802       return NULL;
 803     }
 804 }
 805 
 806 // Number of words in an MGP packet header
 807 # define MGP_PACKET_HEADER_SIZE  4
 808 
 809 struct mgp_packet_header
 810 {
 811   // The u_char fields are "technically" 9-bit,
 812   // but they are always 8-bit in reality
 813   u_char checksum;             /* Checksum low byte in first word          */
 814   u_char identification;       /* A character that always appears here (#) */
 815   u_char packet_type;          /* Similar to Chaos operation code          */
 816   struct
 817   {                            /* bits about packet                        */
 818     u_int unusable  : 1;       /* can't transfer this bit to/from PDP-11   */
 819     u_int nak       : 1;       /* This packet is NAKing some packet        */
 820     u_int reply_now : 1;       /* This packet requires an immediate reply  */
 821     u_int padding   : 5;       /* Unused, reserved                         */
 822     u_int loopback  : 1;       /* Used for detecting errors                */
 823   } flags;
 824   u_char frame_number;         /* Per-link flow control                    */
 825   u_char receipt_number;       /* ditto                                    */
 826   u_char packet_number;        /* Per-connection flow control              */
 827   u_char ack_number;           /* ditto                                    */
 828   // These three are 2 x 9-bit in Multics, but implemented as 2 x 8-bit
 829   u_short byte_count;          /* Number of bytes in data                  */
 830   u_short source_process;      /* Who it came from                         */
 831   u_short destination_process; /* Who it's going to                        */
 832   u_char chaos_opcode;         /* The opcode in the original packet        */
 833   u_char reserved;             /* Not yet used.   MBZ                      */
 834 };
 835 
 836 int
 837 valid_chaos_host_address(u_short addr)
     /*  */
 838 {
 839   // both subnet and host part must be non-zero
 840   return ( addr > 0xff ) && (( addr & 0xff ) != 0 );
 841 }
 842 
 843 // Copy Multics packet data (9-bit) to cbridge packet data (8-bit).
 844 // words is max #words in buf, dlen is max #bytes in dest.
 845 static void
 846 copy_packet9_to_cbridge8(word36 *buf, uint words, u_char *dest, int dlen)
     /*  */
 847 {
 848 # if !defined(__clang_analyzer__)
 849   int j;
 850   /* Convert from 9-bit to 8-bit */
 851   for (j = 0; j < words * 4 && j < dlen; j++)
 852     {
 853       // Clang Analyzer warning: 1st function call argument is an uninitialized value
 854       dest[j] = getbits36_9(buf[MGP_PACKET_HEADER_SIZE + j / 4], ( j % 4 ) * 9);
 855     }
 856 # endif /* if !defined(__clang_analyzer__) */
 857 }
 858 
 859 // and the other way around
 860 static void
 861 copy_cbridge8_to_packet9(u_char *src, int slen, word36 *buf, uint words)
     /*  */
 862 {
 863   int j;
 864   /* Convert from 8-bit to 9-bit */
 865   for (j = 0; j < words * 4 && j < slen; j++)
 866     {
 867       putbits36_9(&buf[MGP_PACKET_HEADER_SIZE + j / 4], ( j % 4 ) * 9, src[j]);
 868     }
 869 }
 870 
 871 // cf mgp_checksum_.pl1
 872 // Compute checksum on a raw Multics packet
 873 u_char
 874 mgp_checksum_raw(word36 *buf, uint words)
     /*  */
 875 {
 876   int j, cks = 0;
 877   // Skip checksum and ident bytes
 878   for (j = 2; j < words * 4; j++)
 879     {
 880       cks += getbits36_9(buf[j / 4], ( j % 4 ) * 9);
 881     }
 882 
 883   return cks % 256;
 884 }
 885 
 886 // Compute checksum on a header struct and 8-bit byte body
 887 u_char
 888 mgp_checksum(struct mgp_packet_header *p, u_char *pkt, uint pklen)
     /*  */
 889 {
 890   uint i, cks = 0;
 891 
 892   // Flags are actually 9 bits!
 893   cks  = ( p->flags.unusable  << 8 )
 894        | ( p->flags.nak       << 7 )
 895        | ( p->flags.reply_now << 6 )
 896        | ( p->flags.padding   << 1 )
 897        |   p->flags.loopback;
 898 
 899   cks  +=  p->packet_type
 900        +   p->frame_number
 901        +   p->receipt_number
 902        +   p->packet_number
 903        +   p->ack_number
 904        + ( p->byte_count           & 0xff )
 905        + ( p->byte_count          >> 8    )
 906        + ( p->source_process       & 0xff )
 907        + ( p->source_process      >> 8    )
 908        + ( p->destination_process  & 0xff )
 909        + ( p->destination_process >> 8    )
 910        +   p->chaos_opcode;
 911   for (i = 0; i < pklen; i++)
 912     {
 913       cks += pkt[i]; //-V557 //-V522 /* XXX */
 914     }
 915 
 916   return cks % 256;
 917 }
 918 
 919 static struct mgp_packet_header *
 920 parse_packet_header(word36 *buf, uint words)
     /*  */
 921 {
 922   if (words * 4 < sizeof ( struct mgp_packet_header ))
 923     {
 924       sim_printf("%s: buffer too small (%d words) for mgp packet header\r\n",
 925                  __func__, words);
 926 
 927       return NULL;
 928     }
 929 
 930   struct mgp_packet_header *p = malloc(sizeof ( struct mgp_packet_header ));
 931   if (p == NULL)
 932     {
 933       (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 934                      __func__, __FILE__, __LINE__);
 935 # if defined(USE_BACKTRACE)
 936 #  if defined(SIGUSR2)
 937       (void)raise(SIGUSR2);
 938       /*NOTREACHED*/ /* unreachable */
 939 #  endif /* if defined(SIGUSR2) */
 940 # endif /* if defined(USE_BACKTRACE) */
 941       abort();
 942     }
 943 
 944   int checksum        = getbits36_9(buf[0],  0);
 945   int id              = getbits36_9(buf[0],  9);
 946   int pktype          = getbits36_9(buf[0], 18);
 947   // int flags        = getbits36_9(buf[0], 27);
 948   int f_unus          = getbits36_1(buf[0], 27);
 949   int f_nak           = getbits36_1(buf[0], 28);
 950   int f_rnow          = getbits36_1(buf[0], 29);
 951   int f_pad           = getbits36_5(buf[0], 30);
 952   int f_loop          = getbits36_1(buf[0], 35);
 953 
 954   p->checksum         = checksum;
 955   p->identification   = id;
 956   p->packet_type      = pktype;
 957   p->flags.unusable   = f_unus;
 958   p->flags.nak        = f_nak;
 959   p->flags.reply_now  = f_rnow;
 960   p->flags.padding    = f_pad;
 961   p->flags.loopback   = f_loop;
 962 
 963   int framenr         = getbits36_9(buf[1],  0);
 964   int rcpt            = getbits36_9(buf[1],  9);
 965   int pknr            = getbits36_9(buf[1], 18);
 966   int acknr           = getbits36_9(buf[1], 27);
 967 
 968   p->frame_number     = framenr;
 969   p->receipt_number   = rcpt;
 970   p->packet_number    = pknr;
 971   p->ack_number       = acknr;
 972 
 973   // Note: 8-bit byte values combine to 16-bit values.
 974   int bytecount  =     ( getbits36_9(buf[2],  0) & 0xff )
 975                     | (( getbits36_9(buf[2],  9) & 0xff ) << 8 );
 976   int srcprc     =     ( getbits36_9(buf[2], 18) & 0xff )
 977                     | (( getbits36_9(buf[2], 27) & 0xff ) << 8 );
 978 
 979   p->byte_count      = bytecount;
 980   p->source_process  = srcprc;
 981 
 982   int dstprc     =     ( getbits36_9(buf[3],  0) & 0xff )
 983                     | (( getbits36_9(buf[3],  9) & 0xff ) << 8 );
 984   int chopcode   =       getbits36_9(buf[3], 18);
 985   int mbz        =       getbits36_9(buf[3], 27);
 986 
 987   p->destination_process  = dstprc;
 988   p->chaos_opcode         = chopcode;
 989   p->reserved             = mbz;
 990 
 991   return p;
 992 }
 993 
 994 static void
 995 unparse_packet_header(struct mgp_packet_header *p, word36 *buf, uint words)
     /*  */
 996 {
 997   if (words * 4 < sizeof ( struct mgp_packet_header ))
 998     {
 999       sim_printf("%s: buffer too small (%d words) for mgp packet header\r\n",
1000                  __func__, words);
1001 
1002       return;
1003     }
1004 
1005   putbits36_9(&buf[0],  0, p->checksum);
1006   putbits36_9(&buf[0],  9, p->identification);
1007   putbits36_9(&buf[0], 18, p->packet_type);
1008   putbits36_1(&buf[0], 27, p->flags.unusable);
1009   putbits36_1(&buf[0], 28, p->flags.nak);
1010   putbits36_1(&buf[0], 29, p->flags.reply_now);
1011   putbits36_5(&buf[0], 30, p->flags.padding);
1012   putbits36_1(&buf[0], 35, p->flags.loopback);
1013 
1014   putbits36_9(&buf[1],  0, p->frame_number);
1015   putbits36_9(&buf[1],  9, p->receipt_number);
1016   putbits36_9(&buf[1], 18, p->packet_number);
1017   putbits36_9(&buf[1], 27, p->ack_number);
1018 
1019   // Note: these mgp_packet_header values
1020   // are 16 bits, and put in 9-bit fields
1021 
1022   putbits36_9(&buf[2],  0, p->byte_count      & 0xff);
1023   putbits36_9(&buf[2],  9, p->byte_count     >> 8   );
1024   putbits36_9(&buf[2], 18, p->source_process  & 0xff);
1025   putbits36_9(&buf[2], 27, p->source_process >> 8   );
1026 
1027   putbits36_9(&buf[3],  0, p->destination_process  & 0xff);
1028   putbits36_9(&buf[3],  9, p->destination_process >> 8   );
1029 
1030   putbits36_9(&buf[3], 18, p->chaos_opcode);
1031   putbits36_9(&buf[3], 27, p->reserved);
1032 }
1033 
1034 static void
1035 dumppkt(char *hdr, word36 *buf, uint words)
     /*  */
1036 {
1037   int i;
1038   struct mgp_packet_header *p = parse_packet_header(buf, words);
1039   if (p == NULL)
1040     {
1041       sim_printf("%s: failed to parse packet!\r\n", __func__);
1042 
1043       return;
1044     }
1045 
1046   sim_printf("%s packet (%d words)\r\n", hdr, words);
1047   sim_printf("cks %#x, id %#x, type %#x (%s), flags %#x (%s%s%s%s)\r\n"
1048              "frame %#x, rcpt %#x, pknr %#x, acknr %#x\r\n"
1049              "bytecount %d, src %#x, dst %#x, chopcode %#o (%s)\r\n",
1050              p->checksum, p->identification, p->packet_type,
1051              pktype_name(p->packet_type),
1052              ( p->flags.unusable << 8 ) | ( p->flags.nak << 7 )
1053              | ( p->flags.reply_now << 6 ) | ( p->flags.padding << 1 )
1054              | p->flags.loopback, p->flags.unusable ? "unusable " : "",
1055              p->flags.nak ? "NAK " : "", p->flags.reply_now ? "rNOW " : "",
1056              p->flags.loopback ? "loop" : "", p->frame_number,
1057              p->receipt_number, p->packet_number, p->ack_number,
1058              p->byte_count, p->source_process, p->destination_process,
1059              p->chaos_opcode, chop_name(p->chaos_opcode));
1060 
1061   if (p->identification != '#')
1062     {
1063       sim_printf("[Warning: identification byte is %d instead of %d]\r\n",
1064                  p->identification, '#');
1065     }
1066 
1067   if (p->reserved != 0)
1068     {
1069       sim_printf("[Warning: MBZ byte is %d]\r\n", p->reserved);
1070     }
1071 
1072   int pklen = 4 + ( p->byte_count / 4 ) \
1073                 + ( p->byte_count % 4 ? 1 : 0 );
1074   FREE(p);
1075   for (i = 0; i < pklen; i++)
1076     {
1077       int lh  = getbits36_18 (buf[i],  0);
1078       int rh  = getbits36_18 (buf[i], 18);
1079       int b0  = getbits36_9  (buf[i],  0);
1080       int b1  = getbits36_9  (buf[i],  9);
1081       int b2  = getbits36_9  (buf[i], 18);
1082       int b3  = getbits36_9  (buf[i], 27);
1083       if (i < MGP_PACKET_HEADER_SIZE)
1084         {
1085           sim_printf(" %d: %06o,,%06o = 0x%02x %02x %02x %02x\r\n",
1086                      i, lh, rh, b0, b1, b2, b3);
1087         }
1088       else
1089         {
1090           /* avoid printing NULs for the console output to work */
1091           char chars[128], *cp = chars;
1092           (void)memset(chars, 0, sizeof ( chars ));
1093           if (b0 && b0 < 0177 && b0 >= 040)
1094             {
1095               cp += sprintf(cp, "'%c' ",
1096                       b0);
1097             }
1098           else
1099             {
1100               cp += sprintf(cp, "'^%c' ",
1101                       b0 < 0100 ? b0 + 0100 : b0 - 0100);
1102             }
1103 
1104           if (b1 && b1 < 0177 && b1 >= 040)
1105             {
1106               cp += sprintf(cp, "'%c' ",
1107                       b1);
1108             }
1109           else
1110             {
1111               cp += sprintf(cp, "'^%c' ",
1112                       b1 < 0100 ? b1 + 0100 : b1 - 0100);
1113             }
1114 
1115           if (b2 && b2 < 0177 && b2 >= 040)
1116             {
1117               cp += sprintf(cp, "'%c' ",
1118                       b2);
1119             }
1120           else
1121             {
1122               cp += sprintf(cp, "'^%c' ",
1123                       b2 < 0100 ? b2 + 0100 : b2 - 0100);
1124             }
1125 
1126           if (b3 && b3 < 0177 && b3 >= 040)
1127             {
1128               cp += sprintf(cp, "'%c'",
1129                       b3);
1130             }
1131           else
1132             {
1133               cp += sprintf(cp, "'^%c'",
1134                       b3 < 0100 ? b3 + 0100 : b3 - 0100);
1135             }
1136 
1137           sim_printf(" %d: %06o,,%06o = 0x%02x %02x %02x %02x = %s\r\n",
1138                      i, lh, rh, b0, b1, b2, b3, chars);
1139         }
1140     }
1141 
1142   sim_printf("EOP\r\n"); /* although this helps */
1143 }
1144 
1145 // Pipe for sending conn index which needs to have a STATUS packet sent for
1146 static int status_conns[2];
1147 
1148 static void
1149 mgp_init_dev_state(void)
     /*  */
1150 {
1151   (void)memset(&mgp_dev_state, 0, sizeof ( mgp_dev_state ));
1152   // Start reading at the lowest index
1153   mgp_dev_state.read_index  = -1;
1154 
1155   status_conns[0] = status_conns[1] = 0;
1156   if (pipe(status_conns) < 0)
1157     {
1158       sim_printf("%s: error from pipe(): %s (%d)\r\n",
1159                  __func__, xstrerror_l(errno), errno);
1160     }
1161 
1162   // Init randomness
1163   uint32_t h = 0;  /* initial hash value */
1164 # if __STDC_VERSION__ < 201112L
1165   /* LINTED E_OLD_STYLE_FUNC_DECL */
1166   void *(*mallocptr)() = malloc;
1167   h = hash32s(&mallocptr, sizeof(mallocptr), h);
1168 # endif /* if __STDC_VERSION__ < 201112L */
1169   void *ptr = &ptr;
1170   h = hash32s(&ptr, sizeof(ptr), h);
1171   time_t t = time(0);
1172   h = hash32s(&t, sizeof(t), h);
1173 # if !defined(_AIX) && !defined(__managarm__)
1174   for (int i = 0; i < 1000; i++)
1175     {
1176       unsigned long counter = 0;
1177       clock_t start = clock();
1178       while (clock() == start)
1179         {
1180           counter++;
1181         }
1182       h = hash32s(&start, sizeof(start), h);
1183       h = hash32s(&counter, sizeof(counter), h);
1184     }
1185 # endif /* if !defined(_AIX) */
1186   int mypid = (int)_sir_getpid();
1187   h = hash32s(&mypid, sizeof(mypid), h);
1188   char rnd[4];
1189   FILE *f = fopen("/dev/urandom", "rb");
1190   if (f)
1191     {
1192       if (fread(rnd, sizeof(rnd), 1, f))
1193         {
1194           h = hash32s(rnd, sizeof(rnd), h);
1195         }
1196       fclose(f);
1197     }
1198   srandom(h);
1199 }
1200 
1201 static void
1202 mgp_wants_to_read(uint iom_unit_idx, uint chan)
     /*  */
1203 {
1204   mgp_dev_state.read_unit_idx  = iom_unit_idx;
1205   mgp_dev_state.read_unit_chan = chan;
1206   mgp_dev_state.want_to_read   = 1;
1207 }
1208 
1209 // Find the first conn which has a zero skt
1210 static int
1211 find_free_conn(void)
     /*  */
1212 {
1213   int i;
1214   for (i = 0; i < MAX_CONNS; i++)
1215     {
1216       if (mgp_dev_state.conns[i].skt == 0)
1217         {
1218           return i;
1219         }
1220     }
1221 
1222   return -1;
1223 }
1224 
1225 // Find the conn for <remote,local> id.
1226 // local may be 0 which matches all local ids.
1227 static int
1228 find_conn_for(int remote, int local)
     /*  */
1229 {
1230   int i;
1231   for (i = 0; i < MAX_CONNS; i++)
1232     {
1233       if ( ( mgp_dev_state.conns[i].multics_proc != 0 )
1234         && ( mgp_dev_state.conns[i].multics_proc == remote )
1235         && (( local == 0 ) || ( mgp_dev_state.conns[i].local_id == local )) )
1236         {
1237           return i;
1238         }
1239     }
1240 
1241   return -1;
1242 }
1243 
1244 // Return a malloc'd pkt with cbridge header filled in.
1245 static u_char *
1246 make_cbridge_pkt(int len, int opcode)
     /*  */
1247 {
1248   u_char *pkt = malloc(len + CBRIDGE_PACKET_HEADER_SIZE); /* space for cbridge header */
1249   if (pkt == NULL)
1250     {
1251       (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1252                      __func__, __FILE__, __LINE__);
1253 # if defined(USE_BACKTRACE)
1254 #  if defined(SIGUSR2)
1255       (void)raise(SIGUSR2);
1256       /*NOTREACHED*/ /* unreachable */
1257 #  endif /* if defined(SIGUSR2) */
1258 # endif /* if defined(USE_BACKTRACE) */
1259       abort();
1260     }
1261   (void)memset(pkt, 0, len + CBRIDGE_PACKET_HEADER_SIZE);
1262 
1263   pkt[0]  = opcode;
1264   pkt[2]  = len & 0xff;
1265   pkt[3]  = len >> 8;
1266 
1267   return pkt;
1268 }
1269 
1270 static u_char *
1271 make_rfc_pkt(int *len, char *host, char *contact, char *args)
     /*  */
1272 {
1273   /* cbridge header + strings with spaces + NUL */
1274   *len = strlen(host) + 1 + strlen(contact) + \
1275          ( args == NULL ? 0 : 1 + strlen(args) ) + 1;
1276 
1277   u_char *pkt = make_cbridge_pkt(*len, CHOP_RFC);
1278   (void)sprintf((char *)&pkt[CBRIDGE_PACKET_HEADER_SIZE],
1279                 "%s %s%s%s", host, contact,
1280                 args == NULL || *args == '\0' ? "" : " ",
1281                 args == NULL || *args == '\0' ? "" : args);
1282 
1283   return pkt;
1284 }
1285 
1286 // Open a packet socket to cbridge (done for each conn)
1287 int
1288 cbridge_open_socket(void)
     /*  */
1289 {
1290   int slen, sock;
1291   struct sockaddr_un server;
1292 
1293   if (( sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
1294     {
1295       // Check for "out of sockets" or similar?
1296       sim_printf("%s: socket(AF_UNIX) error: %s (%d)",
1297                  __func__, xstrerror_l(errno), errno); // @@@@ handle error better?
1298 
1299       return sock;
1300     }
1301 
1302   server.sun_family  = AF_UNIX;
1303   (void)sprintf(server.sun_path, "%s", CBRIDGE_PACKET_SOCKET);
1304   slen = strlen(server.sun_path) + 1 + sizeof ( server.sun_family );
1305 
1306   if (connect(sock, (struct sockaddr *)&server, slen) < 0)
1307     {
1308       sim_printf("%s: connect(%s) error: %s (%d)", __func__,
1309                  server.sun_path, xstrerror_l(errno), errno);
1310       // @@@@ let the device go down, instead
1311       close(sock);
1312       sock = 0;
1313     }
1314 
1315   return sock;
1316 }
1317 
1318 static void
1319 close_conn(int i)
     /*  */
1320 {
1321   if (i < 0)
1322     {
1323       sim_printf("%s: closing conn %d which is invalid!\r\n", __func__, i);
1324       return;
1325     }
1326   sim_printf("%s: closing conn %d <%#x,%#x>, remote %#o, contact \"%s\"\r\n",
1327              __func__, i,
1328              mgp_dev_state.conns[i].multics_proc, //-V557 /* XXX */
1329              mgp_dev_state.conns[i].local_id,
1330              mgp_dev_state.conns[i].remote_addr,
1331              mgp_dev_state.conns[i].contact_name);
1332 
1333   if (mgp_dev_state.conns[i].skt > 0)
1334     {
1335       close(mgp_dev_state.conns[i].skt);
1336     }
1337 
1338   mgp_dev_state.conns[i].multics_proc  = 0;
1339   mgp_dev_state.conns[i].local_id      = 0;
1340   if (mgp_dev_state.conns[i].contact_name != NULL)
1341     {
1342       FREE(mgp_dev_state.conns[i].contact_name);
1343     }
1344 
1345   mgp_dev_state.conns[i].contact_name  = NULL;
1346   mgp_dev_state.conns[i].remote_addr   = 0;
1347 }
1348 
1349 static int
1350 cbridge_send_packet(int i, u_char *pkt, int len)
     /*  */
1351 {
1352   int skt  = mgp_dev_state.conns[i].skt;
1353   int x    = write(skt, pkt, len);
1354   if (x < 0)
1355     {
1356       // @@@@ handle error, pass it on to Multics
1357       if (( errno == EBADF      )  \
1358        || ( errno == ECONNRESET )  \
1359        || ( errno == EPIPE      ))
1360         {
1361           sim_printf("%s: socket seems to have closed: %s\r\n",
1362                      __func__, xstrerror_l(errno));
1363           close_conn(i);
1364         }
1365       else
1366         {
1367           sim_warn("%s: socket write error: %s (%d)\r\n",
1368                    __func__, xstrerror_l(errno), errno);
1369         }
1370     }
1371   else if (x != len)
1372     {
1373       sim_printf("%s: wrote %d bytes (expected %d)\r\n", __func__, x, len);
1374     }
1375 
1376   FREE(pkt);
1377   return x;
1378 }
1379 
1380 // Handle packets from Multics, send them to cbridge
1381 static int
1382 handle_packet(int opcode, struct mgp_packet_header *p, word36 *buf,
     /*  */
1383               uint words)
1384 {
1385   int i = find_conn_for(p->source_process, p->destination_process);
1386   if (i < 0)
1387     {
1388       sim_warn("%s: can't find conn for %#x,%#x\r\n",
1389                __func__, p->source_process, p->destination_process);
1390       return -1;
1391     }
1392 
1393   u_char *pkt = make_cbridge_pkt(p->byte_count, opcode);
1394   if (p->byte_count > 0)
1395     {
1396       copy_packet9_to_cbridge8(
1397         buf, words, pkt + CBRIDGE_PACKET_HEADER_SIZE, p->byte_count);
1398     }
1399 
1400   return cbridge_send_packet(
1401                  i, pkt, CBRIDGE_PACKET_HEADER_SIZE + p->byte_count);
1402 }
1403 
1404 static int
1405 handle_close(struct mgp_packet_header *p, word36 *buf, uint words)
     /*  */
1406 {
1407   // Close the connection in a controlled way:
1408   // first send and EOF with payload "wait",
1409   // which makes cbridge send the EOF and wait (some time) for its
1410   // acknowledgement, and then send an ACK packet here. When the ACK arrives,
1411   // send the CLS. (No need to save a close message somewhere, since Multics
1412   // doesn't include any data.)
1413   word36 eof[1];
1414   copy_cbridge8_to_packet9((u_char *)"wait", 4, buf, 1);
1415 
1416   return handle_packet(CHOP_EOF, p, eof, 1);
1417 }
1418 
1419 static int
1420 handle_lose(int conni, struct mgp_packet_header *p, word36 *buf, uint words)
     /*  */
1421 {
1422   // send LOS, close socket, clear out our conn
1423   int v = handle_packet(CHOP_LOS, p, buf, words);
1424   // after sending a LOS, the connection is gone
1425   close_conn(conni);
1426 
1427   return v;
1428 }
1429 
1430 static int
1431 handle_connect(struct mgp_packet_header *p, word36 *buf, uint words)
     /*  */
1432 {
1433   char connect_string[256], *net, *host, *contact, *args;
1434   char *i;
1435   copy_packet9_to_cbridge8(buf,
1436     words, (u_char *)connect_string, sizeof ( connect_string ));
1437   sim_printf("%s: connect string is \"%s\"\r\n", __func__, connect_string);
1438   // Parse the connect string, something like "CHAOS 12234 NAME /W BV"
1439   net  = connect_string;
1440   i    = index(net, ' ');
1441   if (i == NULL)
1442     {
1443       sim_printf("%s: bad connect string: first space not found\r\n", __func__);
1444 
1445       return -1;
1446     }
1447 
1448   *i    = '\0';
1449   host  = i + 1;
1450   i     = index(host, ' ');
1451   if (i == NULL)
1452     {
1453       sim_printf("%s: bad connect string: second space not found\r\n", __func__);
1454 
1455       return -1;
1456     }
1457 
1458   *i       = '\0';
1459   contact  = i + 1;
1460   i        = index(contact, ' ');
1461   if (i == NULL)
1462     {
1463       sim_printf("%s: third space not found, no contact args\r\n", __func__);
1464       args = NULL;
1465     }
1466   else
1467     {
1468       *i    = '\0';
1469       args  = i + 1;
1470     }
1471 
1472   sim_printf("%s: parsed connect string: net \"%s\", host \"%s\", contact "
1473              "\"%s\", args \"%s\"\r\n", __func__, net, host, contact, args);
1474   if (strcasecmp(net, "CHAOS") != 0)
1475     {
1476       sim_printf("%s: not CHAOS net, ignoring\r\n", __func__);
1477 
1478       return -1;
1479     }
1480 
1481   // Now find a free slot in mgp_dev_state.conns,
1482   int cindex               = find_free_conn();
1483   if (cindex < 0)
1484     {
1485       sim_printf("%s: no free conns available!\r\n", __func__);
1486       return -1;
1487     }
1488   struct conn_table *conn  = &mgp_dev_state.conns[cindex];
1489   // save the contact name
1490   if (conn->contact_name) /* Free any old string */
1491     {
1492       FREE(conn->contact_name);
1493     }
1494 
1495   conn->contact_name = strdup(contact);
1496   // parse the host address and save it
1497   u_short raddr;
1498   if (( sscanf(host, "%ho", &raddr) != 1 ) || !valid_chaos_host_address(raddr))
1499     {
1500       sim_printf("%s: bad remote address %s\r\n", __func__, host);
1501 
1502       return -1;
1503     }
1504   else
1505     {
1506       conn->remote_addr = raddr;
1507     }
1508 
1509   // make a local id, fill in multics id,
1510   conn->local_id      = random() % ( 1 << 16 ); /* srandom() called in mgp_init_dev_state */
1511   conn->multics_proc  = p->source_process;
1512   // open a socket,
1513   int cbskt = cbridge_open_socket();
1514   if (cbskt < 0)
1515     {
1516       sim_printf("%s: unable to get a socket\r\n", __func__);
1517 
1518       return cbskt;
1519     }
1520 
1521   conn->skt = cbskt;
1522   // construct a cbridge packet,
1523   int cblen;
1524   u_char *cbpkt = make_rfc_pkt(&cblen, host, contact, args);
1525 
1526   // send the packet on it
1527   int v = cbridge_send_packet(cindex, cbpkt,
1528               CBRIDGE_PACKET_HEADER_SIZE + cblen);  /* incl header pls */
1529 
1530   if (v < 0)
1531     {
1532       // failed sending, close it again
1533       // @@@@ and pass on error to Multics
1534       close_conn(cindex);
1535 
1536       return -1;
1537     }
1538   else
1539     {
1540       int i = cindex;
1541       sim_printf(
1542            "%s: opened conn %d <%#x,%#x>, remote %#o, contact \"%s\"\r\n",
1543            __func__, i, mgp_dev_state.conns[i].multics_proc,
1544            mgp_dev_state.conns[i].local_id, mgp_dev_state.conns[i].remote_addr,
1545            mgp_dev_state.conns[i].contact_name);
1546 
1547       return cindex;
1548     }
1549 }
1550 
1551 // Given pkt read from Multics, act on it
1552 static int
1553 handle_mgp_packet(word36 *buf, uint words)
     /*  */
1554 {
1555   struct mgp_packet_header *p  = parse_packet_header(buf, words);
1556   int rval                     = 0;
1557 
1558   if (   ( p->checksum       == 0 ) \
1559       && ( p->packet_type    == 0 ) \
1560       && ( p->frame_number   == 0 ) \
1561       && ( p->receipt_number == 0 ) )
1562     {
1563       FREE(p);
1564       // Not a real packet, ignore
1565       return 0;
1566     }
1567 
1568   if (mgp_dev_state.first_frame_received
1569       && ( p->frame_number != ( mgp_dev_state.frame_last_received + 1 )))
1570     {
1571       sim_printf("%s: unordered frame %#x read, expected %#x\r\n", __func__,
1572                  p->frame_number, mgp_dev_state.frame_last_received + 1);
1573       // send NAK?
1574     }
1575   else
1576     {
1577       mgp_dev_state.first_frame_received = 1;
1578     }
1579 
1580   int i = find_conn_for(p->source_process, p->destination_process);
1581   sim_printf(
1582           "%s: packet %#x (ack %#x) for conn %d <%#x,%#x>, pktype %d (%s)\r\n",
1583           __func__, p->packet_number, p->ack_number, i,
1584           i < 0 ? 0 : mgp_dev_state.conns[i].multics_proc,
1585           i < 0 ? 0 : mgp_dev_state.conns[i].local_id,
1586           p->packet_type, pktype_name(p->packet_type));
1587 
1588   int pktype = p->packet_type;
1589   switch (pktype)
1590     {
1591     case pktype_NOOP:
1592       // NOOP seems to be nonspecific to conn, just conveying frame/receipt
1593       // (handled above/below)
1594       break;
1595 
1596     case pktype_CONNECT:
1597       rval = handle_connect(p, buf, words);
1598       break;
1599 
1600     case pktype_OPEN:
1601       // make it ANS or OPN, depending on opcode
1602       rval = handle_packet(
1603         p->chaos_opcode ? p->chaos_opcode : CHOP_OPN, p, buf, words);
1604       break;
1605 
1606     case pktype_CLOSE:
1607       rval = handle_close(p, buf, words);
1608       break;
1609 
1610     case pktype_LOSE:
1611       rval = handle_lose(i, p, buf, words);
1612       break;
1613 
1614     case pktype_DATA:
1615       // just convert to DAT and send (but watch out for EOF, check opcode)
1616       rval = handle_packet(
1617         p->chaos_opcode ? p->chaos_opcode : CHOP_DAT, p, buf, words);
1618       break;
1619 
1620     case pktype_SEND_STATUS:
1621       if (status_conns[1] > 0)
1622         {
1623           char b[2] = { i, 0 };
1624           sim_printf(
1625               "%s: asking for STATUS to be sent for conn %d on status_conns\r\n",
1626               __func__, i);
1627           if (write(status_conns[1], b, 1) < 0)
1628             {
1629               sim_printf(
1630                   "%s: write() on status_conns failed: %s (%d)\r\n",
1631                   __func__, xstrerror_l(errno), errno);
1632               status_conns[1] = status_conns[0] = 0;
1633             }
1634         }
1635 
1636       break;
1637 
1638     case pktype_STATUS:
1639       sim_printf("%s: STATUS for conn %d: frame,rcpt = <%#x,%#x>, pkt,ack = "
1640             "<%#x,%#x>\r\n", __func__, i, p->frame_number, p->receipt_number,
1641             p->packet_number, p->ack_number);
1642       break;
1643 
1644     default:
1645       sim_printf("%s: can't handle pkt type %#o (%s) yet\r\n",
1646                  __func__, pktype, pktype_name(pktype));
1647       rval = -1;
1648     }
1649 
1650   // Set a mark to make a NOOP being available for reading next.
1651     if (p->flags.reply_now)
1652       {
1653         sim_printf("%s: reply_NOW set, setting flag for sending NOOP\r\n",
1654                    __func__);
1655         mgp_dev_state.send_noop = 1;
1656 
1657 
1658 
1659 
1660 
1661 
1662 
1663 
1664 
1665 
1666 
1667 
1668 
1669 
1670 
1671 
1672 
1673 
1674 
1675 
1676 
1677 
1678 
1679 
1680 
1681 
1682       }
1683 
1684   // Count the frame
1685   mgp_dev_state.frame_last_received = p->frame_number;
1686   sim_printf("%s: afterwards, frame last sent %#x, last received %#x\r\n",
1687              __func__, mgp_dev_state.frame_last_sent,
1688              mgp_dev_state.frame_last_received);
1689   FREE(p);
1690 
1691   return rval;
1692 }
1693 
1694 // Handle packets from cbridge, give them to Multics.
1695 
1696 // Mapping from Chaos opcode to MGP packet type
1697 u_char opcode_to_pktype[] = {
1698   0,              /* None                    */
1699   pktype_CONNECT, /* RFC                     */
1700   pktype_OPEN,    /* OPN                     */
1701   pktype_CLOSE,   /* CLS                     */
1702   0,              /* FWD (not handled)       */
1703   pktype_OPEN,    /* ANS                     */
1704   0,              /* SNS (never appears)     */
1705   pktype_STATUS,  /* STS (internal use only) */
1706   0,              /* RUT (never appears)     */
1707   pktype_LOSE,    /* LOS                     */
1708   0,              /* LSN (never appears)     */
1709   0,              /* MNT (never appears)     */
1710   pktype_DATA,    /* EOF                     */
1711   0,              /* UNC (not handled)       */
1712   pktype_CONNECT  /* BRD                     */
1713 };
1714 
1715 static void
1716 make_mgp_header(struct mgp_packet_header *p, u_char opcode, u_char *pkt,
     /*  */
1717                 uint pklen, int i)
1718 {
1719   (void)memset(p, 0, sizeof ( struct mgp_packet_header ));
1720   p->identification = '#';
1721   if (( opcode > 0 ) && ( opcode <= CHOP_BRD ))
1722     {
1723       p->packet_type = opcode_to_pktype[opcode];
1724     }
1725   else if (opcode >= CHOP_DAT)
1726     {
1727       p->packet_type = pktype_DATA;
1728     }
1729   else if (i == -1) /* special case */
1730     {
1731       p->packet_type = pktype_NOOP;
1732     }
1733 
1734   /* no flags? */
1735   p->flags.reply_now  = 1;
1736   p->frame_number     = ++mgp_dev_state.frame_last_sent;
1737   p->receipt_number   = mgp_dev_state.frame_last_received;
1738   if (i >= 0)
1739     {
1740       // Never mind about these if it is a NOOP we're making
1741       p->packet_number        = ++mgp_dev_state.conns[i].pkt_last_sent; //-V557 /* XXX */
1742       p->ack_number           =   mgp_dev_state.conns[i].pkt_last_received;
1743       p->source_process       =   mgp_dev_state.conns[i].local_id;
1744       p->destination_process  =   mgp_dev_state.conns[i].multics_proc;
1745     }
1746 
1747   p->chaos_opcode  = opcode;
1748   p->byte_count    = pklen;
1749   sim_printf(
1750         "%s: made %s (%d) f,r=<%#x,%#x> p,a=<%#x,%#x> opc %s (%d) bc %d\r\n",
1751         __func__, pktype_name(p->packet_type), p->packet_type, p->frame_number,
1752         p->receipt_number, p->packet_number, p->ack_number,
1753         chop_name(p->chaos_opcode), p->chaos_opcode, p->byte_count);
1754 }
1755 
1756 static int
1757 make_mgp_packet(u_char opcode, u_char *pkt, uint pklen, word36 *buf,
     /*  */
1758                 uint words, uint conni)
1759 {
1760   struct mgp_packet_header hdr;
1761 
1762   // Make an mgp header
1763   make_mgp_header(&hdr, opcode, pkt, pklen, conni);
1764 
1765   // fill in the checksum (which is computed on the 8-bit bytes!)
1766   hdr.checksum = mgp_checksum(&hdr, pkt, pklen);
1767 
1768   // fill in the header in the buffer
1769   unparse_packet_header(&hdr, buf, words);
1770 
1771   // copy the data part, converting from 8-bit to 9-bit
1772   copy_cbridge8_to_packet9(pkt, pklen, buf, words);
1773   sim_printf("%s: conn %d <%#x,%#x> made %s pkt %#x (ack %#x), frame %#x "
1774       "(rcpt %#x)\r\n", __func__, conni, mgp_dev_state.conns[conni].local_id,
1775       mgp_dev_state.conns[conni].multics_proc, pktype_name(hdr.packet_type),
1776       hdr.packet_number, hdr.ack_number, hdr.frame_number, hdr.receipt_number);
1777 
1778   return 0;
1779 }
1780 
1781 static int
1782 make_status_packet(int conni, word36 *buf, uint words)
     /*  */
1783 {
1784   struct mgp_packet_header hdr;
1785 
1786   // Make an mgp header - reuse CHOP_STS which doesn't appear otherwise
1787   make_mgp_header(&hdr, CHOP_STS, NULL, 0, conni);
1788 
1789   // fill in the checksum (which is computed on the 8-bit bytes!)
1790   hdr.checksum = mgp_checksum(&hdr, NULL, 0);
1791 
1792   // fill in the header in the buffer
1793   unparse_packet_header(&hdr, buf, words);
1794 
1795   // (no data to copy)
1796   sim_printf("%s: conn %d <%#x,%#x> made %s pkt %#x (ack %#x), frame %#x "
1797       "(rcpt %#x)\r\n", __func__, conni, mgp_dev_state.conns[conni].local_id,
1798       mgp_dev_state.conns[conni].multics_proc, pktype_name(hdr.packet_type),
1799       hdr.packet_number, hdr.ack_number, hdr.frame_number, hdr.receipt_number);
1800 
1801   return 0;
1802 }
1803 
1804 static int
1805 make_noop_packet(word36 *buf, uint words)
     /*  */
1806 {
1807   struct mgp_packet_header hdr;
1808 
1809   // Make an mgp header
1810   make_mgp_header(&hdr, 0, NULL, 0, -1);
1811   hdr.packet_number  = 1;
1812 
1813   // fill in the checksum
1814   hdr.checksum       = mgp_checksum(&hdr, NULL, 0);
1815 
1816   // fill in the header in the buffer
1817   unparse_packet_header(&hdr, buf, words);
1818 
1819   // (no data to copy)
1820   sim_printf("%s: made NOOP pkt %#x (ack %#x), frame %#x (rcpt %#x)\r\n",
1821              __func__, hdr.packet_number, hdr.ack_number, hdr.frame_number,
1822              hdr.receipt_number);
1823 
1824   return 0;
1825 }
1826 
1827 static int
1828 make_open_packet(u_char opcode, u_char *pkt, uint pklen, word36 *buf,
     /*  */
1829                  uint words, uint conni)
1830 {
1831   if (opcode == CHOP_OPN)
1832     {
1833       // Skip content of OPN packets, which is
1834       // the ascii host name (or octal address)
1835       return make_mgp_packet(opcode, pkt, 0, buf, words, conni);
1836     }
1837   else if (opcode == CHOP_ANS)
1838     {
1839       // First two bytes is the source (useful e.g. if we sent a broadcast)
1840       u_short src = pkt[0] | ( pkt[1] << 8 );
1841       if (src != mgp_dev_state.conns[conni].remote_addr)
1842         {
1843           sim_printf("%s: got ANS from %#o but had remote addr %#o\r\n",
1844                      __func__, src, mgp_dev_state.conns[conni].remote_addr);
1845                      mgp_dev_state.conns[conni].remote_addr = src;
1846         }
1847 
1848       // Skip the two source bytes in the mgp packet
1849       return make_mgp_packet(opcode, pkt + 2, pklen - 2, buf, words, conni);
1850     }
1851   else
1852     {
1853       sim_warn("%s: BUG: opcode is not ANS or OPN: %s (%#o)\r\n",
1854                __func__, chop_name(opcode), opcode);
1855 
1856       return -1;
1857     }
1858 }
1859 
1860 static int
1861 make_connect_packet(u_char *pkt, uint pklen, word36 *buf, uint words,
     /*  */
1862                     uint conni)
1863 {
1864   // An RFC cbridge pkt is almost like a mgp connect pkt
1865   char *i, *rhost, *args = NULL, connect[128];
1866   rhost = (char *)pkt;
1867   // Zap any line ending
1868   if (( i = index(rhost, '\r')) != NULL)
1869     {
1870       *i = '\0';
1871     }
1872   else if (( i = index(rhost, '\n')) != NULL)
1873     {
1874       *i = '\0';
1875     }
1876 
1877   // Find any contact args
1878   if (( i = index(rhost, ' ')) != NULL)
1879     {
1880       args  = i + 1;
1881       *i    = '\0';
1882     }
1883 
1884   // @@@@ beware: I think Multics wants the name of the remote host,
1885   // @@@@ not the address.
1886   // @@@@ But it should handle the address, I think/hope?
1887   // @@@@ Make sure contact_name is set up also when listening
1888   // @@@@ - this is future work.
1889 
1890   // Prefix with the "net", add contact name, and args
1891   if ( ( mgp_dev_state.conns[conni].contact_name == NULL )
1892    || ( *mgp_dev_state.conns[conni].contact_name == '\0' ))
1893     {
1894       sim_printf("%s: no contact name known for conn %d\r\n", __func__, conni);
1895 
1896       return -1;
1897     }
1898 
1899   (void)sprintf(connect, "CHAOS %s %s%s%s",
1900                 rhost, mgp_dev_state.conns[conni].contact_name,
1901                 args == NULL ? "" : " ", args == NULL ? "" : args);
1902 
1903   return make_mgp_packet(CHOP_RFC,
1904     (u_char *)connect, strlen(connect), buf, words, conni);
1905 }
1906 
1907 static int
1908 receive_cbridge_opcode(u_char copcode, u_char *cbuf, uint clen, word36 *buf,
     /*  */
1909                        uint words, int conni)
1910 {
1911   sim_printf("%s: got opcode %#o (%s)\r\n",
1912              __func__, copcode, chop_name(copcode));
1913   switch (copcode)
1914     {
1915     case CHOP_FWD:
1916     // These should never be seen:
1917     case CHOP_RUT:
1918     case CHOP_MNT:
1919     case CHOP_UNC:
1920     case CHOP_STS:
1921     case CHOP_SNS:
1922     // Do nothing.
1923       return -1;
1924 
1925     case CHOP_RFC: /* this can originally be a BRD, too */
1926       // format is similar, but not same
1927       return make_connect_packet(cbuf, clen, buf, words, conni);
1928 
1929     case CHOP_OPN:
1930     case CHOP_ANS:
1931       return make_open_packet(copcode, cbuf, clen, buf, words, conni);
1932 
1933     case CHOP_ACK:
1934     {
1935       // This is the ACK of an EOF[wait] (see handle_close),
1936       // so now it is time to send a CLS
1937       u_char *clspkt = make_cbridge_pkt(0, CHOP_CLS);
1938       cbridge_send_packet(conni, clspkt, 0);
1939       // After sending a CLS, the connection can be discarded (cf MIT AIM 628)
1940       close_conn(conni);
1941     }
1942     break;
1943 
1944     case CHOP_CLS:
1945     case CHOP_LOS:
1946     {
1947       // Pass it on to Multics
1948       int v = make_mgp_packet(copcode, cbuf, clen, buf, words, conni);
1949       // and then discard the connection
1950       close_conn(conni);
1951 
1952       return v;
1953     }
1954 
1955     default:
1956       // Most pkts have the same content
1957       return make_mgp_packet(copcode, cbuf, clen, buf, words, conni);
1958     }
1959 
1960   return 1;
1961 }
1962 
1963 // Read result into buf, return the number of bytes/words put there or -1.
1964 static int
1965 poll_from_cbridge(word36 *buf, uint words, uint probe_only)
     /*  */
1966 {
1967   fd_set rfd;
1968   int maxfd, numfds, i, sval, cnt, rval = -1;
1969   int foundone = 0, tryagain = 0;
1970   u_char cbuf[CH_PK_MAX_DATALEN + CBRIDGE_PACKET_HEADER_SIZE]; /* Fit data + cbridge header */
1971 
1972   maxfd   = 0;
1973   numfds  = 0;
1974   // Add the status pipe to the fd set
1975   FD_ZERO(&rfd);
1976   if (status_conns[0] != 0)
1977     {
1978       FD_SET(status_conns[0], &rfd);
1979       maxfd = status_conns[0];
1980       numfds++;
1981     }
1982 
1983   // Add all existing conns
1984   for (i = 0; i < MAX_CONNS; i++)
1985     {
1986       if (mgp_dev_state.conns[i].skt != 0)
1987         {
1988           FD_SET(mgp_dev_state.conns[i].skt, &rfd);
1989           numfds++;
1990           if (mgp_dev_state.conns[i].skt > maxfd)
1991             {
1992               maxfd = mgp_dev_state.conns[i].skt;
1993             }
1994         }
1995     }
1996 
1997   if (maxfd > 0)
1998     {
1999       struct timeval timeout;
2000       do
2001         {
2002           tryagain         = 0;
2003           // set a very short timeout (e.g. 0.01ms)
2004           timeout.tv_sec   = 0;
2005           timeout.tv_usec  = 10;
2006           sval             = select(maxfd + 1, &rfd, NULL, NULL, &timeout);
2007           if (probe_only)
2008             {
2009               if ((sval < 0) && (errno == EINTR))
2010                 {
2011                   return 0; /* Timeout, nothing to read */
2012                 }
2013               else
2014                 {
2015                   return sval;
2016                 }
2017             }
2018 
2019           if (sval < 0)
2020             {
2021               if (errno == EINTR)
2022                 {
2023                   // timed out
2024                 }
2025               else
2026                 {
2027                   sim_printf(
2028                        "%s: select() error, maxfd %d, numfds %d: %s (%d)\r\n",
2029                        __func__, maxfd, numfds, xstrerror_l(errno), errno);
2030                 }
2031 
2032               return -1;
2033             }
2034           else if (sval > 0)
2035             {
2036               int statusconn = -1;
2037 
2038               // First see if a STATUS should be sent
2039               if (( status_conns[0] != 0 ) && FD_ISSET(status_conns[0], &rfd))
2040                 {
2041                   char b[2];
2042                   sim_printf(
2043                        "%s: about to read a byte from status_conns[0] = %d\r\n",
2044                        __func__, status_conns[0]);
2045                   int s = read(status_conns[0], b, 1);
2046                   if (s < 0)
2047                     {
2048                       sim_warn("%s: read on status_conns failed: %s (%d)\r\n",
2049                                __func__, xstrerror_l(errno), errno);
2050                       status_conns[0] = status_conns[1] = 0;
2051                     }
2052                   else if (s == 0)
2053                     {
2054                       sim_printf("%s: read on status_conns returned 0\r\n",
2055                                  __func__);
2056                       status_conns[0] = status_conns[1] = 0;
2057                     }
2058                   else
2059                     {
2060                       sim_printf(
2061                          "%s: read %d from status_conns, make STATUS packet\r\n",
2062                          __func__, b[0]);
2063                       // make a STATUS packet
2064                       statusconn = b[0];
2065                     }
2066                 }
2067 
2068               // Start at the one after the previously read index, to make it
2069               // round-robin-like
2070               for (i = mgp_dev_state.read_index + 1; i < MAX_CONNS; i++)
2071                 {
2072                   if (FD_ISSET(mgp_dev_state.conns[i].skt, &rfd))
2073                     {
2074                       mgp_dev_state.read_index = i;
2075                       // read the header first, then that many bytes
2076                       if (( cnt = read(mgp_dev_state.conns[i].skt,
2077                               cbuf, CBRIDGE_PACKET_HEADER_SIZE)) < 0)
2078                         {
2079                           // @@@@ handle error, socket closed, pass on to Multics
2080                           sim_printf(
2081                               "%s: read() header error for conn %d: %s (%d)\r\n",
2082                               __func__, i, xstrerror_l(errno), errno);
2083                           FD_CLR(mgp_dev_state.conns[i].skt, &rfd);
2084                           numfds--;
2085                           close_conn(i);
2086                           foundone = 0;
2087                           continue;
2088                         }
2089                       else if (cnt == 0)
2090                         {
2091                           sim_printf(
2092                               "%s: read() header zero length conn %d, assuming closed\r\n",
2093                               __func__, i);
2094                           FD_CLR(mgp_dev_state.conns[i].skt, &rfd);
2095                           numfds--;
2096                           close_conn(i);
2097                           foundone = 0;
2098                           continue;
2099                         }
2100                       else if (cnt != CBRIDGE_PACKET_HEADER_SIZE)
2101                         {
2102                           sim_printf(
2103                                 "%s: read() header length %d for conn %d\r\n",
2104                                 __func__, cnt, i);
2105                           foundone = 0;
2106                           continue;
2107                         }
2108 
2109                       // Parse the cbridge packet header
2110                       int copcode  = cbuf[0];
2111                       int mbz      = cbuf[1];
2112                       int clen     = cbuf[2] | ( cbuf[3] << 8 );
2113                       sim_printf(
2114                         "%s: read cbridge pkt: opcode %#o (%s), mbz %d, len %d\r\n",
2115                         __func__, copcode, chop_name(copcode), mbz, clen);
2116                       if (( mbz != 0 ) || (( copcode > CHOP_BRD )  \
2117                                   && ( copcode < CHOP_ACK ))       \
2118                                   || ( clen > CH_PK_MAX_DATALEN ))
2119                         {
2120                           sim_printf(
2121                             "%s: cbridge header bad: opcode %#o (%s), mbz %d, len %d\r\n",
2122                             __func__, copcode, chop_name(copcode), mbz, clen);
2123                           FD_CLR(mgp_dev_state.conns[i].skt, &rfd);
2124                           numfds--;
2125                           close_conn(i);
2126                           foundone  = 0;
2127                           rval      = -1;
2128                           break;
2129                         }
2130                       else if (( cnt = read(mgp_dev_state.conns[i].skt, cbuf, clen)) < 0)
2131                         {
2132                           // @@@@ handle error, socket closed, pass on to Multics
2133                           sim_printf(
2134                                "%s: read() body error for conn %d: %s (%d)\r\n",
2135                                __func__, i, xstrerror_l(errno), errno);
2136                           FD_CLR(mgp_dev_state.conns[i].skt, &rfd);
2137                           numfds--;
2138                           close_conn(i);
2139                           foundone = 0;
2140                           continue;
2141                         }
2142                       else if (cnt != clen)
2143                         {
2144                           sim_printf(
2145                             "%s: read() body read %d (expected %d) for conn %d\r\n",
2146                             __func__, cnt, clen, i);
2147                           foundone = 0;
2148                           continue;
2149                         }
2150                       else
2151                         {
2152                           foundone = 1;
2153                           if (i == statusconn) /* No need for STATUS if we're
2154                                                 * making some other pkt */
2155                             {
2156                               statusconn = -1;
2157                             }
2158 
2159                           // Handle based on chaos opcode, and return
2160                           rval = receive_cbridge_opcode(
2161                             copcode, cbuf, clen, buf, words, i);
2162                           break;
2163                         }
2164                     }
2165                 }
2166 
2167               if (statusconn >= 0)
2168                 {
2169                   sim_printf("%s: making STATUS packet for conn %d\r\n",
2170                              __func__, statusconn);
2171                   make_status_packet(statusconn, buf, words);
2172                   foundone  = 1;
2173                   rval      = 1;
2174                 }
2175             }
2176           else
2177             {
2178               // sim_printf("%s: select() returned 0 (maxfd %d)\r\n",
2179               //   __func__, maxfd);
2180               rval = -1;
2181             }
2182 
2183           // If none found, start again at the lowest index
2184           if (!foundone && ( mgp_dev_state.read_index > -1 ))
2185             {
2186               sim_printf(
2187                   "%s: nothing to read at indices over %d, retrying select\r\n",
2188                   __func__, mgp_dev_state.read_index);
2189               mgp_dev_state.read_index  = -1;
2190               tryagain                  =  1;
2191             }
2192         }
2193       while (tryagain);
2194     }
2195 
2196   // If we didn't already send something, make a NOOP
2197   if (mgp_dev_state.send_noop)
2198     {
2199       sim_printf("%s: asked to send a NOOP - current frame %#x receipt %#x\r\n",
2200                  __func__, mgp_dev_state.frame_last_sent,
2201                  mgp_dev_state.frame_last_received);
2202       mgp_dev_state.send_noop = 0;
2203       if (!foundone)
2204         { // Only do it if we didn't already send something
2205           make_noop_packet(buf, words);
2206           rval = 1;
2207         }
2208       else
2209         {
2210           sim_printf("%s: already made a packet, skipping NOOP\r\n", __func__);
2211         }
2212     }
2213 
2214   return rval;
2215 }
2216 
2217 #endif /* if defined(WITH_MGP_DEV) */
/* */
root/src/dps8/dps8_mgp.c

DEFINITIONS
