terminal3270.c (8928B)
1 /* 2 * Terminal 3270 implementation 3 * 4 * Copyright 2017 IBM Corp. 5 * 6 * Authors: Yang Chen <bjcyang@linux.vnet.ibm.com> 7 * Jing Liu <liujbjl@linux.vnet.ibm.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2 or (at 10 * your option) any later version. See the COPYING file in the top-level 11 * directory. 12 */ 13 14 #include "qemu/osdep.h" 15 #include "qapi/error.h" 16 #include "qemu/module.h" 17 #include "chardev/char-fe.h" 18 #include "hw/qdev-properties.h" 19 #include "hw/qdev-properties-system.h" 20 #include "hw/s390x/3270-ccw.h" 21 #include "qom/object.h" 22 23 /* Enough spaces for different window sizes. */ 24 #define INPUT_BUFFER_SIZE 1000 25 /* 26 * 1 for header, 1024*2 for datastream, 2 for tail 27 * Reserve enough spaces for telnet IAC escape. 28 */ 29 #define OUTPUT_BUFFER_SIZE 2051 30 31 struct Terminal3270 { 32 EmulatedCcw3270Device cdev; 33 CharBackend chr; 34 uint8_t inv[INPUT_BUFFER_SIZE]; 35 uint8_t outv[OUTPUT_BUFFER_SIZE]; 36 int in_len; 37 bool handshake_done; 38 guint timer_tag; 39 }; 40 typedef struct Terminal3270 Terminal3270; 41 42 #define TYPE_TERMINAL_3270 "x-terminal3270" 43 DECLARE_INSTANCE_CHECKER(Terminal3270, TERMINAL_3270, 44 TYPE_TERMINAL_3270) 45 46 static int terminal_can_read(void *opaque) 47 { 48 Terminal3270 *t = opaque; 49 50 return INPUT_BUFFER_SIZE - t->in_len; 51 } 52 53 static void terminal_timer_cancel(Terminal3270 *t) 54 { 55 if (t->timer_tag) { 56 g_source_remove(t->timer_tag); 57 t->timer_tag = 0; 58 } 59 } 60 61 /* 62 * Protocol handshake done, 63 * signal guest by an unsolicited DE irq. 64 */ 65 static void TN3270_handshake_done(Terminal3270 *t) 66 { 67 CcwDevice *ccw_dev = CCW_DEVICE(t); 68 SubchDev *sch = ccw_dev->sch; 69 70 t->handshake_done = true; 71 sch->curr_status.scsw.dstat = SCSW_DSTAT_DEVICE_END; 72 css_conditional_io_interrupt(sch); 73 } 74 75 /* 76 * Called when the interval is timeout to detect 77 * if the client is still alive by Timing Mark. 78 */ 79 static gboolean send_timing_mark_cb(gpointer opaque) 80 { 81 Terminal3270 *t = opaque; 82 const uint8_t timing[] = {0xff, 0xfd, 0x06}; 83 84 qemu_chr_fe_write_all(&t->chr, timing, sizeof(timing)); 85 return true; 86 } 87 88 /* 89 * Receive inbound data from socket. 90 * For data given to guest, drop the data boundary IAC, IAC_EOR. 91 * TODO: 92 * Using "Reset" key on x3270 may result multiple commands in one packet. 93 * This usually happens when the user meets a poor traffic of the network. 94 * As of now, for such case, we simply terminate the connection, 95 * and we should come back here later with a better solution. 96 */ 97 static void terminal_read(void *opaque, const uint8_t *buf, int size) 98 { 99 Terminal3270 *t = opaque; 100 CcwDevice *ccw_dev = CCW_DEVICE(t); 101 SubchDev *sch = ccw_dev->sch; 102 int end; 103 104 assert(size <= (INPUT_BUFFER_SIZE - t->in_len)); 105 106 terminal_timer_cancel(t); 107 t->timer_tag = g_timeout_add_seconds(600, send_timing_mark_cb, t); 108 memcpy(&t->inv[t->in_len], buf, size); 109 t->in_len += size; 110 if (t->in_len < 2) { 111 return; 112 } 113 114 if (!t->handshake_done) { 115 /* 116 * Receiving Terminal Type is the last step of handshake. 117 * The data format: IAC SB Terminal-Type IS <terminal type> IAC SE 118 * The code for Terminal-Type is 0x18, for IS is 0. 119 * Simply check the data format and mark handshake_done. 120 */ 121 if (t->in_len > 6 && t->inv[2] == 0x18 && t->inv[3] == 0x0 && 122 t->inv[t->in_len - 2] == IAC && t->inv[t->in_len - 1] == IAC_SE) { 123 TN3270_handshake_done(t); 124 t->in_len = 0; 125 } 126 return; 127 } 128 129 for (end = 0; end < t->in_len - 1; end++) { 130 if (t->inv[end] == IAC && t->inv[end + 1] == IAC_EOR) { 131 break; 132 } 133 } 134 if (end == t->in_len - 2) { 135 /* Data is valid for consuming. */ 136 t->in_len -= 2; 137 sch->curr_status.scsw.dstat = SCSW_DSTAT_ATTENTION; 138 css_conditional_io_interrupt(sch); 139 } else if (end < t->in_len - 2) { 140 /* "Reset" key is used. */ 141 qemu_chr_fe_disconnect(&t->chr); 142 } else { 143 /* Gathering data. */ 144 return; 145 } 146 } 147 148 static void chr_event(void *opaque, QEMUChrEvent event) 149 { 150 Terminal3270 *t = opaque; 151 CcwDevice *ccw_dev = CCW_DEVICE(t); 152 SubchDev *sch = ccw_dev->sch; 153 154 /* Ensure the initial status correct, always reset them. */ 155 t->in_len = 0; 156 t->handshake_done = false; 157 terminal_timer_cancel(t); 158 159 switch (event) { 160 case CHR_EVENT_OPENED: 161 /* 162 * 3270 does handshake firstly by the negotiate options in 163 * char-socket.c. Once qemu receives the terminal-type of the 164 * client, mark handshake done and trigger everything rolling again. 165 */ 166 t->timer_tag = g_timeout_add_seconds(600, send_timing_mark_cb, t); 167 break; 168 case CHR_EVENT_CLOSED: 169 sch->curr_status.scsw.dstat = SCSW_DSTAT_DEVICE_END; 170 css_conditional_io_interrupt(sch); 171 break; 172 case CHR_EVENT_BREAK: 173 case CHR_EVENT_MUX_IN: 174 case CHR_EVENT_MUX_OUT: 175 /* Ignore */ 176 break; 177 } 178 } 179 180 static void terminal_init(EmulatedCcw3270Device *dev, Error **errp) 181 { 182 Terminal3270 *t = TERMINAL_3270(dev); 183 static bool terminal_available; 184 185 if (terminal_available) { 186 error_setg(errp, "Multiple 3270 terminals are not supported."); 187 return; 188 } 189 terminal_available = true; 190 qemu_chr_fe_set_handlers(&t->chr, terminal_can_read, 191 terminal_read, chr_event, NULL, t, NULL, true); 192 } 193 194 static inline CcwDataStream *get_cds(Terminal3270 *t) 195 { 196 return &(CCW_DEVICE(&t->cdev)->sch->cds); 197 } 198 199 static int read_payload_3270(EmulatedCcw3270Device *dev) 200 { 201 Terminal3270 *t = TERMINAL_3270(dev); 202 int len; 203 int ret; 204 205 len = MIN(ccw_dstream_avail(get_cds(t)), t->in_len); 206 ret = ccw_dstream_write_buf(get_cds(t), t->inv, len); 207 if (ret < 0) { 208 return ret; 209 } 210 t->in_len -= len; 211 212 return len; 213 } 214 215 /* TN3270 uses binary transmission, which needs escape IAC to IAC IAC */ 216 static int insert_IAC_escape_char(uint8_t *outv, int out_len) 217 { 218 int IAC_num = 0, new_out_len, i, j; 219 220 for (i = 0; i < out_len; i++) { 221 if (outv[i] == IAC) { 222 IAC_num++; 223 } 224 } 225 if (IAC_num == 0) { 226 return out_len; 227 } 228 new_out_len = out_len + IAC_num; 229 for (i = out_len - 1, j = new_out_len - 1; j > i && i >= 0; i--, j--) { 230 outv[j] = outv[i]; 231 if (outv[i] == IAC) { 232 outv[--j] = IAC; 233 } 234 } 235 return new_out_len; 236 } 237 238 /* 239 * Write 3270 outbound to socket. 240 * Return the count of 3270 data field if succeeded, zero if failed. 241 */ 242 static int write_payload_3270(EmulatedCcw3270Device *dev, uint8_t cmd) 243 { 244 Terminal3270 *t = TERMINAL_3270(dev); 245 int retval = 0; 246 int count = ccw_dstream_avail(get_cds(t)); 247 int bound = (OUTPUT_BUFFER_SIZE - 3) / 2; 248 int len = MIN(count, bound); 249 int out_len = 0; 250 251 if (!t->handshake_done) { 252 if (!(t->outv[0] == IAC && t->outv[1] != IAC)) { 253 /* 254 * Before having finished 3270 negotiation, 255 * sending outbound data except protocol options is prohibited. 256 */ 257 return 0; 258 } 259 } 260 if (!qemu_chr_fe_backend_connected(&t->chr)) { 261 /* We just say we consumed all data if there's no backend. */ 262 return count; 263 } 264 265 t->outv[out_len++] = cmd; 266 do { 267 retval = ccw_dstream_read_buf(get_cds(t), &t->outv[out_len], len); 268 if (retval < 0) { 269 return retval; 270 } 271 count = ccw_dstream_avail(get_cds(t)); 272 out_len += len; 273 274 out_len = insert_IAC_escape_char(t->outv, out_len); 275 if (!count) { 276 t->outv[out_len++] = IAC; 277 t->outv[out_len++] = IAC_EOR; 278 } 279 retval = qemu_chr_fe_write_all(&t->chr, t->outv, out_len); 280 len = MIN(count, bound); 281 out_len = 0; 282 } while (len && retval >= 0); 283 return (retval <= 0) ? 0 : get_cds(t)->count; 284 } 285 286 static Property terminal_properties[] = { 287 DEFINE_PROP_CHR("chardev", Terminal3270, chr), 288 DEFINE_PROP_END_OF_LIST(), 289 }; 290 291 static const VMStateDescription terminal3270_vmstate = { 292 .name = TYPE_TERMINAL_3270, 293 .unmigratable = 1, 294 }; 295 296 static void terminal_class_init(ObjectClass *klass, void *data) 297 { 298 DeviceClass *dc = DEVICE_CLASS(klass); 299 EmulatedCcw3270Class *ck = EMULATED_CCW_3270_CLASS(klass); 300 301 device_class_set_props(dc, terminal_properties); 302 dc->vmsd = &terminal3270_vmstate; 303 ck->init = terminal_init; 304 ck->read_payload_3270 = read_payload_3270; 305 ck->write_payload_3270 = write_payload_3270; 306 } 307 308 static const TypeInfo ccw_terminal_info = { 309 .name = TYPE_TERMINAL_3270, 310 .parent = TYPE_EMULATED_CCW_3270, 311 .instance_size = sizeof(Terminal3270), 312 .class_init = terminal_class_init, 313 .class_size = sizeof(EmulatedCcw3270Class), 314 }; 315 316 static void register_types(void) 317 { 318 type_register_static(&ccw_terminal_info); 319 } 320 321 type_init(register_types)