qemu

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)
322