src/dps8/fnptelnet.c

/* */
This source file includes following definitions.
evHandler
ltnConnect
ltnConnect3270
ltnEOR
ltnDialout
fnpTelnetInit
fnp3270Init
   1 /*
   2  * vim: filetype=c:tabstop=4:ai:expandtab
   3  * SPDX-License-Identifier: ICU
   4  * scspell-id: 24f735f0-f62f-11ec-b8af-80ee73e9b8e7
   5  *
   6  * ---------------------------------------------------------------------------
   7  *
   8  * Copyright (c) 2016 Charles Anthony
   9  * Copyright (c) 2021-2025 The DPS8M Development Team
  10  *
  11  * This software is made available under the terms of the ICU License.
  12  * See the LICENSE.md file at the top-level directory of this distribution.
  13  *
  14  * ---------------------------------------------------------------------------
  15  */
  16 
  17 #include <stdio.h>
  18 #include <signal.h>
  19 
  20 #include "dps8.h"
  21 #include "dps8_sys.h"
  22 #include "dps8_iom.h"
  23 #include "dps8_cable.h"
  24 #include "dps8_cpu.h"
  25 #include "dps8_faults.h"
  26 #include "dps8_scu.h"
  27 #include "dps8_fnp2.h"
  28 #include "dps8_utils.h"
  29 #include "fnpuv.h"
  30 #include "fnptelnet.h"
  31 
  32 static const telnet_telopt_t my_telopts[] = {
  33     { TELNET_TELOPT_SGA,       TELNET_WILL, TELNET_DO   },
  34     { TELNET_TELOPT_ECHO,      TELNET_WILL, TELNET_DONT },
  35   //{ TELNET_TELOPT_TTYPE,     TELNET_WONT, TELNET_DONT },
  36     { TELNET_TELOPT_BINARY,    TELNET_WILL, TELNET_DO   },
  37   //{ TELNET_TELOPT_NAWS,      TELNET_WONT, TELNET_DONT },
  38     { -1, 0, 0 }
  39   };
  40 
  41 static const telnet_telopt_t my_3270telopts[] = {
  42     { TELNET_TELOPT_TTYPE,     TELNET_WILL, TELNET_DO },
  43     { TELNET_TELOPT_BINARY,    TELNET_WILL, TELNET_DO },
  44     { TELNET_TELOPT_EOR,       TELNET_WILL, TELNET_DO },
  45     { -1, 0, 0 }
  46   };
  47 
  48 static void evHandler (UNUSED telnet_t *telnet, telnet_event_t *event, void *user_data)
     /*  */
  49   {
  50     uv_tcp_t * client = (uv_tcp_t *) user_data;
  51 
  52     if (! telnet || ! libtelnet_is_valid(telnet)) {
  53         if (! sim_quiet) {
  54             sim_warn ("evHandler telnet status invalid\r\n");
  55         }
  56         return;
  57     }
  58 
  59     switch (event->type)
  60       {
  61         case TELNET_EV_DATA:
  62           {
  63             if (! client || ! client->data)
  64               {
  65                 if (! sim_quiet) {
  66                     sim_warn ("evHandler TELNET_EV_DATA bad client data\r\n");
  67                 }
  68                 return;
  69               }
  70             uvClientData * p = (uvClientData *) client->data;
  71             (* p->read_cb) (client, (ssize_t) event->data.size, (unsigned char *)event->data.buffer);
  72           }
  73           break;
  74 
  75         case TELNET_EV_SEND:
  76           {
  77             //sim_printf ("evHandler: send %zu <%s>\r\n", event->data.size, event->data.buffer);
  78             //fnpuv_start_write_actual (client, (char *) event->data.buffer, (ssize_t) event->data.size);
  79             if (! client || ! client->data)
  80               {
  81                 if (! sim_quiet) {
  82                     sim_warn ("evHandler TELNET_EV_SEND bad client data\r\n");
  83                 }
  84                 return;
  85               }
  86             uvClientData * p = client->data;
  87             (* p->write_actual_cb) (client, (unsigned char *) event->data.buffer, (ssize_t) event->data.size);
  88           }
  89           break;
  90 
  91         case TELNET_EV_DO:
  92           {
  93             if (event->neg.telopt == TELNET_TELOPT_BINARY)
  94               {
  95                 // DO Binary
  96               }
  97             else if (event->neg.telopt == TELNET_TELOPT_SGA)
  98               {
  99                 // DO Suppress Go Ahead
 100               }
 101             else if (event->neg.telopt == TELNET_TELOPT_ECHO)
 102               {
 103                 // DO Suppress Echo
 104               }
 105             else if (event->neg.telopt == TELNET_TELOPT_EOR)
 106               {
 107                 //sim_printf ("EOR rcvd\r\n");
 108                 //fnpuv_recv_eor (client);
 109                 // DO EOR
 110               }
 111             else
 112               {
 113                 if (! sim_quiet) {
 114                     sim_printf ("evHandler DO %d\r\n", event->neg.telopt);
 115                 }
 116               }
 117           }
 118           break;
 119 
 120         case TELNET_EV_DONT:
 121           {
 122             if (! sim_quiet) {
 123                 sim_printf ("evHandler DONT %d\r\n", event->neg.telopt);
 124             }
 125           }
 126           break;
 127 
 128         case TELNET_EV_WILL:
 129           {
 130             if (event->neg.telopt == TELNET_TELOPT_BINARY)
 131               {
 132                 // WILL BINARY
 133               }
 134             else if (event->neg.telopt == TELNET_TELOPT_TTYPE)
 135               {
 136                 // WILL TTYPE
 137               }
 138             else if (event->neg.telopt == TELNET_TELOPT_EOR)
 139               {
 140                 // WILL EOR
 141               }
 142             else
 143               {
 144                 if (! sim_quiet) {
 145                     if (event->neg.telopt != 3)
 146                         sim_printf ("evHandler WILL %d\r\n", event->neg.telopt);
 147                 }
 148               }
 149           }
 150           break;
 151 
 152         case TELNET_EV_WONT:
 153           {
 154             if (! sim_quiet) {
 155                 sim_printf ("evHandler WONT %d\r\n", event->neg.telopt);
 156             }
 157           }
 158           break;
 159 
 160         case TELNET_EV_ERROR:
 161           {
 162             if (! sim_quiet) {
 163                 sim_warn ("libtelnet evHandler error <%s>\r\n", event->error.msg);
 164             }
 165           }
 166           break;
 167 
 168         case TELNET_EV_IAC:
 169           {
 170             if (event->iac.cmd == TELNET_BREAK ||
 171                 event->iac.cmd == TELNET_IP)
 172               {
 173                 if (! client || ! client->data)
 174                   {
 175                     if (! sim_quiet) {
 176                         sim_warn ("evHandler TELNET_EV_IAC bad client data\r\n");
 177                     }
 178                     return;
 179                   }
 180                 uvClientData * p = (uvClientData *) client->data;
 181                 if (p -> assoc)
 182                   {
 183                     fnpuv_associated_brk (client);
 184                   }
 185                 else
 186                   if (! sim_quiet) {
 187                     sim_warn ("libtelnet dropping unassociated BRK\r\n");
 188                   }
 189               }
 190             else if (event->iac.cmd == TELNET_EOR)
 191               {
 192                 fnpuv_recv_eor (client);
 193               }
 194             else
 195               if (! sim_quiet) {
 196                 if (event->iac.cmd != 241) {
 197                     sim_warn ("libtelnet unhandled IAC event %d\r\n", event->iac.cmd);
 198                 }
 199               }
 200           }
 201           break;
 202 
 203         case TELNET_EV_TTYPE:
 204           {
 205             if (! client || ! client->data)
 206               {
 207                 if (! sim_quiet) {
 208                     sim_warn ("evHandler TELNET_EV_IAC bad client data\r\n");
 209                 }
 210                 return;
 211               }
 212             uvClientData * p = (uvClientData *) client->data;
 213             // A client may negotiate TTYPE more than once.
 214             free (p->ttype);
 215             p->ttype = NULL;
 216             p->ttype = strdup (event->ttype.name);
 217             if (!p->ttype)
 218               {
 219                 (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 220                                __func__, __FILE__, __LINE__);
 221 #if defined(USE_BACKTRACE)
 222 # if defined(SIGUSR2)
 223                 (void)raise(SIGUSR2);
 224                 /*NOTREACHED*/ /* unreachable */
 225 # endif /* if defined(SIGUSR2) */
 226 #endif /* if defined(USE_BACKTRACE) */
 227                 abort();
 228               }
 229           }
 230           break;
 231 
 232         case TELNET_EV_SUBNEGOTIATION:
 233           {
 234             /* no subnegotiation */
 235           }
 236           break;
 237 
 238         default:
 239           if (! sim_quiet) {
 240             sim_printf ("evHandler: unhandled event %d\r\n", event->type);
 241           }
 242           break;
 243       }
 244 
 245   }
 246 
 247 void * ltnConnect (uv_tcp_t * client)
     /*  */
 248   {
 249     void * p = (void *) telnet_init (my_telopts, evHandler, 0, client);
 250     if (! p)
 251       {
 252         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 253                        __func__, __FILE__, __LINE__);
 254 #if defined(USE_BACKTRACE)
 255 # if defined(SIGUSR2)
 256         (void)raise(SIGUSR2);
 257         /*NOTREACHED*/ /* unreachable */
 258 # endif /* if defined(SIGUSR2) */
 259 #endif /* if defined(USE_BACKTRACE) */
 260         abort();
 261       }
 262     const telnet_telopt_t * q = my_telopts;
 263     while (q->telopt != -1)
 264       {
 265         telnet_negotiate (p, q->us, (unsigned char) q->telopt);
 266         q ++;
 267       }
 268     return p;
 269   }
 270 
 271 void * ltnConnect3270 (uv_tcp_t * client)
     /*  */
 272   {
 273     void * p = (void *) telnet_init (my_3270telopts, evHandler, 0, client);
 274     if (! p)
 275       {
 276         (void)fprintf (stderr, "\rFATAL: Out of memory! Aborting at %s[%s:%d]\r\n",
 277                        __func__, __FILE__, __LINE__);
 278 #if defined(USE_BACKTRACE)
 279 # if defined(SIGUSR2)
 280         (void)raise(SIGUSR2);
 281         /*NOTREACHED*/ /* unreachable */
 282 # endif /* if defined(SIGUSR2) */
 283 #endif /* if defined(USE_BACKTRACE) */
 284         abort();
 285       }
 286 
 287     // This behavior is copied from Hercules.
 288     telnet_negotiate (p, TELNET_DO, (unsigned char) TELNET_TELOPT_TTYPE);
 289     telnet_begin_sb  (p, TELNET_TELOPT_TTYPE);
 290     const char ttype [1] = { 1 };
 291     telnet_send (p, ttype, 1);
 292     telnet_finish_sb (p);
 293     telnet_negotiate (p, TELNET_WILL, (unsigned char) TELNET_TELOPT_BINARY);
 294     telnet_negotiate (p, TELNET_DO, (unsigned char) TELNET_TELOPT_BINARY);
 295     telnet_negotiate (p, TELNET_WILL, (unsigned char) TELNET_TELOPT_EOR);
 296     telnet_negotiate (p, TELNET_DO, (unsigned char) TELNET_TELOPT_EOR);
 297 
 298     return p;
 299   }
 300 
 301 void ltnEOR (telnet_t * tclient)
     /*  */
 302   {
 303     telnet_iac (tclient, TELNET_EOR);
 304   }
 305 
 306 void ltnDialout (UNUSED telnet_t * tclient)
     /*  */
 307   {
 308     // dialout telnet: We are a teletype. What settings should we be doing?
 309     //telnet_negotiate (tclient, TELNET_WILL, TELNET_TELOPT_SGA);
 310   }
 311 
 312 void fnpTelnetInit (void)
     /*  */
 313   {
 314 
 315 
 316 
 317 
 318 
 319 
 320 
 321 
 322 
 323 
 324 
 325 
 326 
 327   }
 328 
 329 void fnp3270Init (void)
     /*  */
 330   {
 331   }
/* */
root/src/dps8/fnptelnet.c

DEFINITIONS
