[amt] / redir.c

/*
 *  Intel AMT tcp redirection protocol helper functions.
 *
 *  Copyright (C) 2007 Gerd Hoffmann <kraxel@redhat.com
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#include "tcp.h"
#include "redir.h"

static const char *state_name[] = {
    [ REDIR_NONE      ] = "NONE",
    [ REDIR_CONNECT   ] = "CONNECT",
    [ REDIR_INIT      ] = "INIT",
    [ REDIR_AUTH      ] = "AUTH",
    [ REDIR_INIT_SOL  ] = "INIT_SOL",
    [ REDIR_RUN_SOL   ] = "RUN_SOL",
    [ REDIR_INIT_IDER ] = "INIT_IDER",
    [ REDIR_RUN_IDER  ] = "RUN_IDER",
    [ REDIR_CLOSING   ] = "CLOSING",
    [ REDIR_CLOSED    ] = "CLOSED",
    [ REDIR_ERROR     ] = "ERROR",
};

static const char *state_desc[] = {
    [ REDIR_NONE      ] = "disconnected",
    [ REDIR_CONNECT   ] = "connection to host",
    [ REDIR_INIT      ] = "redirection initialization",
    [ REDIR_AUTH      ] = "session authentication",
    [ REDIR_INIT_SOL  ] = "serial-over-lan initialization",
    [ REDIR_RUN_SOL   ] = "serial-over-lan active",
    [ REDIR_INIT_IDER ] = "IDE redirect initialization",
    [ REDIR_RUN_IDER  ] = "IDE redirect active",
    [ REDIR_CLOSING   ] = "redirection shutdown",
    [ REDIR_CLOSED    ] = "connection closed",
    [ REDIR_ERROR     ] = "failure",
};

/* ------------------------------------------------------------------ */

static void hexdump(const char *prefix, const unsigned char *data, size_t size)
{
    char ascii[17];
    int i;

    for (i = 0; i < size; i++) {
	if (0 == (i%16)) {
	    fprintf(stderr,"%s%s%04x:",
		    prefix ? prefix : "",
		    prefix ? ": "   : "",
		    i);
	    memset(ascii,0,sizeof(ascii));
	}
	if (0 == (i%4))
	    fprintf(stderr," ");
	fprintf(stderr," %02x",data[i]);
	ascii[i%16] = isprint(data[i]) ? data[i] : '.';
	if (15 == (i%16))
	    fprintf(stderr,"  %s\n",ascii);
    }
    if (0 != (i%16)) {
	while (0 != (i%16)) {
	    if (0 == (i%4))
		fprintf(stderr," ");
	    fprintf(stderr,"   ");
	    i++;
	};
	fprintf(stderr," %s\n",ascii);
    }
}

static ssize_t redir_write(struct redir *r, const char *buf, size_t count)
{
    int rc;
    
    if (r->trace)
	hexdump("out", buf, count);
    rc = write(r->sock, buf, count);
    if (-1 == rc)
	snprintf(r->err, sizeof(r->err), "write(socket): %s", strerror(errno));
    return rc;
}

static void redir_state(struct redir *r, enum redir_state new)
{
    enum redir_state old = r->state;

    r->state = new;
    if (r->cb_state)
	r->cb_state(r->cb_data, old, new);
}

/* ------------------------------------------------------------------ */

const char *redir_state_name(enum redir_state state)
{
    const char *name = NULL;

    if (state < sizeof(state_name)/sizeof(state_name[0]))
	name = state_name[state];
    if (NULL == name)
	name = "unknown";
    return name;
}

const char *redir_state_desc(enum redir_state state)
{
    const char *desc = NULL;

    if (state < sizeof(state_desc)/sizeof(state_desc[0]))
	desc = state_desc[state];
    if (NULL == desc)
	desc = "unknown";
    return desc;
}

int redir_connect(struct redir *r)
{
    static unsigned char *defport = "16994";
    struct addrinfo ai;

    memset(&ai, 0, sizeof(ai));
    ai.ai_socktype = SOCK_STREAM;
    ai.ai_family = PF_UNSPEC;
    tcp_verbose = r->verbose;
    redir_state(r, REDIR_CONNECT);
    r->sock = tcp_connect(&ai, NULL, NULL, r->host,
			  strlen(r->port) ? r->port : defport);
    if (-1 == r->sock) {
	redir_state(r, REDIR_ERROR);
	return -1;
    }
    return 0;
}

int redir_start(struct redir *r)
{
    unsigned char request[START_REDIRECTION_SESSION_LENGTH] = {
	START_REDIRECTION_SESSION, 0, 0, 0,  0, 0, 0, 0
    };

    memcpy(request+4, r->type, 4);
    redir_state(r, REDIR_INIT);
    return redir_write(r, request, sizeof(request));
}

int redir_stop(struct redir *r)
{
    unsigned char request[END_REDIRECTION_SESSION_LENGTH] = {
	END_REDIRECTION_SESSION, 0, 0, 0
    };

    redir_state(r, REDIR_CLOSED);
    redir_write(r, request, sizeof(request));
    close(r->sock);
    return 0;
}

int redir_auth(struct redir *r)
{
    int ulen = strlen(r->user);
    int plen = strlen(r->pass);
    int len = 11+ulen+plen;
    int rc;
    unsigned char *request = malloc(len);

    memset(request, 0, len);
    request[0] = AUTHENTICATE_SESSION;
    request[4] = 0x01;
    request[5] = ulen+plen+2;
    request[9] = ulen;
    memcpy(request + 10, r->user, ulen);
    request[10 + ulen] = plen;
    memcpy(request + 11 + ulen, r->pass, plen);
    redir_state(r, REDIR_AUTH);
    rc = redir_write(r, request, len);
    free(request);
    return rc;
}

int redir_sol_start(struct redir *r)
{
    unsigned char request[START_SOL_REDIRECTION_LENGTH] = {
	START_SOL_REDIRECTION, 0, 0, 0,
	0, 0, 0, 0,
	MAX_TRANSMIT_BUFFER & 0xff,
	MAX_TRANSMIT_BUFFER >> 8,
	TRANSMIT_BUFFER_TIMEOUT & 0xff,
	TRANSMIT_BUFFER_TIMEOUT >> 8,
	TRANSMIT_OVERFLOW_TIMEOUT & 0xff,	TRANSMIT_OVERFLOW_TIMEOUT >> 8,
	HOST_SESSION_RX_TIMEOUT & 0xff,
	HOST_SESSION_RX_TIMEOUT >> 8,
	HOST_FIFO_RX_FLUSH_TIMEOUT & 0xff,
	HOST_FIFO_RX_FLUSH_TIMEOUT >> 8,
	HEARTBEAT_INTERVAL & 0xff,
	HEARTBEAT_INTERVAL >> 8,
	0, 0, 0, 0
    };

    redir_state(r, REDIR_INIT_SOL);
    return redir_write(r, request, sizeof(request));
}

int redir_sol_stop(struct redir *r)
{
    unsigned char request[END_SOL_REDIRECTION_LENGTH] = {
	END_SOL_REDIRECTION, 0, 0, 0,
	0, 0, 0, 0,
    };

    redir_state(r, REDIR_CLOSING);
    return redir_write(r, request, sizeof(request));
}

int redir_sol_send(struct redir *r, unsigned char *buf, int blen)
{
    int len = 10+blen;
    int rc;
    int i;
    unsigned char *request;

    for (i = 0; i < blen; i++) {
    	if (buf[i] == 0x0a)
		buf[i] = 0x0d;
    }

    request = malloc(len);
    if (!request) {
    	return -1;
    }

    memset(request, 0, len);
    request[0] = SOL_DATA_TO_HOST;
    request[8] = blen & 0xff;
    request[9] = blen >> 8;
    memcpy(request + 10, buf, blen);
    rc = redir_write(r, request, len);
    free(request);
    return rc;
}

int redir_sol_recv(struct redir *r)
{
    unsigned char msg[64];
    int count, len, bshift;

    len = r->buf[8] + (r->buf[9] << 8);
    count = r->blen - 10;
    if (count > len)
	count = len;
    bshift = count + 10;
    if (r->cb_recv)
	r->cb_recv(r->cb_data, r->buf + 10, count);
    len -= count;

    while (len) {
	if (r->trace)
	    fprintf(stderr, "in+: need %d more data bytes\n", len);
	count = sizeof(msg);
	if (count > len)
	    count = len;
	count = read(r->sock, msg, count);
	switch (count) {
	case -1:
	    snprintf(r->err, sizeof(r->err), "read(socket): %s", strerror(errno));
	    return -1;
	case 0:
	    snprintf(r->err, sizeof(r->err), "EOF from socket");
	    return -1;
	default:
	    if (r->trace)
		hexdump("in+", msg, count);
	    if (r->cb_recv)
		r->cb_recv(r->cb_data, msg, count);
	    len -= count;
	}
    }

    return bshift;
}

int redir_data(struct redir *r)
{
    int rc, bshift;

    if (r->trace) {
	fprintf(stderr, "in --\n");
	if (r->blen)
	    fprintf(stderr, "in : already have %d\n", r->blen);
    }
    rc = read(r->sock, r->buf + r->blen, sizeof(r->buf) - r->blen);
    switch (rc) {
    case -1:
	snprintf(r->err, sizeof(r->err), "read(socket): %s", strerror(errno));
	goto err;
    case 0:
	snprintf(r->err, sizeof(r->err), "EOF from socket");
	goto err;
    default:
	if (r->trace)
	    hexdump("in ", r->buf + r->blen, rc);
	r->blen += rc;
    }

    for (;;) {
	if (r->blen < 4)
	    goto again;
	bshift = 0;

	switch (r->buf[0]) {
	case START_REDIRECTION_SESSION_REPLY:
	    bshift = START_REDIRECTION_SESSION_REPLY_LENGTH;
	    if (r->blen < bshift)
		goto again;
	    if (r->buf[1] != STATUS_SUCCESS) {
		snprintf(r->err, sizeof(r->err), "redirection session start failed");
		goto err;
	    }
	    if (-1 == redir_auth(r))
		goto err;
	    break;
	case AUTHENTICATE_SESSION_REPLY:
	    bshift = r->blen; /* FIXME */
	    if (r->blen < bshift)
		goto again;
	    if (r->buf[1] != STATUS_SUCCESS) {
		snprintf(r->err, sizeof(r->err), "session authentication failed");
		goto err;
	    }
	    if (-1 == redir_sol_start(r))
		goto err;
	    break;
	case START_SOL_REDIRECTION_REPLY:
	    bshift = r->blen; /* FIXME */
	    if (r->blen < bshift)
		goto again;
	    if (r->buf[1] != STATUS_SUCCESS) {
		snprintf(r->err, sizeof(r->err), "serial-over-lan redirection failed");
		goto err;
	    }
	    redir_state(r, REDIR_RUN_SOL);
	    break;
	case SOL_HEARTBEAT:
	case SOL_KEEP_ALIVE_PING:
	case IDER_HEARTBEAT:
	case IDER_KEEP_ALIVE_PING:
	    bshift = HEARTBEAT_LENGTH;
	    if (r->blen < bshift)
		goto again;
	    if (HEARTBEAT_LENGTH != redir_write(r, r->buf, HEARTBEAT_LENGTH))
		goto err;
	    break;
	case SOL_DATA_FROM_HOST:
	    if (r->blen < 10) /* header length */
		goto again;
	    bshift = redir_sol_recv(r);
	    if (bshift < 0)
		goto err;
	    break;
	case END_SOL_REDIRECTION_REPLY:
	    bshift = r->blen; /* FIXME */
	    if (r->blen < bshift)
		goto again;
	    redir_stop(r);
	    break;
	default:
	    snprintf(r->err, sizeof(r->err), "%s: unknown r->buf 0x%02x",
		     __FUNCTION__, r->buf[0]);
	    goto err;
	}

	if (bshift == r->blen) {
	    r->blen = 0;
	    break;
	}

	/* have more data, shift by bshift */
	if (r->trace)
	    fprintf(stderr, "in : shift by %d\n", bshift);
	memmove(r->buf, r->buf + bshift, r->blen - bshift);
	r->blen -= bshift;
    }
    return 0;

again:
    /* need more data, jump back into poll/select loop */
    if (r->trace)
	fprintf(stderr, "in : need more data\n");
    return 0;

err:
    if (r->trace)
	fprintf(stderr, "in : ERROR (%s)\n", r->err);
    redir_state(r, REDIR_ERROR);
    close(r->sock);
    return -1;
}
Commit	Line	Data
402f63cd MG	1	/*
	2	* Intel AMT tcp redirection protocol helper functions.
	3	*
	4	* Copyright (C) 2007 Gerd Hoffmann <kraxel@redhat.com
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; if not, write to the Free Software Foundation, Inc.,
	18	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19	*/
	20
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <unistd.h>
	24	#include <string.h>
	25	#include <ctype.h>
	26	#include <errno.h>
	27
	28	#include "tcp.h"
	29	#include "redir.h"
	30
	31	static const char *state_name[] = {
	32	[ REDIR_NONE ] = "NONE",
	33	[ REDIR_CONNECT ] = "CONNECT",
	34	[ REDIR_INIT ] = "INIT",
	35	[ REDIR_AUTH ] = "AUTH",
	36	[ REDIR_INIT_SOL ] = "INIT_SOL",
	37	[ REDIR_RUN_SOL ] = "RUN_SOL",
	38	[ REDIR_INIT_IDER ] = "INIT_IDER",
	39	[ REDIR_RUN_IDER ] = "RUN_IDER",
	40	[ REDIR_CLOSING ] = "CLOSING",
	41	[ REDIR_CLOSED ] = "CLOSED",
	42	[ REDIR_ERROR ] = "ERROR",
	43	};
	44
	45	static const char *state_desc[] = {
	46	[ REDIR_NONE ] = "disconnected",
	47	[ REDIR_CONNECT ] = "connection to host",
	48	[ REDIR_INIT ] = "redirection initialization",
	49	[ REDIR_AUTH ] = "session authentication",
	50	[ REDIR_INIT_SOL ] = "serial-over-lan initialization",
	51	[ REDIR_RUN_SOL ] = "serial-over-lan active",
	52	[ REDIR_INIT_IDER ] = "IDE redirect initialization",
	53	[ REDIR_RUN_IDER ] = "IDE redirect active",
	54	[ REDIR_CLOSING ] = "redirection shutdown",
	55	[ REDIR_CLOSED ] = "connection closed",
	56	[ REDIR_ERROR ] = "failure",
	57	};
	58
	59	/* ------------------------------------------------------------------ */
	60
	61	static void hexdump(const char prefix, const unsigned char data, size_t size)
	62	{
	63	char ascii[17];
	64	int i;
65
66	for (i = 0; i < size; i++) {
67	if (0 == (i%16)) {
68	fprintf(stderr,"%s%s%04x:",
69	prefix ? prefix : "",
70	prefix ? ": " : "",
71	i);
72	memset(ascii,0,sizeof(ascii));
73	}
74	if (0 == (i%4))
75	fprintf(stderr," ");
76	fprintf(stderr," %02x",data[i]);
77	ascii[i%16] = isprint(data[i]) ? data[i] : '.';
78	if (15 == (i%16))
79	fprintf(stderr," %s\n",ascii);
80	}
81	if (0 != (i%16)) {
82	while (0 != (i%16)) {
83	if (0 == (i%4))
84	fprintf(stderr," ");
85	fprintf(stderr," ");
86	i++;
87	};
88	fprintf(stderr," %s\n",ascii);
89	}
90	}
91
92	static ssize_t redir_write(struct redir r, const char buf, size_t count)
93	{
94	int rc;
95
96	if (r->trace)
97	hexdump("out", buf, count);
98	rc = write(r->sock, buf, count);
99	if (-1 == rc)
100	snprintf(r->err, sizeof(r->err), "write(socket): %s", strerror(errno));
101	return rc;
102	}
103
104	static void redir_state(struct redir *r, enum redir_state new)
105	{
106	enum redir_state old = r->state;
107
108	r->state = new;
109	if (r->cb_state)
110	r->cb_state(r->cb_data, old, new);
111	}
112
113	/* ------------------------------------------------------------------ */
114
115	const char *redir_state_name(enum redir_state state)
116	{
117	const char *name = NULL;
118
119	if (state < sizeof(state_name)/sizeof(state_name[0]))
120	name = state_name[state];
121	if (NULL == name)
122	name = "unknown";
123	return name;
124	}
125
126	const char *redir_state_desc(enum redir_state state)
127	{
128	const char *desc = NULL;
129
130	if (state < sizeof(state_desc)/sizeof(state_desc[0]))
131	desc = state_desc[state];
132	if (NULL == desc)
133	desc = "unknown";
134	return desc;
135	}
136
137	int redir_connect(struct redir *r)
138	{
139	static unsigned char *defport = "16994";
140	struct addrinfo ai;
141
142	memset(&ai, 0, sizeof(ai));
143	ai.ai_socktype = SOCK_STREAM;
144	ai.ai_family = PF_UNSPEC;
145	tcp_verbose = r->verbose;
146	redir_state(r, REDIR_CONNECT);
147	r->sock = tcp_connect(&ai, NULL, NULL, r->host,
148	strlen(r->port) ? r->port : defport);
149	if (-1 == r->sock) {
150	redir_state(r, REDIR_ERROR);
151	return -1;
152	}
153	return 0;
154	}
155
156	int redir_start(struct redir *r)
157	{
158	unsigned char request[START_REDIRECTION_SESSION_LENGTH] = {
159	START_REDIRECTION_SESSION, 0, 0, 0, 0, 0, 0, 0
160	};
161
162	memcpy(request+4, r->type, 4);
163	redir_state(r, REDIR_INIT);
164	return redir_write(r, request, sizeof(request));
165	}
166
167	int redir_stop(struct redir *r)
168	{
169	unsigned char request[END_REDIRECTION_SESSION_LENGTH] = {
170	END_REDIRECTION_SESSION, 0, 0, 0
171	};
172
173	redir_state(r, REDIR_CLOSED);
174	redir_write(r, request, sizeof(request));
175	close(r->sock);
176	return 0;
177	}
178
179	int redir_auth(struct redir *r)
180	{
181	int ulen = strlen(r->user);
182	int plen = strlen(r->pass);
183	int len = 11+ulen+plen;
184	int rc;
185	unsigned char *request = malloc(len);
186
187	memset(request, 0, len);
188	request[0] = AUTHENTICATE_SESSION;
189	request[4] = 0x01;
190	request[5] = ulen+plen+2;
191	request[9] = ulen;
192	memcpy(request + 10, r->user, ulen);
193	request[10 + ulen] = plen;
194	memcpy(request + 11 + ulen, r->pass, plen);
195	redir_state(r, REDIR_AUTH);
196	rc = redir_write(r, request, len);
197	free(request);
198	return rc;
199	}
200
201	int redir_sol_start(struct redir *r)
202	{
203	unsigned char request[START_SOL_REDIRECTION_LENGTH] = {
204	START_SOL_REDIRECTION, 0, 0, 0,
205	0, 0, 0, 0,
206	MAX_TRANSMIT_BUFFER & 0xff,
207	MAX_TRANSMIT_BUFFER >> 8,
208	TRANSMIT_BUFFER_TIMEOUT & 0xff,
209	TRANSMIT_BUFFER_TIMEOUT >> 8,
210	TRANSMIT_OVERFLOW_TIMEOUT & 0xff, TRANSMIT_OVERFLOW_TIMEOUT >> 8,
211	HOST_SESSION_RX_TIMEOUT & 0xff,
212	HOST_SESSION_RX_TIMEOUT >> 8,
213	HOST_FIFO_RX_FLUSH_TIMEOUT & 0xff,
214	HOST_FIFO_RX_FLUSH_TIMEOUT >> 8,
215	HEARTBEAT_INTERVAL & 0xff,
216	HEARTBEAT_INTERVAL >> 8,
217	0, 0, 0, 0
218	};
219
220	redir_state(r, REDIR_INIT_SOL);
221	return redir_write(r, request, sizeof(request));
222	}
223
224	int redir_sol_stop(struct redir *r)
225	{
226	unsigned char request[END_SOL_REDIRECTION_LENGTH] = {
227	END_SOL_REDIRECTION, 0, 0, 0,
228	0, 0, 0, 0,
229	};
230
231	redir_state(r, REDIR_CLOSING);
232	return redir_write(r, request, sizeof(request));
233	}
234
235	int redir_sol_send(struct redir r, unsigned char buf, int blen)
236	{
237	int len = 10+blen;
238	int rc;
0ddcc0c9	239	int i;
bdb412f7 MG	240	unsigned char *request;
	241
	242	for (i = 0; i < blen; i++) {
	243	if (buf[i] == 0x0a)
0ddcc0c9	244	buf[i] = 0x0d;
bdb412f7 MG	245	}
	246
	247	request = malloc(len);
0ddcc0c9 MG	248	if (!request) {
	249	return -1;
	250	}
402f63cd MG	251
	252	memset(request, 0, len);
	253	request[0] = SOL_DATA_TO_HOST;
0ddcc0c9 MG	254	request[8] = blen & 0xff;
	255	request[9] = blen >> 8;
	256	memcpy(request + 10, buf, blen);
402f63cd MG	257	rc = redir_write(r, request, len);
	258	free(request);
	259	return rc;
	260	}
	261
	262	int redir_sol_recv(struct redir *r)
	263	{
	264	unsigned char msg[64];
	265	int count, len, bshift;
	266
	267	len = r->buf[8] + (r->buf[9] << 8);
	268	count = r->blen - 10;
	269	if (count > len)
	270	count = len;
	271	bshift = count + 10;
	272	if (r->cb_recv)
	273	r->cb_recv(r->cb_data, r->buf + 10, count);
	274	len -= count;
	275
	276	while (len) {
	277	if (r->trace)
	278	fprintf(stderr, "in+: need %d more data bytes\n", len);
	279	count = sizeof(msg);
	280	if (count > len)
	281	count = len;
	282	count = read(r->sock, msg, count);
	283	switch (count) {
	284	case -1:
	285	snprintf(r->err, sizeof(r->err), "read(socket): %s", strerror(errno));
	286	return -1;
	287	case 0:
	288	snprintf(r->err, sizeof(r->err), "EOF from socket");
	289	return -1;
	290	default:
	291	if (r->trace)
	292	hexdump("in+", msg, count);
	293	if (r->cb_recv)
	294	r->cb_recv(r->cb_data, msg, count);
	295	len -= count;
	296	}
	297	}
	298
	299	return bshift;
	300	}
	301
	302	int redir_data(struct redir *r)
	303	{
	304	int rc, bshift;
	305
	306	if (r->trace) {
	307	fprintf(stderr, "in --\n");
	308	if (r->blen)
	309	fprintf(stderr, "in : already have %d\n", r->blen);
	310	}
	311	rc = read(r->sock, r->buf + r->blen, sizeof(r->buf) - r->blen);
	312	switch (rc) {
	313	case -1:
	314	snprintf(r->err, sizeof(r->err), "read(socket): %s", strerror(errno));
	315	goto err;
	316	case 0:
	317	snprintf(r->err, sizeof(r->err), "EOF from socket");
	318	goto err;
	319	default:
	320	if (r->trace)
321	hexdump("in ", r->buf + r->blen, rc);
322	r->blen += rc;
323	}
324
325	for (;;) {
326	if (r->blen < 4)
327	goto again;
328	bshift = 0;
329
330	switch (r->buf[0]) {
331	case START_REDIRECTION_SESSION_REPLY:
332	bshift = START_REDIRECTION_SESSION_REPLY_LENGTH;
333	if (r->blen < bshift)
334	goto again;
335	if (r->buf[1] != STATUS_SUCCESS) {
336	snprintf(r->err, sizeof(r->err), "redirection session start failed");
337	goto err;
338	}
339	if (-1 == redir_auth(r))
340	goto err;
341	break;
342	case AUTHENTICATE_SESSION_REPLY:
343	bshift = r->blen; /* FIXME */
344	if (r->blen < bshift)
345	goto again;
346	if (r->buf[1] != STATUS_SUCCESS) {
347	snprintf(r->err, sizeof(r->err), "session authentication failed");
348	goto err;
349	}
350	if (-1 == redir_sol_start(r))
351	goto err;
352	break;
353	case START_SOL_REDIRECTION_REPLY:
354	bshift = r->blen; /* FIXME */
355	if (r->blen < bshift)
356	goto again;
357	if (r->buf[1] != STATUS_SUCCESS) {
358	snprintf(r->err, sizeof(r->err), "serial-over-lan redirection failed");
359	goto err;
360	}
361	redir_state(r, REDIR_RUN_SOL);
362	break;
363	case SOL_HEARTBEAT:
364	case SOL_KEEP_ALIVE_PING:
365	case IDER_HEARTBEAT:
366	case IDER_KEEP_ALIVE_PING:
367	bshift = HEARTBEAT_LENGTH;
368	if (r->blen < bshift)
369	goto again;
370	if (HEARTBEAT_LENGTH != redir_write(r, r->buf, HEARTBEAT_LENGTH))
371	goto err;
372	break;
373	case SOL_DATA_FROM_HOST:
374	if (r->blen < 10) /* header length */
375	goto again;
376	bshift = redir_sol_recv(r);
377	if (bshift < 0)
378	goto err;
379	break;
380	case END_SOL_REDIRECTION_REPLY:
381	bshift = r->blen; /* FIXME */
382	if (r->blen < bshift)
383	goto again;
384	redir_stop(r);
385	break;
386	default:
387	snprintf(r->err, sizeof(r->err), "%s: unknown r->buf 0x%02x",
388	__FUNCTION__, r->buf[0]);
389	goto err;
390	}
391
392	if (bshift == r->blen) {
393	r->blen = 0;
394	break;
395	}
396
397	/* have more data, shift by bshift */
398	if (r->trace)
399	fprintf(stderr, "in : shift by %d\n", bshift);
400	memmove(r->buf, r->buf + bshift, r->blen - bshift);
401	r->blen -= bshift;
402	}
403	return 0;
404
405	again:
406	/* need more data, jump back into poll/select loop */
407	if (r->trace)
408	fprintf(stderr, "in : need more data\n");
409	return 0;
410
411	err:
412	if (r->trace)
413	fprintf(stderr, "in : ERROR (%s)\n", r->err);
414	redir_state(r, REDIR_ERROR);
415	close(r->sock);
416	return -1;
417	}