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 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 #ifdef WITH_SSH1 78 void 79 ssh_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 89 void 90 ssh_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 99 void 100 ssh_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 111 void 112 ssh_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 120 u_int 121 ssh_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 131 u_int 132 ssh_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 142 u_int64_t 143 ssh_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 154 void 155 ssh_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 165 void 166 ssh_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 175 void 176 ssh_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 186 void * 187 ssh_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 200 const void * 201 ssh_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 214 char * 215 ssh_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 230 void 231 packet_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 238 void 239 packet_backup_state(void) 240 { 241 ssh_packet_backup_state(active_state, backup_state); 242 } 243 244 void 245 packet_restore_state(void) 246 { 247 ssh_packet_restore_state(active_state, backup_state); 248 } 249 250 u_int 251 packet_get_char(void) 252 { 253 return (ssh_packet_get_char(active_state)); 254 } 255 256 u_int 257 packet_get_int(void) 258 { 259 return (ssh_packet_get_int(active_state)); 260 } 261 262 int 263 packet_read_seqnr(u_int32_t *seqnr) 264 { 265 u_char type; 266 int r; 267 268 if ((r = ssh_packet_read_seqnr(active_state, &type, seqnr)) != 0) 269 sshpkt_fatal(active_state, __func__, r); 270 return type; 271 } 272 273 int 274 packet_read_poll_seqnr(u_int32_t *seqnr) 275 { 276 u_char type; 277 int r; 278 279 if ((r = ssh_packet_read_poll_seqnr(active_state, &type, seqnr))) 280 sshpkt_fatal(active_state, __func__, r); 281 return type; 282 } 283 284 void 285 packet_close(void) 286 { 287 ssh_packet_close(active_state); 288 active_state = NULL; 289 } 290 291 void 292 packet_process_incoming(const char *buf, u_int len) 293 { 294 int r; 295 296 if ((r = ssh_packet_process_incoming(active_state, buf, len)) != 0) 297 sshpkt_fatal(active_state, __func__, r); 298 } 299 300 void 301 packet_write_wait(void) 302 { 303 int r; 304 305 if ((r = ssh_packet_write_wait(active_state)) != 0) 306 sshpkt_fatal(active_state, __func__, r); 307 } 308 309 void 310 packet_write_poll(void) 311 { 312 int r; 313 314 if ((r = ssh_packet_write_poll(active_state)) != 0) 315 sshpkt_fatal(active_state, __func__, r); 316 } 317 318 void 319 packet_read_expect(int expected_type) 320 { 321 int r; 322 323 if ((r = ssh_packet_read_expect(active_state, expected_type)) != 0) 324 sshpkt_fatal(active_state, __func__, r); 325 } 326 327 void 328 packet_disconnect(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_disconnect(active_state, "%s", buf); 337 } 338 339 void 340 packet_send_debug(const char *fmt, ...) 341 { 342 char buf[1024]; 343 va_list args; 344 345 va_start(args, fmt); 346 vsnprintf(buf, sizeof(buf), fmt, args); 347 va_end(args); 348 ssh_packet_send_debug(active_state, "%s", buf); 349 } 350
