src/dps8/fnpuv.c

/* */
This source file includes following definitions.
tun_alloc
alloc_buffer
fnpuv_associated_brk
fnpuv_associated_readcb
fnpuv_3270_readcb
fnpuv_unassociated_readcb
fuv_close_cb
close_connection
fuv_read_cb
fuv_write_cb
fuv_write_3270_cb
fnpuv_start_write_3270_actual
fnpuv_start_write_actual
fnpuv_start_write
fnpuv_start_3270_write
fnpuv_start_writestr
fnpuv_send_eor
fnpuv_recv_eor
fnpuv_read_start
fnpuv_read_stop
on_new_connection
fnpuvInit
fnpuvProcessEvent
on_dialout_connect
fnpuv_dial_out
fnpuv_open_slave
processPacketInput
fnoTUNProcessLine
fnpTUNProcessEvent
fnpuv3270Poll
on_new_3270_connection
fnpuv3270Init
   1 /*
   2  * vim: filetype=c:tabstop=4:ai:expandtab
   3  * SPDX-License-Identifier: ICU
   4  * scspell-id: 2fdee814-f62f-11ec-8f3d-80ee73e9b8e7
   5  *
   6  * ---------------------------------------------------------------------------
   7  *
   8  * Copyright (c) 2016 Charles Anthony
   9  * Copyright (c) 2016 Michal Tomek
  10  * Copyright (c) 2021-2025 The DPS8M Development Team
  11  *
  12  * This software is made available under the terms of the ICU License.
  13  * See the LICENSE.md file at the top-level directory of this distribution.
  14  *
  15  * ---------------------------------------------------------------------------
  16  */
  17 
  18 //-V::595
  19 
  20 // The FNP <--> libuv interface
  21 //
  22 // Every libuv TCP connection has a uv_tcp_t object.
  23 //
  24 // The uv_tcp_t object has a 'user data' field defined as "void * data".
  25 //
  26 // This code stores a pointer to a "struct uvClientData" in 'data'; this
  27 // structure allows this code to determine which HSLA line the connection
  28 // has been made with.
  29 //
  30 // The uvClientData structure contains:
  31 //
  32 //    bool assoc
  33 //    uint fnpno;
  34 //    uint lineno;
  35 //
  36 //       If 'assoc' is true, the TCP connection is associated with a particular
  37 //       HSLA line as specified by 'fnpno' and 'lineno'. A dialup line is
  38 //       associated by the user entering the FNP name and line number in the
  39 //       multiplexor dial in dialog. For slave and dialout lines, 'assoc'
  40 //       is always true as the association is predetermined by the FNP
  41 //       configuration.
  42 //
  43 //    char buffer [1024];
  44 //    size_t nPos;
  45 //
  46 //      Line canonicalization buffer used by the multiplexor dial in dialog.
  47 //
  48 // Each HSLA line is identified by a 'fnpno', 'lineno' pair. 'fnpno' indexes
  49 // into the 'fnpUnitData' data structure and 'lineno' into
  50 // 'fnpUnitData[fnpno].MState.line[]'.
  51 //
  52 // The 'line' structure contains:
  53 //
  54 //   enum service_types service;
  55 //
  56 //     This tracks the Multics' line configuration of 'dialup', 'dialout', and
  57 //     'slave'.
  58 //
  59 //   uv_tcp_t * client;
  60 //
  61 //     If this is non-null, the HSLA has a TCP connection.
  62 //
  63 //   telnet_t * telnetp;
  64 //
  65 //     If this is non-null, Telnet is enabled on the connection.
  66 //
  67 //   uv_tcp_t server;
  68 //
  69 //     This is used by the 'slave' logic and holds the handle of the
  70 //     TCP server port for the slave line.
  71 //
  72 //     The data field of 'server' points to a uvClientData structure; this
  73 //     field is used by the incoming connection handler to distinguish the
  74 //     slave and dialup server ports. (If null, dialup; else slave.)
  75 //
  76 //   uv_connect_t doConnect;
  77 //
  78 //     libuv uses a uv_connect_t object to create outbound connections;
  79 //     the dialout code uses 'doConnect' for this.
  80 //
  81 //   int port;
  82 //
  83 //     The port number that a slave line listens on.
  84 //
  85 
  86 // Dialup logic.
  87 //
  88 // The code assumes a single port number for all dialup lines, even for the
  89 // case of multiple FNPs.
  90 //
  91 // 'fnpuvInit()' is called when by the 'fnpserverport' command logic. It
  92 // creates a TCP server listen port, assigning 'on_new_connection()' as
  93 // the connection callback handler.
  94 //
  95 // When a connection is made to the listen port, libuv invokes the
  96 // 'on_new_connection()' callback handler.
  97 //
  98 // The handler creates a 'uv_tcp_t' object 'client' and accepts the
  99 // connection.
 100 //
 101 // It then checks the 'data' field on the listener object to see if this
 102 // is a dialup or slave listener. For the case of dialup, a 'uvClientData'
 103 // object is created and its 'assoc' field is set to false to flag the
 104 // the connection as not yet being associated with an HSLA line; the
 105 // libtelnet data structure is initialized and the initial Telnet negotiations
 106 // are started. 'client->data' is set to the 'uvClientData' object,
 107 // reading is enabled on 'client', and the HSLA line selection dialog
 108 // prompt is sent down the dialup connection.
 109 //
 110 // When input data is ready on the connection (user input), libuv allocates
 111 // a buffer, fills it with the data calls the 'fuv_read_cb()' callback handler.
 112 //
 113 // The handler looks at the 'data' field of the connection to access the
 114 // 'uvClientData' structure; if the structure indicates that Telnet
 115 // processing is to be done, it passes the data to libtelent handler.
 116 // Otherwise, it checks the 'assoc' field; if true the data is passed to the
 117 // FNP incoming data handler; if false, to the multiplexor line selection
 118 // dialog handler. The libtelnet handler, after stripping and processing
 119 // Telnet overhead passes any remaining data on in the same manner.
 120 // The data buffer is then freed, and the callback returns.
 121 //
 122 // Since the FNP incoming data handler is dependent on Multics accepting
 123 // the input data before it can safely dispose of the data, it disables
 124 // reading on the connection, and reenables it when Multics has accepted the
 125 // data.
 126 
 127 // Data are written to the TCP connections with 'fnpuv_start_write()'. The
 128 // 'uvClientData' is inspected for telnet usage; if so, the data is passed
 129 // to libtelnet for telnet packaging and is sent on to
 130 // 'fnpuv_start_write_actual'. If telnet is not in play, the data is sent
 131 // directly on to 'fnpuv_start_write_actual()' There, a buffer is allocated
 132 // and the data copied and a 'uv_write_t' request object is created and
 133 // initialized data the buffer address and length, and a write request
 134 // is send to libuv.
 135 //
 136 // When the write is complete, libuv calls the write callback 'fuv_write_cb()',
 137 // which frees the data buffers and destroys the write request object.
 138 
 139 // Dialout logic
 140 //
 141 // When the FNP receives a 'dial_out' command, it calls 'fnpuv_dial_out()'.
 142 // The dial string is parsed for IP address, port number and telnet flag.
 143 // An 'uv_tcp_t' object constructed and its address stored in the HSLA
 144 // 'client' field. An 'uvClientData' object is created, associated with
 145 // the dialout line HSLA, and if the Telnet flag is set, the Telnet processor
 146 // is initialized. The TCP connect is initiated and the procedure returns.
 147 //
 148 // When the connection succeeds or times out, the 'on_dialout_connect()' callback
 149 // is called. on_dialout_connect retrieves the 'uvClientData'. If the connection
 150 // succeeded, the connection data field is set to the 'uvClientData'; read is
 151 // enabled on the connection, and the 'accept_new_terminal' flag is set which
 152 // will cause an 'accept_new_terminal' command to be send to Multics.
 153 //
 154 
 155 #if defined(TUN)
 156 // TUN interface
 157 
 158 // If makes more sense to me to have the emulator on an endpoint, but
 159 // that's not really the way ethernet works; for the nonce, we will
 160 // create a subnet and route to it with a tun device; the emulator
 161 // will listen on the device and do the whole ARP rigamorole.
 162 //
 163 // It's not clear to me what happens if multiple emulators are listening
 164 // on the same tun device, do they each get a copy of the message (i.e.
 165 // are we wired as point-to-point)?
 166 //
 167 // Create device node:
 168 //   mkdir /dev/net (if it doesn't exist already)
 169 //   mknod /dev/net/tun c 10 200
 170 //   chmod 0666 /dev/net/tun
 171 //   modprobe tun
 172 //
 173 // The subnet gateway device is 'dps8m' at address 192.168.8.0
 174 //
 175 //   sudo ip tuntap add mode tun dps8m
 176 //   sudo ip link set dps8m up
 177 //   sudo ip addr add 192.168.8.1/24 dev dps8m
 178 #endif /* if defined(TUN) */
 179 
 180 #define ASSUME0 0
 181 
 182 #include <stdio.h>
 183 #include <stdlib.h>
 184 #include <unistd.h>
 185 #include <ctype.h>
 186 #include <signal.h>
 187 #if defined(TUN)
 188 # include <string.h>
 189 # include <fcntl.h>
 190 # include <errno.h>
 191 # include <sys/ioctl.h>
 192 # include <sys/types.h>
 193 # include <sys/stat.h>
 194 # include <netinet/in.h>
 195 # include <sys/socket.h>
 196 # include <linux/if.h>
 197 # include <linux/if_tun.h>
 198 #endif /* if defined(TUN) */
 199 
 200 #include "dps8.h"
 201 #include "dps8_sys.h"
 202 #include "dps8_iom.h"
 203 #include "dps8_cable.h"
 204 #include "dps8_cpu.h"
 205 #include "dps8_scu.h"
 206 #include "dps8_fnp2.h"
 207 #include "dps8_utils.h"
 208 #include "fnpuv.h"
 209 #include "fnptelnet.h"
 210 
 211 #if defined(NO_LOCALE)
 212 # define xstrerror_l strerror
 213 #endif
 214 
 215 #if defined(FREE)
 216 # undef FREE
 217 #endif /* if defined(FREE) */
 218 #define FREE(p) do  \
 219   {                 \
 220     free((p));      \
 221     (p) = NULL;     \
 222   } while(0)
 223 
 224 #define USE_REQ_DATA
 225 
 226 // Making it up...
 227 #define DEFAULT_BACKLOG 1024
 228 
 229 #if defined(TUN)
 230 static int tun_alloc (char * dev)
     /*  */
 231   {
 232     struct ifreq ifr;
 233     int fd, err;
 234 
 235     if ((fd = open ("/dev/net/tun", O_RDWR)) < 0)
 236       //return tun_alloc_old (dev);
 237       return fd;
 238 
 239     (void)memset (& ifr, 0,  sizeof (ifr));
 240 
 241     /*
 242      *  Flags: IFF_TUN   - TUN device (no Ethernet headers)
 243      *        IFF_TAP   - TAP device
 244      *
 245      *        IFF_NO_PI - Do not provide packet information
 246      */
 247 
 248     ifr.ifr_flags = IFF_TUN;
 249     if (* dev)
 250       strncpy (ifr.ifr_name, dev, IFNAMSIZ);
 251 
 252     if ((err = ioctl (fd, TUNSETIFF, (void *) & ifr)) < 0)
 253       {
 254         close (fd);
 255         return err;
 256       }
 257     strcpy (dev, ifr.ifr_name);
 258     return fd;
 259   }
 260 #endif /* if defined(TUN) */
 261 
 262 //
 263 // alloc_buffer: libuv callback handler to allocate buffers for incoming data.
 264 //
 265 
 266 static void alloc_buffer (UNUSED uv_handle_t * handle, size_t suggested_size,
     /*  */
 267                           uv_buf_t * buf)
 268  {
 269 /* Suppress Clang Analyzer's possible memory leak warning */
 270 #if !defined(__clang_analyzer__)
 271     * buf = uv_buf_init ((char *) malloc (suggested_size), (uint) suggested_size);
 272 #endif /* if !defined(__clang_analyzer__) */
 273   }
 274 
 275 void fnpuv_associated_brk (uv_tcp_t * client)
     /*  */
 276   {
 277     if (! client || uv_is_closing ((uv_handle_t *) client))
 278       return;
 279     if (! client->data)
 280       {
 281         sim_warn ("fnpuv_associated_brk bad client data\r\n");
 282         return;
 283       }
 284     uvClientData * p = (uvClientData *) client->data;
 285     uint fnpno = p -> fnpno;
 286     uint lineno = p -> lineno;
 287     struct t_line * linep = & fnpData.fnpUnitData[fnpno].MState.line[lineno];
 288     // The break key forces an input buffer flush.
 289     // XXX is this a race condition? Is it possible for processFnpMbx to see
 290     // the line_break before the accept input?
 291     linep->accept_input = 1;
 292     linep->line_break=true;
 293   }
 294 
 295 // read callback for connections that are associated with an HSLA line;
 296 // forward the data to the FNP input handler
 297 
 298 void fnpuv_associated_readcb (uv_tcp_t * client,
     /*  */
 299                            ssize_t nread,
 300                            unsigned char * buf)
 301   {
 302     processLineInput (client, buf, nread);
 303   }
 304 
 305 void fnpuv_3270_readcb (uv_tcp_t * client,
     /*  */
 306                            ssize_t nread,
 307                            unsigned char * buf)
 308   {
 309     process3270Input (client, buf, nread);
 310   }
 311 
 312 // read callback for connections that are no associated with an HSLA line;
 313 // forward the data to the line selection dialog handler
 314 
 315 void fnpuv_unassociated_readcb (uv_tcp_t * client,
     /*  */
 316                            ssize_t nread,
 317                            unsigned char * buf)
 318   {
 319     //(void)printf ("unassoc. <%*s>\r\n", (int) nread, buf->base);
 320     processUserInput (client, buf, nread);
 321   }
 322 
 323 static void fuv_close_cb (uv_handle_t * stream)
     /*  */
 324   {
 325     FREE (stream);
 326   }
 327 
 328 // teardown a connection
 329 
 330 void close_connection (uv_stream_t* stream)
     /*  */
 331   {
 332     if (! stream)
 333       {
 334         sim_warn ("close_connection bad client data\r\n");
 335         return;
 336       }
 337     uvClientData * p = (uvClientData *) stream->data;
 338 
 339     // If stream->data, the stream is associated with a Multics line.
 340     // Tear down that association
 341     //if (p && fnpData.fnpUnitData[p->fnpno].MState.line[p->lineno].service != service_3270)
 342     if (p)
 343       {
 344         // If assoc is false, then the disconnect happened before the actual
 345         // association took place
 346         if (p->assoc)
 347           {
 348             struct t_line * linep = & fnpData.fnpUnitData[p->fnpno].MState.line[p->lineno];
 349             if (linep->service  == service_3270)
 350              {
 351                // On the 3270, the station closing does not close the controller
 352                sim_printf ("\r[FNP emulation: TN3270 %d.%d DISCONNECT]\r\n", ASSUME0, p->stationNo);
 353              }
 354             else
 355               {
 356                 sim_printf ("\r[FNP emulation: DISCONNECT %c.d%03d]\r\n", p->fnpno+'a', p->lineno);
 357 #if defined(DISC_DELAY)
 358                 linep -> line_disconnected = DISC_DELAY;
 359 #else
 360                 linep -> line_disconnected = true;
 361 #endif /* if defined(DISC_DELAY) */
 362                 linep -> listen = false;
 363                 if (linep->inBuffer)
 364                   FREE (linep->inBuffer);
 365                 linep->inBuffer = NULL;
 366                 linep->inSize   = 0;
 367                 linep->inUsed   = 0;
 368                 linep->nPos     = 0;
 369               }
 370             if (linep->line_client)
 371               {
 372                 // linep->line_client is a copied stream->data; will be freed
 373                 // below
 374                 linep->line_client = NULL;
 375               }
 376           }
 377         else // ! p-assoc
 378           {
 379             sim_printf ("\r[FNP emulation: DISCONNECT]\r\n");
 380           }
 381         // Clean up allocated data
 382         if (p->telnetp)
 383           {
 384             telnet_free (p->telnetp);
 385             // telnet_free frees self
 386             //free (p->telnetp);
 387             p->telnetp = NULL;
 388           }
 389         if (((uvClientData *) stream->data)->ttype)
 390           FREE (((uvClientData *) stream->data)->ttype);
 391         FREE (stream->data);
 392         stream->data = NULL;
 393       } // if (p)
 394     if (! uv_is_closing ((uv_handle_t *) stream))
 395       uv_close ((uv_handle_t *) stream, fuv_close_cb);
 396   }
 397 
 398 //
 399 // fuv_read_cb: libuv read complete callback
 400 //
 401 //   Cleanup on read error.
 402 //   Forward data to appropriate handler.
 403 
 404 static void fuv_read_cb (uv_stream_t* stream,
     /*  */
 405                          ssize_t nread,
 406                          const uv_buf_t* buf)
 407   {
 408     if (nread < 0)
 409       {
 410         //if (nread == UV_EOF)
 411           {
 412             close_connection (stream);
 413           }
 414       }
 415     else if (nread > 0)
 416       {
 417         if (! stream)
 418           {
 419             sim_warn ("fuv_read_cb bad client data\r\n");
 420             return;
 421           }
 422         uvClientData * p = (uvClientData *) stream->data;
 423         if (p)
 424           {
 425             if (p->telnetp)
 426               {
 427                 telnet_recv (p->telnetp, buf->base, (size_t) nread); //-V525
 428               }
 429             else
 430               {
 431 
 432                 (* p->read_cb) ((uv_tcp_t *) stream, nread, (unsigned char *) buf->base);
 433 
 434 
 435 
 436 
 437 
 438 
 439 
 440 
 441 
 442 
 443 
 444               }
 445           }
 446       }
 447 
 448     if (buf->base)
 449         free (buf->base); /* X-LINTED: FREE */
 450   }
 451 
 452 //
 453 // fuv_write_cb: libuv write complete callback
 454 //
 455 //   Cleanup on error
 456 //   Free buffers
 457 //
 458 
 459 static void fuv_write_cb (uv_write_t * req, int status)
     /*  */
 460   {
 461     if (status < 0)
 462       {
 463         if (status == -ECONNRESET || status == -ECANCELED ||
 464             status == -EPIPE)
 465           {
 466             // This occurs when the other end disconnects; not an "error"
 467           }
 468         else
 469           {
 470             sim_warn ("fuv_write_cb status %d (%s)\r\n", -status, xstrerror_l(-status));
 471           }
 472 
 473         // connection reset by peer
 474         close_connection (req->handle);
 475       }
 476 
 477 #if defined(USE_REQ_DATA)
 478     //sim_printf ("freeing bufs %p\r\n", req->data);
 479     FREE (req->data);
 480 #else
 481     unsigned int nbufs = req->nbufs;
 482     uv_buf_t * bufs = req->bufs;
 483     for (unsigned int i = 0; i < nbufs; i ++)
 484       {
 485         if (bufs && bufs[i].base)
 486           {
 487             //sim_printf ("freeing bufs%d %p\r\n", i, bufs[i].base);
 488             FREE (bufs[i].base);
 489           }
 490         if (req->bufsml[i].base)
 491           {
 492             //sim_printf ("freeing bufsml%d %p@%p\r\n", i, req->bufsml[i].base, & req->bufsml[i].base);
 493             FREE (req->bufsml[i].base);
 494           }
 495       }
 496 #endif /* if defined(USE_REQ_DATA) */
 497 
 498     // the buf structure is copied; do not free.
 499     //sim_printf ("freeing req %p\r\n", req);
 500     FREE (req);
 501   }
 502 
 503 //
 504 // fuv_write_3270_cb: libuv write complete callback
 505 //
 506 //   Cleanup on error
 507 //   Free buffers
 508 //
 509 
 510 static void fuv_write_3270_cb (uv_write_t * req, int status) {
     /*  */
 511     uv_tcp_t * client = (uv_tcp_t *) req->handle;
 512     fuv_write_cb (req, status);
 513     set_3270_write_complete (client);
 514   }
 515 
 516 // Create and start a write request
 517 
 518 static void fnpuv_start_write_3270_actual (UNUSED uv_tcp_t * client, unsigned char * data, ssize_t datalen)
     /*  */
 519   {
 520 #if defined(TESTING)
 521       sim_printf ("fnpuv_start_write_3270_actual\r\n");
 522 #endif /* if defined(TESTING) */
 523 
 524     // Find the client from the device selection call
 525 
 526     uint stn_no;
 527     for (stn_no = 0; stn_no < ADDR_MAP_ENTRIES; stn_no ++)
 528       if (addr_map [stn_no] == fnpData.ibm3270ctlr[ASSUME0].selDevChar)
 529         break;
 530     if (stn_no >= ADDR_MAP_ENTRIES)
 531       {
 532         sim_printf ("fnpuv_start_write_3270_actual couldn't find selDevChar %02x\r\n",
 533                     (unsigned int) fnpData.ibm3270ctlr[ASSUME0].selDevChar);
 534         return;
 535       }
 536     uv_tcp_t * stn_client = fnpData.ibm3270ctlr[ASSUME0].stations[stn_no].client;
 537     if (! stn_client || uv_is_closing ((uv_handle_t *) stn_client))
 538       return;
 539 
 540     // Allocate write request
 541 /* Suppress Clang Analyzer's possible memory leak warning */
 542 #if !defined (__clang_analyzer__)
 543     uv_write_t * req = (uv_write_t *) malloc (sizeof (uv_write_t));
 544     if (!req)
 545       {
 546         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 547                        __func__, __FILE__, __LINE__);
 548 # if defined(USE_BACKTRACE)
 549 #  if defined(SIGUSR2)
 550         (void)raise(SIGUSR2);
 551         /*NOTREACHED*/ /* unreachable */
 552 #  endif /* if defined(SIGUSR2) */
 553 # endif /* if defined(USE_BACKTRACE) */
 554         abort();
 555       }
 556     // This makes sure that bufs*.base and bufsml*.base are NULL
 557     (void)memset (req, 0, sizeof (uv_write_t));
 558     uv_buf_t buf = uv_buf_init ((char *) malloc ((unsigned long) datalen), (uint) datalen);
 559 //sim_printf ("allocated req %p data %p\r\n", req, buf.base);
 560 # if defined(USE_REQ_DATA)
 561     req->data = buf.base;
 562 # endif
 563 //sim_printf ("fnpuv_start_write_actual req %p buf.base %p\r\n", req, buf.base);
 564     memcpy (buf.base, data, (unsigned long) datalen);
 565     int ret = uv_write (req, (uv_stream_t *) stn_client, & buf, 1, fuv_write_3270_cb);
 566 // There seems to be a race condition when Multics signals a disconnect_line;
 567 // We close the socket, but Multics is still writing its goodbye text trailing
 568 // NULs.
 569 // If the socket has been closed, write will return BADF; just ignore it.
 570     if (ret < 0 && ret != -EBADF)
 571       sim_printf ("\r[FNP emulation: uv_write returned %d]\r\n", ret);
 572 #endif /* if !defined(__clang_analyzer__) */
 573   }
 574 
 575 void fnpuv_start_write_actual (uv_tcp_t * client, unsigned char * data, ssize_t datalen)
     /*  */
 576   {
 577     if (! client || uv_is_closing ((uv_handle_t *) client))
 578       return;
 579 /* Suppress Clang Analyzer's possible memory leak warning */
 580 #if !defined(__clang_analyzer__)
 581     uv_write_t * req = (uv_write_t *) malloc (sizeof (uv_write_t));
 582     if (!req)
 583       {
 584         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 585                        __func__, __FILE__, __LINE__);
 586 # if defined(USE_BACKTRACE)
 587 #  if defined(SIGUSR2)
 588         (void)raise(SIGUSR2);
 589         /*NOTREACHED*/ /* unreachable */
 590 #  endif /* if defined(SIGUSR2) */
 591 # endif /* if defined(USE_BACKTRACE) */
 592         abort();
 593       }
 594     // This makes sure that bufs*.base and bufsml*.base are NULL
 595     (void)memset (req, 0, sizeof (uv_write_t));
 596     uv_buf_t buf = uv_buf_init ((char *) malloc ((unsigned long) datalen), (uint) datalen);
 597 //sim_printf ("allocated req %p data %p\r\n", req, buf.base);
 598 # if defined(USE_REQ_DATA)
 599     req->data = buf.base;
 600 # endif
 601 //sim_printf ("fnpuv_start_write_actual req %p buf.base %p\r\n", req, buf.base);
 602     memcpy (buf.base, data, (unsigned long) datalen);
 603     int ret = uv_write (req, (uv_stream_t *) client, & buf, 1, fuv_write_cb);
 604 // There seems to be a race condition when Multics signals a disconnect_line;
 605 // We close the socket, but Multics is still writing its goodbye text trailing
 606 // NULs.
 607 // If the socket has been closed, write will return BADF; just ignore it.
 608     if (ret < 0 && ret != -EBADF)
 609       sim_printf ("\r[FNP emulation: uv_write returned %d]\r\n", ret);
 610 #endif /* if !defined(__clang_analyzer__) */
 611   }
 612 
 613 //
 614 // Write data to a connection, doing Telnet if needed.
 615 //
 616 
 617 void fnpuv_start_write (uv_tcp_t * client, unsigned char * data, ssize_t datalen)
     /*  */
 618   {
 619     if (! client || uv_is_closing ((uv_handle_t *) client))
 620       return;
 621     uvClientData * p = (uvClientData *) client->data;
 622     if (! p) //-V547
 623       return;
 624     if (!p->telnetp)
 625       {
 626         sim_warn ("telnetp NULL; dropping fnpuv_start_write()\r\n");
 627         return;
 628       }
 629     telnet_send (p->telnetp, (char *) data, (size_t) datalen);
 630   }
 631 
 632 void fnpuv_start_3270_write (uv_tcp_t * client, unsigned char * data, ssize_t datalen)
     /*  */
 633   {
 634     if (! client || uv_is_closing ((uv_handle_t *) client) || ! client->data)
 635       return;
 636     uvClientData * p = (uvClientData *) client->data;
 637     if (! p) //-V547
 638       return;
 639 #if defined(TESTING)
 640 sim_printf ("fnpuv_start_3270_write\r\n");
 641 #endif
 642 
 643     // Strip BSC protocol:
 644     //    STX <text> ETX
 645     //    EOT
 646 
 647     if (datalen == 1 && data [0] == 0x37) // EOT
 648       {
 649 #if defined(TESTING)
 650 sim_printf ("fnpuv: detected EOT\r\n");
 651 #endif /* if defined(TESTING) */
 652         fnpuv_send_eor (client);
 653         return;
 654       }
 655 
 656     unsigned char * actual_data_start = data;
 657     unsigned long actual_datalen = (unsigned long) datalen;
 658     //bool send_eor = false;
 659     if (datalen > 0 && data [datalen - 1] == 0x03) // ETX
 660       {
 661         actual_datalen --;
 662         //send_eor = true;
 663       }
 664     if (datalen > 0 && data [0] == 0x02) // STX
 665       {
 666         actual_data_start ++;
 667         actual_datalen --;
 668         if (actual_datalen > 0 && data [1] == 0x27) // ESC
 669           {
 670             actual_data_start ++;
 671             actual_datalen --;
 672           }
 673       }
 674 
 675     //telnet_send (p->telnetp, (char *) actual_data_start, (size_t) actual_datalen);
 676     //if (send_eor) fnpuv_send_eor (client);
 677     if (actual_datalen > 0)
 678       {
 679         telnet_send (p->telnetp, (char *) actual_data_start, (size_t) actual_datalen);
 680       }
 681   }
 682 
 683 // C-string wrapper for fnpuv_start_write
 684 
 685 void fnpuv_start_writestr (uv_tcp_t * client, unsigned char * data)
     /*  */
 686   {
 687     //fnpuv_start_write (client, data, (ssize_t) strlen (data));
 688     if (! client || uv_is_closing ((uv_handle_t *) client))
 689       return;
 690     if (! client->data)
 691       {
 692         sim_warn ("fnpuv_start_writestr bad client data\r\n");
 693         return;
 694       }
 695     uvClientData * p = client->data;
 696     (* p->write_cb) (client, data, (ssize_t) strlen ((char *) data));
 697   }
 698 
 699 void fnpuv_send_eor (uv_tcp_t * client)
     /*  */
 700   {
 701     if (! client || uv_is_closing ((uv_handle_t *) client))
 702       return;
 703     if (! client->data)
 704       {
 705         sim_warn ("fnpuv_send_eor bad client data\r\n");
 706         return;
 707       }
 708     uvClientData * p = (uvClientData *) client->data;
 709     ltnEOR (p->telnetp);
 710     //unsigned char EOR [] = { TELNET_IAC, TELNET_EOR };
 711     //fnpuv_start_write_special (client, (char *) EOR, sizeof (EOR));
 712   }
 713 
 714 void fnpuv_recv_eor (uv_tcp_t * client)
     /*  */
 715   {
 716     fnpRecvEOR (client);
 717   }
 718 
 719 //
 720 // Enable reading on connection
 721 //
 722 
 723 void fnpuv_read_start (uv_tcp_t * client)
     /*  */
 724   {
 725     if (! client || uv_is_closing ((uv_handle_t *) client))
 726       return;
 727     uv_read_start ((uv_stream_t *) client, alloc_buffer, fuv_read_cb);
 728   }
 729 
 730 //
 731 // Disable reading on connection
 732 //
 733 
 734 void fnpuv_read_stop (uv_tcp_t * client)
     /*  */
 735   {
 736     if (! client || uv_is_closing ((uv_handle_t *) client))
 737       return;
 738     uv_read_stop ((uv_stream_t *) client);
 739   }
 740 
 741 //
 742 // Connection callback handler for dialup connections
 743 //
 744 
 745 static void on_new_connection (uv_stream_t * server, int status)
     /*  */
 746   {
 747     if (status < 0)
 748       {
 749         sim_printf ("\r[FNP emulation: new connection error: %s]\r\n", uv_strerror(status));
 750         // error!
 751         return;
 752       }
 753 
 754     uv_tcp_t * client = (uv_tcp_t *) malloc (sizeof (uv_tcp_t));
 755     if (!client)
 756       {
 757         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 758                        __func__, __FILE__, __LINE__);
 759 #if defined(USE_BACKTRACE)
 760 # if defined(SIGUSR2)
 761         (void)raise(SIGUSR2);
 762         /*NOTREACHED*/ /* unreachable */
 763 # endif /* if defined(SIGUSR2) */
 764 #endif /* if defined(USE_BACKTRACE) */
 765         abort();
 766       }
 767     uv_tcp_init (fnpData.loop, client);
 768     if (uv_accept (server, (uv_stream_t *) client) != 0)
 769       {
 770         uv_close ((uv_handle_t *) client, fuv_close_cb);
 771         return;
 772       }
 773 
 774     // if server->data is non-null, this is a slave server; else a dialup
 775     // server
 776     if (server->data)
 777       {
 778         uvClientData * p = (uvClientData *) server->data;
 779         struct t_line * linep = & fnpData.fnpUnitData[p->fnpno].MState.line[p->lineno];
 780 
 781         // Slave servers only handle a single connection at a time
 782         if (linep->line_client)
 783           {
 784             uv_close ((uv_handle_t *) client, fuv_close_cb);
 785 # if defined(TESTING)
 786 sim_printf ("\r[FNP emulation: dropping 2nd slave]\r\n");
 787 # endif
 788             return;
 789           }
 790 
 791         linep->line_client = client;
 792       }
 793 
 794     struct sockaddr name;
 795     int namelen = sizeof (name);
 796     uv_tcp_nodelay (client,1);
 797     int ret = uv_tcp_getpeername (client, & name, & namelen);
 798     if (ret < 0)
 799       {
 800         sim_printf ("\r[FNP emulation: CONNECT; addr err %d]\r\n", ret);
 801       }
 802     else
 803       {
 804         struct sockaddr_in * p = (struct sockaddr_in *) & name;
 805         sim_printf ("\r[FNP emulation: CONNECT %s]\r\n", inet_ntoa (p -> sin_addr));
 806       }
 807 
 808     uvClientData * p = (uvClientData *) malloc (sizeof (uvClientData));
 809     if (! p)
 810       {
 811          (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 812                         __func__, __FILE__, __LINE__);
 813 #if defined(USE_BACKTRACE)
 814 # if defined(SIGUSR2)
 815         (void)raise(SIGUSR2);
 816         /*NOTREACHED*/ /* unreachable */
 817 # endif /* if defined(SIGUSR2) */
 818 #endif /* if defined(USE_BACKTRACE) */
 819         abort();
 820       }
 821     client->data       = p;
 822     p->assoc           = false;
 823     p->nPos            = 0;
 824     p->ttype           = NULL;
 825     p->write_actual_cb = fnpuv_start_write_actual;
 826     // dialup connections are routed through libtelent
 827     if (! server->data)
 828       {
 829         p->read_cb  = fnpuv_unassociated_readcb;
 830         p->write_cb = fnpuv_start_write;
 831         p->telnetp  = ltnConnect (client);
 832 
 833         if (! p->telnetp)
 834           {
 835              sim_warn ("ltnConnect failed\r\n");
 836              return;
 837           }
 838       }
 839     else
 840       {
 841         p->read_cb       = fnpuv_associated_readcb;
 842         p->write_cb      = fnpuv_start_write_actual;
 843         p->telnetp       = NULL;
 844         uvClientData * q = (uvClientData *) server->data;
 845         p->fnpno         = q->fnpno;
 846         p->lineno        = q->lineno;
 847         p->assoc         = true;
 848       }
 849     fnpuv_read_start (client);
 850     if (! server->data)
 851       fnpConnectPrompt (client);
 852     else
 853       {
 854         uvClientData * p = (uvClientData *) server->data;
 855         struct t_line * linep = & fnpData.fnpUnitData[p->fnpno].MState.line[p->lineno];
 856         if (linep->lineType == 0) /* LINE_NONE */
 857           linep->lineType = 1; /* LINE_ASCII */
 858         linep->accept_new_terminal = true;
 859         reset_line (linep);
 860       }
 861   }
 862 
 863 //
 864 // Setup the dialup listener
 865 //
 866 
 867 int fnpuvInit (int telnet_port, char * telnet_address)
     /*  */
 868   {
 869     // Ignore multiple calls; this means that once the listen port is
 870     // opened, it can't be changed. Fixing this requires non-trivial
 871     // changes.
 872     if (fnpData.du_server_inited)
 873       {
 874         sim_printf ("\r[FNP emulation: FNP already initialized]\r\n");
 875         return 1;
 876       }
 877 
 878     if (! fnpData.loop)
 879       fnpData.loop = uv_default_loop ();
 880 
 881     // Initialize the server socket
 882     fnpData.loop = uv_default_loop ();
 883     uv_tcp_init (fnpData.loop, & fnpData.du_server);
 884 
 885 // XXX to do clean shutdown
 886 // uv_loop_close (fnpData.loop);
 887 
 888     // Flag the this server as being the dialup server
 889     fnpData.du_server.data = NULL;
 890 
 891     // Bind and listen
 892     struct sockaddr_in addr;
 893     uv_ip4_addr (telnet_address, telnet_port, & addr);
 894     uv_tcp_bind (& fnpData.du_server, (const struct sockaddr *) & addr, 0);
 895     int r = uv_listen ((uv_stream_t *) & fnpData.du_server, DEFAULT_BACKLOG,
 896                        on_new_connection);
 897     if (r)
 898      {
 899         sim_printf ("\r[FNP emulation: listen error: %s:%ld: %s]\r\n", telnet_address, (long) telnet_port, uv_strerror(r));
 900         return 1;
 901      }
 902     fnpData.du_server_inited = true;
 903     sim_printf ("\r[FNP emulation: TELNET server listening on %s:%ld]\r\n", telnet_address, (long) telnet_port);
 904     return 0;
 905   }
 906 
 907 // Make a single pass through the libuv event queue.
 908 
 909 void fnpuvProcessEvent (void)
     /*  */
 910   {
 911     // UV_RUN_NOWAIT: Poll for i/o once but don’t block if there are no
 912     // pending callbacks. Returns zero if done (no active handles or
 913     // requests left), or non-zero if more callbacks are expected (meaning
 914     // you should run the event loop again sometime in the future).
 915 
 916     // Note that uv_run returns non-zero if that are any active_handles
 917     // (e.g. TCP connection listener open); that means a non-zero
 918     // return does not mean i/o is pending.
 919     if (! fnpData.loop)
 920       return;
 921     /* int ret = */ uv_run (fnpData.loop, UV_RUN_NOWAIT);
 922   }
 923 
 924 //
 925 // dialout line connection callback
 926 //
 927 
 928 static void on_dialout_connect (uv_connect_t * server, int status)
     /*  */
 929   {
 930     sim_printf ("\r[FNP emulation: dialout connect]\r\n");
 931     uvClientData * p = (uvClientData *) server->handle->data;
 932     // If data is NULL, assume that the line has already been torn down.
 933     if (! p)
 934       {
 935          sim_printf ("\r[FNP emulation: NOTE: on_dialout_connect called with data == NULL]\r\n");
 936          return;
 937       }
 938     struct t_line * linep = & fnpData.fnpUnitData[p->fnpno].MState.line[p->lineno];
 939     if (status < 0)
 940       {
 941         sim_printf ("\r[FNP emulation: dialout connection error: %s]\r\n", uv_strerror(status));
 942         //sim_printf ("%p\r\n", p);
 943         //sim_printf ("%d.%d\r\n", p->fnpno, p->lineno);
 944         linep->acu_dial_failure = true;
 945         return;
 946       }
 947 
 948     uv_read_start ((uv_stream_t *) linep->line_client, alloc_buffer, fuv_read_cb);
 949     linep->listen = true;
 950     if (linep->lineType == 0) /* LINE_NONE */
 951       linep->lineType = 1; /* LINE_ASCII */
 952     linep->accept_new_terminal = true;
 953     linep->was_CR              = false;
 954     linep->line_client->data   = p;
 955     if (p->telnetp)
 956       {
 957         ltnDialout (p->telnetp);
 958       }
 959   }
 960 
 961 //
 962 // Perform a dialout
 963 //
 964 
 965 void fnpuv_dial_out (uint fnpno, uint lineno, word36 d1, word36 d2, word36 d3)
     /*  */
 966   {
 967     if (! fnpData.loop)
 968       return;
 969     sim_printf ("\r[FNP emulation: received dial_out %c.h%03d %012llu %012llu %012llu]\r\n", fnpno+'a', lineno,
 970             (unsigned long long)d1, (unsigned long long)d2, (unsigned long long)d3);
 971     struct t_line * linep = & fnpData.fnpUnitData[fnpno].MState.line[lineno];
 972     uint d01   = (d1 >> 30) & 017;
 973     uint d02   = (d1 >> 24) & 017;
 974     uint d03   = (d1 >> 18) & 017;
 975     uint d04   = (d1 >> 12) & 017;
 976     uint d05   = (d1 >>  6) & 017;
 977     uint d06   = (d1 >>  0) & 017;
 978     uint d07   = (d2 >> 30) & 017;
 979     uint d08   = (d2 >> 24) & 017;
 980     uint d09   = (d2 >> 18) & 017;
 981     uint d10   = (d2 >> 12) & 017;
 982     uint d11   = (d2 >>  6) & 017;
 983     uint d12   = (d2 >>  0) & 017;
 984     uint flags = (d3 >> 30) & 017;
 985     uint p1    = (d3 >> 24) & 017;
 986     uint p2    = (d3 >> 18) & 017;
 987     uint p3    = (d3 >> 12) & 017;
 988     uint p4    = (d3 >>  6) & 017;
 989     uint p5    = (d3 >>  0) & 017;
 990 
 991     uint oct1  = d01 * 100 + d02 * 10 + d03;
 992     uint oct2  = d04 * 100 + d05 * 10 + d06;
 993     uint oct3  = d07 * 100 + d08 * 10 + d09;
 994     uint oct4  = d10 * 100 + d11 * 10 + d12;
 995 
 996     uint port  = ((((p1 * 10) + p2) * 10 + p3) * 10 + p4) * 10 + p5;
 997 
 998 // Flags
 999 //   1    Use Telnet
1000 #if defined(TUN)
1001 //   2    Use TUN device (in which case 'port' is the netmask
1002 //   4
1003 
1004     linep->is_tun = false;
1005     if (flags & 2)
1006       {
1007         if (linep->tun_fd <= 0)
1008           {
1009             char a_name [IFNAMSIZ] = "dps8m";
1010             linep->tun_fd = tun_alloc (a_name);
1011             if (linep->tun_fd < 0)
1012               {
1013                 sim_printf ("\r[FNP emulation: dialout TUN tun_alloc returned %d errno %d]\r\n", linep->tun_fd, errno);
1014                 return;
1015              }
1016             int flags = fcntl (linep->tun_fd, F_GETFL, 0);
1017             if (flags < 0)
1018               {
1019                 sim_printf ("\r[FNP emulation: dialout TUN F_GETFL returned < 0]\r\n");
1020                 return;
1021               }
1022             flags |= O_NONBLOCK;
1023             int ret = fcntl (linep->tun_fd, F_SETFL, flags);
1024             if (ret)
1025               {
1026                 sim_printf ("\r[FNP emulation: dialout TUN F_SETFL returned %d]\r\n", ret);
1027                 return;
1028               }
1029           }
1030           linep->is_tun = true;
1031           return;
1032         }
1033 #endif /* if defined(TUN) */
1034 
1035     // firewall
1036 
1037     // Default is accept
1038     bool accept = true;
1039     uint32_t ip_addr = (uint32_t) ((oct1 << 24) | (oct2 << 16) | (oct3 << 8) | oct4);
1040     uint this_line = encodeline (fnpno, lineno);
1041     for (int i = 0; i < n_fw_entries; i ++)
1042       {
1043         struct fw_entry_s * p = fw_entries + i;
1044         if (this_line < p->line_0 || this_line > p->line_1)
1045           continue;
1046         if ((ip_addr & p->cidr_mask) != (p->ipaddr & p->cidr_mask))
1047           continue;
1048         accept = p->accept;
1049         break;
1050       }
1051 
1052     if (! accept)
1053       {
1054         sim_printf ("Dialout %c.d%03d denied\r\n", fnpno + 'a', lineno);
1055         linep->acu_dial_failure = true;
1056         return;
1057       }
1058 
1059     char ipaddr [256];
1060     (void)sprintf (ipaddr, "%d.%d.%d.%d", oct1, oct2, oct3, oct4);
1061     sim_printf ("calling %s:%d\r\n", ipaddr,port);
1062 
1063     struct sockaddr_in dest;
1064     uv_ip4_addr(ipaddr, (int) port, &dest);
1065 
1066     linep->line_client = (uv_tcp_t *) malloc (sizeof (uv_tcp_t));
1067     if (!linep->line_client)
1068       {
1069         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1070                        __func__, __FILE__, __LINE__);
1071 #if defined(USE_BACKTRACE)
1072 # if defined(SIGUSR2)
1073         (void)raise(SIGUSR2);
1074         /*NOTREACHED*/ /* unreachable */
1075 # endif /* if defined(SIGUSR2) */
1076 #endif /* if defined(USE_BACKTRACE) */
1077         abort();
1078       }
1079     uv_tcp_init (fnpData.loop, linep->line_client);
1080 
1081     uvClientData * p = (uvClientData *) malloc (sizeof (uvClientData));
1082     if (! p)
1083       {
1084         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1085                        __func__, __FILE__, __LINE__);
1086 #if defined(USE_BACKTRACE)
1087 # if defined(SIGUSR2)
1088         (void)raise(SIGUSR2);
1089         /*NOTREACHED*/ /* unreachable */
1090 # endif /* if defined(SIGUSR2) */
1091 #endif /* if defined(USE_BACKTRACE) */
1092         abort();
1093       }
1094     p->assoc                 = true;
1095     p->read_cb               = fnpuv_associated_readcb;
1096     p->nPos                  = 0;
1097     p->ttype                 = NULL;
1098     p->fnpno                 = fnpno;
1099     p->lineno                = lineno;
1100     linep->line_client->data = p;
1101 
1102     if (flags & 1)
1103       {
1104         p->write_cb        = fnpuv_start_write;
1105         p->write_actual_cb = fnpuv_start_write_actual;
1106         p->telnetp         = ltnConnect (linep->line_client);
1107         if (! p->telnetp)
1108           {
1109               sim_warn ("ltnConnect failed\r\n");
1110           }
1111       }
1112     else
1113       {
1114         p->write_cb        = fnpuv_start_write_actual;
1115         p->write_actual_cb = fnpuv_start_write_actual;
1116         p->telnetp         = NULL; // Mark this line as 'not a telnet connection'
1117       }
1118 
1119     uv_tcp_connect (& linep->doConnect, linep->line_client, (const struct sockaddr *) & dest, on_dialout_connect);
1120   }
1121 
1122 
1123 
1124 
1125 
1126 
1127 
1128 
1129 
1130 
1131 
1132 
1133 
1134 
1135 
1136 
1137 
1138 
1139 
1140 //
1141 // Start a slave line connection listener.
1142 //
1143 
1144 void fnpuv_open_slave (uint fnpno, uint lineno)
     /*  */
1145   {
1146     if (! fnpData.loop)
1147       return;
1148     sim_printf ("\r[FNP emulation: fnpuv_open_slave %d.%d]\r\n", fnpno, lineno);
1149     struct t_line * linep = & fnpData.fnpUnitData[fnpno].MState.line[lineno];
1150 
1151     // Do we already have a listening port (ie not first time)?
1152     if (linep->server.data)
1153       return;
1154 
1155     uv_tcp_init (fnpData.loop, & linep->server);
1156 
1157     // Mark this server has being a slave server
1158     // XXX This does not get freed during a normal shutdown, as Multics
1159     // XXX doesn't tell idle slave lines anything. The emulator shutdown
1160     // XXX needs to call an FNP cleanup routine that frees this.
1161 
1162     uvClientData * p = (uvClientData *) malloc (sizeof (uvClientData));
1163     if (! p)
1164       {
1165         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1166                        __func__, __FILE__, __LINE__);
1167 #if defined(USE_BACKTRACE)
1168 # if defined(SIGUSR2)
1169         (void)raise(SIGUSR2);
1170         /*NOTREACHED*/ /* unreachable */
1171 # endif /* if defined(SIGUSR2) */
1172 #endif /* if defined(USE_BACKTRACE) */
1173         abort();
1174       }
1175     p->assoc           = false;
1176     p->read_cb         = fnpuv_associated_readcb;
1177     p->write_cb        = fnpuv_start_write_actual;
1178     p->write_actual_cb = fnpuv_start_write_actual;
1179     p->nPos            = 0;
1180     p->ttype           = NULL;
1181     p->fnpno           = fnpno;
1182     p->lineno          = lineno;
1183     linep->server.data = p;
1184     linep->line_client = NULL;
1185 
1186     struct sockaddr_in addr;
1187     uv_ip4_addr (fnpData.telnet_address, linep->port, & addr);
1188     uv_tcp_bind (& linep->server, (const struct sockaddr *) & addr, 0);
1189     int r = uv_listen ((uv_stream_t *) & linep->server, DEFAULT_BACKLOG,
1190                        on_new_connection);
1191     if (r)
1192      {
1193         sim_printf ("\r[FNP emulation: listen error: %s:%ld: %s]\r\n", fnpData.telnet_address, (long) linep->port, uv_strerror(r));
1194      }
1195     sim_printf ("\r[FNP emulation: listening on %s:%ld]\r\n", fnpData.telnet_address, (long) linep->port);
1196   }
1197 
1198 #if defined(TUN)
1199 static void processPacketInput (int fnpno, int lineno, unsigned char * buf, ssize_t nread)
     /*  */
1200   {
1201     //uvClientData * p = (uvClientData *) client->data;
1202     //uint fnpno       = p -> fnpno;
1203     //uint lineno      = p -> lineno;
1204     if (fnpno >= N_FNP_UNITS_MAX || lineno >= MAX_LINES)
1205       {
1206         sim_printf ("\r[FNP emulation: processPacketInput bogus client data]\r\n");
1207         return;
1208       }
1209 //sim_printf ("assoc. %d.%d nread %ld <%*s>\r\n", fnpno, lineno, (long) nread, buf);
1210 //{for (int i = 0; i < nread; i ++) sim_printf (" %03o", buf[i]);
1211  //sim_printf ("\r\n");
1212 //}
1213 
1214     struct t_line * linep = & fnpData.fnpUnitData[fnpno].MState.line[lineno];
1215     if (linep->inBuffer)
1216       {
1217         unsigned char * new = realloc (linep->inBuffer, (unsigned long) (linep->inSize + nread));
1218         if (! new)
1219           {
1220             (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1221                            __func__, __FILE__, __LINE__)
1222 # if defined(USE_BACKTRACE)
1223 #  if defined(SIGUSR2)
1224             (void)raise(SIGUSR2);
1225             /*NOTREACHED*/ /* unreachable */
1226 #  endif /* if defined(SIGUSR2) */
1227 # endif /* if defined(USE_BACKTRACE) */
1228             abort();
1229           }
1230         memcpy (new + linep->inSize, buf, (unsigned long) nread);
1231         linep->inSize  += nread;
1232         linep->inBuffer = new;
1233       }
1234     else
1235       {
1236         linep->inBuffer = malloc ((unsigned long) nread);
1237         if (! linep->inBuffer)
1238           {
1239             (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1240                            __func__, __FILE__, __LINE__);
1241 # if defined(USE_BACKTRACE)
1242 #  if defined(SIGUSR2)
1243             (void)raise(SIGUSR2);
1244             /*NOTREACHED*/ /* unreachable */
1245 #  endif /* if defined(SIGUSR2) */
1246 # endif /* if defined(USE_BACKTRACE) */
1247             abort();
1248           }
1249         memcpy (linep->inBuffer, buf, (unsigned long) nread);
1250         linep->inSize = (uint) nread;
1251         linep->inUsed = 0;
1252       }
1253 
1254   }
1255 
1256 static void fnoTUNProcessLine (int fnpno, int lineno, struct t_line * linep)
     /*  */
1257   {
1258 /* Note that "buffer" should be at least the MTU size of the interface, eg 1500 bytes */
1259     unsigned char buffer [1500 + 16];
1260     ssize_t nread = read (linep->tun_fd, buffer, sizeof (buffer));
1261     if (nread < 0)
1262       {
1263         //perror ("Reading from interface");
1264         //close (linep->tun_fd);
1265         //exit (1);
1266         if (errno == EAGAIN)
1267           return;
1268         sim_printf ("%ld %ld\r\n", (long) nread, (long) errno);
1269         return;
1270       }
1271 
1272 // To make debugging easier, return data as a hex string rather than binary.
1273 // When the stack interface is debugged, switch to binary.
1274     unsigned char xbufr [2 * (1500 + 16)];
1275     unsigned char bin2hex [16] = "0123456789ABCDEF";
1276 
1277     for (uint i = 0; i > nread; i ++)
1278       {
1279         xbufr [i * 2 + 0] = bin2hex [(buffer [i] >> 4) & 0xf];
1280         xbufr [i * 2 + 1] = bin2hex [(buffer [i] >> 0) & 0xf];
1281       }
1282      xbufr [nread * 2] = 0;
1283      processPacketInput (fnpno, lineno, xbufr, nread * 2 + 1);
1284 
1285 // Debugging
1286 // 4 bytes of metadata
1287 # define ip 4
1288     /* Do whatever with the data */
1289     sim_printf("Read %ld bytes\r\n", (long) nread);
1290     sim_printf ("%02x %02x %02x %02x %02x %02x %02x %02x\r\n",
1291       buffer [0],  buffer [1],  buffer [2],  buffer [3],
1292       buffer [4],  buffer [5],  buffer [6],  buffer [7]);
1293     sim_printf ("%02x %02x %02x %02x %02x %02x %02x %02x\r\n",
1294       buffer [8],  buffer [9],  buffer [10], buffer [11],
1295       buffer [12], buffer [13], buffer [14], buffer [15]);
1296     uint version         =         (buffer [ip +  0] >> 4) & 0xf;
1297     uint ihl             =         (buffer [ip +  0]) & 0xf;
1298     uint payload_offset  =                  ip + ihl * 4;
1299     uint tos             =          buffer [ip +  1];
1300     uint tl              = ((uint) (buffer [ip +  2]) << 8) +
1301                                     buffer [ip +  3];
1302     uint id              = ((uint) (buffer [ip +  4]) << 8) +
1303                                     buffer [ip +  5];
1304     uint df              =         (buffer [ip +  6] & 0x40) ? 1 : 0;
1305     uint mf              =         (buffer [ip +  6] & 0x20) ? 1 : 0;
1306     uint fragment_offset = ((uint) (buffer [ip +  6] & 0x1f) << 8) +
1307                                     buffer [ip +  7];
1308     uint ttl             =          buffer [ip +  8];
1309     uint protocol        =          buffer [ip +  9];
1310     uint header_checksum = (((uint) buffer [ip + 10]) << 8) +
1311                                     buffer [ip + 11];
1312     uint source_address  = (((uint) buffer [ip + 12]) << 24) +
1313                            (((uint) buffer [ip + 13]) << 16) +
1314                            (((uint) buffer [ip + 14]) << 8) +
1315                                     buffer [ip + 15];
1316     uint dest_address    = (((uint) buffer [ip + 16]) << 24) +
1317                            (((uint) buffer [ip + 17]) << 16) +
1318                            (((uint) buffer [ip + 18]) << 8) +
1319                                     buffer [ip + 19];
1320     if (protocol == 1)
1321       {
1322         uint type = buffer [payload_offset + 0];
1323         if (type == 0x08)
1324           {
1325             sim_printf ("ICMP Echo Request %d.%d.%d.%d %d.%d.%d.%d\r\n",
1326               buffer [ip + 12], buffer [ip + 13], buffer [ip + 14], buffer [ip + 15],
1327               buffer [ip + 16], buffer [ip + 17], buffer [ip + 18], buffer [ip + 19]);
1328           }
1329         else
1330           {
1331             sim_printf ("ICMP 0x%02x\r\n", type);
1332             sim_printf ("%02x %02x %02x %02x %02x %02x %02x %02x\r\n",
1333               buffer [payload_offset + 0], buffer [payload_offset + 1], buffer [payload_offset + 2], buffer [payload_offset + 3],
1334               buffer [payload_offset + 4], buffer [payload_offset + 5], buffer [payload_offset + 6], buffer [payload_offset + 7]);
1335           }
1336       }
1337     if (protocol == 0x11)
1338       {
1339         sim_printf ("UDP\r\n");
1340 
1341       }
1342     else
1343       {
1344         sim_printf ("protocol %02x\r\n", protocol);
1345       }
1346   }
1347 
1348 void fnpTUNProcessEvent (void)
     /*  */
1349   {
1350     unint32 numunits = fnp_dev.numunits;
1351     for (int fnpno = 0; fnpno < numnumts; fnpno ++)
1352       {
1353         for (int lineno = 0; lineno < MAX_LINES; lineno ++)
1354           {
1355             struct t_line * linep = & fnpData.fnpUnitData[fnpno].MState.line[lineno];
1356             if (linep->is_tun)
1357               fnoTUNProcessLine (fnpno, lineno, linep);
1358           }
1359       }
1360   }
1361 #endif
1362 
1363 void fnpuv3270Poll (bool start)
     /*  */
1364   {
1365     // Called at 100Hz; to 1 second poll
1366     fnpData.du3270_poll = start ? 100 : 0;
1367   }
1368 
1369 //
1370 // Connection callback handler for dialup connections
1371 //
1372 
1373 static void on_new_3270_connection (uv_stream_t * server, int status)
     /*  */
1374   {
1375     if (status < 0)
1376       {
1377         sim_printf ("\r[FNP emulation: TN3270 new connection error: %s]\r\n", uv_strerror(status));
1378         // error!
1379         return;
1380       }
1381 
1382     uv_tcp_t * client = (uv_tcp_t *) malloc (sizeof (uv_tcp_t));
1383     if (!client)
1384       {
1385         (void)fprintf(stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1386                       __func__, __FILE__, __LINE__);
1387 #if defined(USE_BACKTRACE)
1388 # if defined(SIGUSR2)
1389         (void)raise(SIGUSR2);
1390         /*NOTREACHED*/ /* unreachable */
1391 # endif /* if defined(SIGUSR2) */
1392 #endif /* if defined(USE_BACKTRACE) */
1393         abort();
1394       }
1395 
1396     uv_tcp_init (fnpData.loop, client);
1397     if (uv_accept (server, (uv_stream_t *) client) != 0)
1398       {
1399         uv_close ((uv_handle_t *) client, fuv_close_cb);
1400         return;
1401       }
1402 
1403     // Search for an available station
1404     uint stn_no;
1405     for (stn_no = 0; stn_no < IBM3270_STATIONS_MAX; stn_no ++)
1406       {
1407         if (fnpData.ibm3270ctlr[ASSUME0].stations[stn_no].client == NULL)
1408           break;
1409       }
1410     if (stn_no >= IBM3270_STATIONS_MAX)
1411       {
1412         // No stations available
1413         uv_close ((uv_handle_t *) client, fuv_close_cb);
1414         return;
1415       }
1416 
1417     uint fnpno  = fnpData.ibm3270ctlr[ASSUME0].fnpno;
1418     uint lineno = fnpData.ibm3270ctlr[ASSUME0].lineno;
1419     // Set the line client to NULL; the actual clients are in 'stations'
1420     fnpData.fnpUnitData[fnpno].MState.line[lineno].line_client = NULL;
1421 
1422     fnpData.ibm3270ctlr[ASSUME0].stations[stn_no].client = client;
1423 
1424     // Set up selection so the telnet negotiation can find the station.
1425     fnpData.ibm3270ctlr[ASSUME0].selDevChar = addr_map[stn_no];
1426 
1427     struct sockaddr name;
1428     int namelen = sizeof (name);
1429     int ret = uv_tcp_getpeername (client, & name, & namelen);
1430     if (ret < 0)
1431       {
1432         sim_printf ("\r[FNP emulation: CONNECT; addr err %d]\r\n", ret);
1433       }
1434     else
1435       {
1436         struct sockaddr_in * p = (struct sockaddr_in *) & name;
1437         sim_printf ("\r[FNP emulation: CONNECT %s]\r\n", inet_ntoa (p -> sin_addr));
1438       }
1439 
1440     uvClientData * p = (uvClientData *) malloc (sizeof (uvClientData));
1441     if (! p)
1442       {
1443          (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
1444                         __func__, __FILE__, __LINE__);
1445 #if defined(USE_BACKTRACE)
1446 # if defined(SIGUSR2)
1447          (void)raise(SIGUSR2);
1448          /*NOTREACHED*/ /* unreachable */
1449 # endif /* if defined(SIGUSR2) */
1450 #endif /* if defined(USE_BACKTRACE) */
1451          abort();
1452       }
1453     client->data       = p;
1454     p->assoc           = false;
1455     p->fnpno           = fnpno;
1456     p->lineno          = lineno;
1457     p->nPos            = 0;
1458     p->ttype           = NULL;
1459     p->read_cb         = fnpuv_3270_readcb;
1460     p->write_cb        = fnpuv_start_3270_write;
1461     p->write_actual_cb = fnpuv_start_write_3270_actual;
1462     p->stationNo       = stn_no;
1463     p->telnetp         = ltnConnect3270 (client);
1464 
1465     if (! p->telnetp)
1466       {
1467         sim_warn ("ltnConnect3270 failed\r\n");
1468         return;
1469       }
1470     fnpuv_read_start (client);
1471     fnp3270ConnectPrompt (client);
1472        // uvClientData * p               = (uvClientData *) server->data;
1473        // struct t_line * linep          = & fnpData.fnpUnitData[p->fnpno].MState.line[p->lineno];
1474        // linep->accept_new_terminal     = true;
1475        // linep->was_CR                  = false;
1476        // //linep->listen                = false;
1477        // linep->inputBufferSize         = 0;
1478        // linep->ctrlStrIdx              = 0;
1479        // linep->breakAll                = false;
1480        // linep->handleQuit              = false;
1481        // linep->echoPlex                = false;
1482        // linep->crecho                  = false;
1483        // linep->lfecho                  = false;
1484        // linep->tabecho                 = false;
1485        // linep->replay                  = false;
1486        // linep->polite                  = false;
1487        // linep->prefixnl                = false;
1488        // linep->eight_bit_out           = false;
1489        // linep->eight_bit_in            = false;
1490        // linep->odd_parity              = false;
1491        // linep->output_flow_control     = false;
1492        // linep->input_flow_control      = false;
1493        // linep->block_xfer_in_frame_sz  = 0;
1494        // linep->block_xfer_out_frame_sz = 0;
1495        // (void)memset (linep->delay_table, 0, sizeof (linep->delay_table));
1496        // linep->inputSuspendLen         = 0;
1497        // (void)memset (linep->inputSuspendStr, 0, sizeof (linep->inputSuspendStr));
1498        // linep->inputResumeLen          = 0;
1499        // (void)memset (linep->inputResumeStr, 0, sizeof (linep->inputResumeStr));
1500        // linep->outputSuspendLen        = 0;
1501        // (void)memset (linep->outputSuspendStr, 0, sizeof (linep->outputSuspendStr));
1502        // linep->outputResumeLen         = 0;
1503        // (void)memset (linep->outputResumeStr, 0, sizeof (linep->outputResumeStr));
1504        // linep->frame_begin             = 0;
1505        // linep->frame_end               = 0;
1506        // (void)memset (linep->echnego, 0, sizeof (linep->echnego));
1507        // linep->line_break              = false;
1508   }
1509 
1510 int fnpuv3270Init (int telnet3270_port)
     /*  */
1511   {
1512     // Ignore multiple calls; this means that once the listen port is
1513     // opened, it can't be changed. Fixing this requires non-trivial
1514     // changes.
1515     if (fnpData.du3270_server_inited)
1516       {
1517         sim_printf ("\r[FNP emulation: FNP already initialized]\r\n");
1518         return 1;
1519       }
1520     if (! fnpData.loop)
1521       fnpData.loop = uv_default_loop ();
1522     // Initialize the server socket
1523     uv_tcp_init (fnpData.loop, & fnpData.du3270_server);
1524 
1525     // Flag the this server as being a 3270
1526     fnpData.du3270_server.data = NULL;
1527 
1528     // Bind and listen
1529     struct sockaddr_in addr;
1530     uv_ip4_addr (fnpData.telnet_address, telnet3270_port, & addr);
1531     uv_tcp_bind (& fnpData.du3270_server, (const struct sockaddr *) & addr, 0);
1532     int r = uv_listen ((uv_stream_t *) & fnpData.du3270_server, DEFAULT_BACKLOG,
1533                    on_new_3270_connection);
1534     if (r)
1535      {
1536         sim_printf ("\r[FNP emulation: listen error: %s:%ld: %s]\r\n",
1537                     fnpData.telnet_address, (long) telnet3270_port, uv_strerror(r));
1538         return 1;
1539      }
1540     fnpData.du3270_server_inited = true;
1541     sim_printf ("\r[FNP emulation: TN3270 server listening on %s:%ld]\r\n",
1542                 fnpData.telnet_address, (long) telnet3270_port);
1543     fnpuv3270Poll (false);
1544     return 0;
1545   }
/* */
root/src/dps8/fnpuv.c

DEFINITIONS
