![[BACK]](/icons/back.gif){kind=icon}
Return to opacket.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / ssh|
Return to opacket.c CVS log | Up to [local] / src / usr.bin / ssh |
1.9 ! djm 1: /* $OpenBSD: opacket.c,v 1.8 2019/01/19 21:31:32 djm Exp $ */
1.1 markus 2: /* Written by Markus Friedl. Placed in the public domain. */
3:
4: #include "ssherr.h"
5: #include "packet.h"
1.8 djm 6: #include "opacket.h" /* XXX */
1.1 markus 7: #include "log.h"
8:
9: struct ssh *active_state, *backup_state;
10:
11: /* Map old to new API */
12:
13: void
14: ssh_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:
22: void
23: ssh_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:
32: void
33: ssh_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:
41: void
42: ssh_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:
50: void
51: ssh_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:
59: void
60: ssh_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:
68: void
69: ssh_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:
1.4 djm 78: #ifdef WITH_OPENSSL
1.1 markus 79: void
80: ssh_packet_put_bignum2(struct ssh *ssh, BIGNUM * value)
81: {
82: int r;
83:
84: if ((r = sshpkt_put_bignum2(ssh, value)) != 0)
85: fatal("%s: %s", __func__, ssh_err(r));
86: }
87:
88: void
89: ssh_packet_put_ecpoint(struct ssh *ssh, const EC_GROUP *curve,
90: const EC_POINT *point)
91: {
92: int r;
93:
94: if ((r = sshpkt_put_ec(ssh, point, curve)) != 0)
95: fatal("%s: %s", __func__, ssh_err(r));
96: }
97: #endif /* WITH_OPENSSL */
98:
99: void
100: ssh_packet_send(struct ssh *ssh)
101: {
102: int r;
103:
104: if ((r = sshpkt_send(ssh)) != 0)
105: fatal("%s: %s", __func__, ssh_err(r));
106: }
107:
108: u_int
109: ssh_packet_get_char(struct ssh *ssh)
110: {
111: u_char ch;
112: int r;
113:
114: if ((r = sshpkt_get_u8(ssh, &ch)) != 0)
115: fatal("%s: %s", __func__, ssh_err(r));
116: return ch;
117: }
118:
119: u_int
120: ssh_packet_get_int(struct ssh *ssh)
121: {
122: u_int val;
123: int r;
124:
125: if ((r = sshpkt_get_u32(ssh, &val)) != 0)
126: fatal("%s: %s", __func__, ssh_err(r));
127: return val;
128: }
129:
130: u_int64_t
131: ssh_packet_get_int64(struct ssh *ssh)
132: {
133: u_int64_t val;
134: int r;
135:
136: if ((r = sshpkt_get_u64(ssh, &val)) != 0)
137: fatal("%s: %s", __func__, ssh_err(r));
138: return val;
139: }
140:
141:
1.4 djm 142: #ifdef WITH_OPENSSL
1.1 markus 143: void
144: ssh_packet_get_bignum2(struct ssh *ssh, BIGNUM * value)
145: {
146: int r;
147:
148: if ((r = sshpkt_get_bignum2(ssh, value)) != 0)
149: fatal("%s: %s", __func__, ssh_err(r));
150: }
151:
152: void
153: ssh_packet_get_ecpoint(struct ssh *ssh, const EC_GROUP *curve, EC_POINT *point)
154: {
155: int r;
156:
157: if ((r = sshpkt_get_ec(ssh, point, curve)) != 0)
158: fatal("%s: %s", __func__, ssh_err(r));
159: }
160: #endif /* WITH_OPENSSL */
161:
162: void *
163: ssh_packet_get_string(struct ssh *ssh, u_int *length_ptr)
164: {
165: int r;
166: size_t len;
167: u_char *val;
168:
169: if ((r = sshpkt_get_string(ssh, &val, &len)) != 0)
170: fatal("%s: %s", __func__, ssh_err(r));
171: if (length_ptr != NULL)
172: *length_ptr = (u_int)len;
173: return val;
174: }
175:
176: const void *
177: ssh_packet_get_string_ptr(struct ssh *ssh, u_int *length_ptr)
178: {
179: int r;
180: size_t len;
181: const u_char *val;
182:
183: if ((r = sshpkt_get_string_direct(ssh, &val, &len)) != 0)
184: fatal("%s: %s", __func__, ssh_err(r));
185: if (length_ptr != NULL)
186: *length_ptr = (u_int)len;
187: return val;
188: }
189:
190: char *
191: ssh_packet_get_cstring(struct ssh *ssh, u_int *length_ptr)
192: {
193: int r;
194: size_t len;
195: char *val;
196:
197: if ((r = sshpkt_get_cstring(ssh, &val, &len)) != 0)
198: fatal("%s: %s", __func__, ssh_err(r));
199: if (length_ptr != NULL)
200: *length_ptr = (u_int)len;
201: return val;
202: }
203:
204: /* Old API, that had to be reimplemented */
205:
206: void
207: packet_set_connection(int fd_in, int fd_out)
208: {
209: active_state = ssh_packet_set_connection(active_state, fd_in, fd_out);
1.3 djm 210: if (active_state == NULL)
211: fatal("%s: ssh_packet_set_connection failed", __func__);
1.1 markus 212: }
213:
214: u_int
215: packet_get_char(void)
216: {
217: return (ssh_packet_get_char(active_state));
218: }
219:
220: u_int
221: packet_get_int(void)
222: {
223: return (ssh_packet_get_int(active_state));
224: }
225:
226: int
227: packet_read_seqnr(u_int32_t *seqnr)
228: {
229: u_char type;
230: int r;
231:
1.3 djm 232: if ((r = ssh_packet_read_seqnr(active_state, &type, seqnr)) != 0)
1.9 ! djm 233: sshpkt_fatal(active_state, r, "%s", __func__);
1.1 markus 234: return type;
235: }
236:
237: int
238: packet_read_poll_seqnr(u_int32_t *seqnr)
239: {
240: u_char type;
241: int r;
242:
243: if ((r = ssh_packet_read_poll_seqnr(active_state, &type, seqnr)))
1.9 ! djm 244: sshpkt_fatal(active_state, r, "%s", __func__);
1.1 markus 245: return type;
246: }
247:
248: void
249: packet_close(void)
250: {
251: ssh_packet_close(active_state);
252: active_state = NULL;
1.2 djm 253: }
254:
255: void
256: packet_process_incoming(const char *buf, u_int len)
257: {
258: int r;
259:
260: if ((r = ssh_packet_process_incoming(active_state, buf, len)) != 0)
1.9 ! djm 261: sshpkt_fatal(active_state, r, "%s", __func__);
1.3 djm 262: }
263:
264: void
265: packet_write_wait(void)
266: {
267: int r;
268:
269: if ((r = ssh_packet_write_wait(active_state)) != 0)
1.9 ! djm 270: sshpkt_fatal(active_state, r, "%s", __func__);
1.3 djm 271: }
272:
273: void
274: packet_write_poll(void)
275: {
276: int r;
277:
278: if ((r = ssh_packet_write_poll(active_state)) != 0)
1.9 ! djm 279: sshpkt_fatal(active_state, r, "%s", __func__);
1.3 djm 280: }
281:
282: void
283: packet_read_expect(int expected_type)
284: {
285: int r;
286:
287: if ((r = ssh_packet_read_expect(active_state, expected_type)) != 0)
1.9 ! djm 288: sshpkt_fatal(active_state, r, "%s", __func__);
1.1 markus 289: }