opacket.c revision 296781 
1/* Written by Markus Friedl. Placed in the public domain.  */
2
3#include "includes.h"
4
5#include "ssherr.h"
6#include "packet.h"
7#include "log.h"
8
9struct ssh *active_state, *backup_state;
10
11/* Map old to new API */
12
13void
14ssh_packet_start(struct ssh *ssh, u_char type)
15{
16	int r;
17
18	if ((r = sshpkt_start(ssh, type)) != 0)
19		fatal("%s: %s", __func__, ssh_err(r));
20}
21
22void
23ssh_packet_put_char(struct ssh *ssh, int value)
24{
25	u_char ch = value;
26	int r;
27
28	if ((r = sshpkt_put_u8(ssh, ch)) != 0)
29		fatal("%s: %s", __func__, ssh_err(r));
30}
31
32void
33ssh_packet_put_int(struct ssh *ssh, u_int value)
34{
35	int r;
36
37	if ((r = sshpkt_put_u32(ssh, value)) != 0)
38		fatal("%s: %s", __func__, ssh_err(r));
39}
40
41void
42ssh_packet_put_int64(struct ssh *ssh, u_int64_t value)
43{
44	int r;
45
46	if ((r = sshpkt_put_u64(ssh, value)) != 0)
47		fatal("%s: %s", __func__, ssh_err(r));
48}
49
50void
51ssh_packet_put_string(struct ssh *ssh, const void *buf, u_int len)
52{
53	int r;
54
55	if ((r = sshpkt_put_string(ssh, buf, len)) != 0)
56		fatal("%s: %s", __func__, ssh_err(r));
57}
58
59void
60ssh_packet_put_cstring(struct ssh *ssh, const char *str)
61{
62	int r;
63
64	if ((r = sshpkt_put_cstring(ssh, str)) != 0)
65		fatal("%s: %s", __func__, ssh_err(r));
66}
67
68void
69ssh_packet_put_raw(struct ssh *ssh, const void *buf, u_int len)
70{
71	int r;
72
73	if ((r = sshpkt_put(ssh, buf, len)) != 0)
74		fatal("%s: %s", __func__, ssh_err(r));
75}
76
77#ifdef WITH_SSH1
78void
79ssh_packet_put_bignum(struct ssh *ssh, BIGNUM * value)
80{
81	int r;
82
83	if ((r = sshpkt_put_bignum1(ssh, value)) != 0)
84		fatal("%s: %s", __func__, ssh_err(r));
85}
86#endif
87
88#ifdef WITH_OPENSSL
89void
90ssh_packet_put_bignum2(struct ssh *ssh, BIGNUM * value)
91{
92	int r;
93
94	if ((r = sshpkt_put_bignum2(ssh, value)) != 0)
95		fatal("%s: %s", __func__, ssh_err(r));
96}
97
98# ifdef OPENSSL_HAS_ECC
99void
100ssh_packet_put_ecpoint(struct ssh *ssh, const EC_GROUP *curve,
101    const EC_POINT *point)
102{
103	int r;
104
105	if ((r = sshpkt_put_ec(ssh, point, curve)) != 0)
106		fatal("%s: %s", __func__, ssh_err(r));
107}
108# endif
109#endif /* WITH_OPENSSL */
110
111void
112ssh_packet_send(struct ssh *ssh)
113{
114	int r;
115
116	if ((r = sshpkt_send(ssh)) != 0)
117		fatal("%s: %s", __func__, ssh_err(r));
118}
119
120u_int
121ssh_packet_get_char(struct ssh *ssh)
122{
123	u_char ch;
124	int r;
125
126	if ((r = sshpkt_get_u8(ssh, &ch)) != 0)
127		fatal("%s: %s", __func__, ssh_err(r));
128	return ch;
129}
130
131u_int
132ssh_packet_get_int(struct ssh *ssh)
133{
134	u_int val;
135	int r;
136
137	if ((r = sshpkt_get_u32(ssh, &val)) != 0)
138		fatal("%s: %s", __func__, ssh_err(r));
139	return val;
140}
141
142u_int64_t
143ssh_packet_get_int64(struct ssh *ssh)
144{
145	u_int64_t val;
146	int r;
147
148	if ((r = sshpkt_get_u64(ssh, &val)) != 0)
149		fatal("%s: %s", __func__, ssh_err(r));
150	return val;
151}
152
153#ifdef WITH_SSH1
154void
155ssh_packet_get_bignum(struct ssh *ssh, BIGNUM * value)
156{
157	int r;
158
159	if ((r = sshpkt_get_bignum1(ssh, value)) != 0)
160		fatal("%s: %s", __func__, ssh_err(r));
161}
162#endif
163
164#ifdef WITH_OPENSSL
165void
166ssh_packet_get_bignum2(struct ssh *ssh, BIGNUM * value)
167{
168	int r;
169
170	if ((r = sshpkt_get_bignum2(ssh, value)) != 0)
171		fatal("%s: %s", __func__, ssh_err(r));
172}
173
174# ifdef OPENSSL_HAS_ECC
175void
176ssh_packet_get_ecpoint(struct ssh *ssh, const EC_GROUP *curve, EC_POINT *point)
177{
178	int r;
179
180	if ((r = sshpkt_get_ec(ssh, point, curve)) != 0)
181		fatal("%s: %s", __func__, ssh_err(r));
182}
183# endif
184#endif /* WITH_OPENSSL */
185
186void *
187ssh_packet_get_string(struct ssh *ssh, u_int *length_ptr)
188{
189	int r;
190	size_t len;
191	u_char *val;
192
193	if ((r = sshpkt_get_string(ssh, &val, &len)) != 0)
194		fatal("%s: %s", __func__, ssh_err(r));
195	if (length_ptr != NULL)
196		*length_ptr = (u_int)len;
197	return val;
198}
199
200const void *
201ssh_packet_get_string_ptr(struct ssh *ssh, u_int *length_ptr)
202{
203	int r;
204	size_t len;
205	const u_char *val;
206
207	if ((r = sshpkt_get_string_direct(ssh, &val, &len)) != 0)
208		fatal("%s: %s", __func__, ssh_err(r));
209	if (length_ptr != NULL)
210		*length_ptr = (u_int)len;
211	return val;
212}
213
214char *
215ssh_packet_get_cstring(struct ssh *ssh, u_int *length_ptr)
216{
217	int r;
218	size_t len;
219	char *val;
220
221	if ((r = sshpkt_get_cstring(ssh, &val, &len)) != 0)
222		fatal("%s: %s", __func__, ssh_err(r));
223	if (length_ptr != NULL)
224		*length_ptr = (u_int)len;
225	return val;
226}
227
228/* Old API, that had to be reimplemented */
229
230void
231packet_set_connection(int fd_in, int fd_out)
232{
233	active_state = ssh_packet_set_connection(active_state, fd_in, fd_out);
234	if (active_state == NULL)
235		fatal("%s: ssh_packet_set_connection failed", __func__);
236}
237
238u_int
239packet_get_char(void)
240{
241	return (ssh_packet_get_char(active_state));
242}
243
244u_int
245packet_get_int(void)
246{
247	return (ssh_packet_get_int(active_state));
248}
249
250int
251packet_read_seqnr(u_int32_t *seqnr)
252{
253	u_char type;
254	int r;
255
256	if ((r = ssh_packet_read_seqnr(active_state, &type, seqnr)) != 0)
257		sshpkt_fatal(active_state, __func__, r);
258	return type;
259}
260
261int
262packet_read_poll_seqnr(u_int32_t *seqnr)
263{
264	u_char type;
265	int r;
266
267	if ((r = ssh_packet_read_poll_seqnr(active_state, &type, seqnr)))
268		sshpkt_fatal(active_state, __func__, r);
269	return type;
270}
271
272void
273packet_close(void)
274{
275	ssh_packet_close(active_state);
276	active_state = NULL;
277}
278
279void
280packet_process_incoming(const char *buf, u_int len)
281{
282	int r;
283
284	if ((r = ssh_packet_process_incoming(active_state, buf, len)) != 0)
285		sshpkt_fatal(active_state, __func__, r);
286}
287
288void
289packet_write_wait(void)
290{
291	int r;
292
293	if ((r = ssh_packet_write_wait(active_state)) != 0)
294		sshpkt_fatal(active_state, __func__, r);
295}
296
297void
298packet_write_poll(void)
299{
300	int r;
301
302	if ((r = ssh_packet_write_poll(active_state)) != 0)
303		sshpkt_fatal(active_state, __func__, r);
304}
305
306void
307packet_read_expect(int expected_type)
308{
309	int r;
310
311	if ((r = ssh_packet_read_expect(active_state, expected_type)) != 0)
312		sshpkt_fatal(active_state, __func__, r);
313}
314
315void
316packet_disconnect(const char *fmt, ...)
317{
318	char buf[1024];
319	va_list args;
320
321	va_start(args, fmt);
322	vsnprintf(buf, sizeof(buf), fmt, args);
323	va_end(args);
324	ssh_packet_disconnect(active_state, "%s", buf);
325}
326
327void
328packet_send_debug(const char *fmt, ...)
329{
330	char buf[1024];
331	va_list args;
332
333	va_start(args, fmt);
334	vsnprintf(buf, sizeof(buf), fmt, args);
335	va_end(args);
336	ssh_packet_send_debug(active_state, "%s", buf);
337}
338