1 /* $OpenBSD: authfd.c,v 1.86 2011/07/06 18:09:21 tedu Exp $ */ 2 /* 3 * Author: Tatu Ylonen <ylo@cs.hut.fi> 4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland 5 * All rights reserved 6 * Functions for connecting the local authentication agent. 7 * 8 * As far as I am concerned, the code I have written for this software 9 * can be used freely for any purpose. Any derived versions of this 10 * software must be clearly marked as such, and if the derived work is 11 * incompatible with the protocol description in the RFC file, it must be 12 * called by a name other than "ssh" or "Secure Shell". 13 * 14 * SSH2 implementation, 15 * Copyright (c) 2000 Markus Friedl. All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions 19 * are met: 20 * 1. Redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer. 22 * 2. Redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 27 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 28 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 29 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 30 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 31 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 39 #include <sys/types.h> 40 #include <sys/un.h> 41 #include <sys/socket.h> 42 43 #include <openssl/evp.h> 44 45 #include <openssl/crypto.h> 46 #include <fcntl.h> 47 #include <stdlib.h> 48 #include <signal.h> 49 #include <string.h> 50 #include <unistd.h> 51 52 #include "xmalloc.h" 53 #include "ssh.h" 54 #include "rsa.h" 55 #include "buffer.h" 56 #include "key.h" 57 #include "authfd.h" 58 #include "cipher.h" 59 #include "kex.h" 60 #include "compat.h" 61 #include "log.h" 62 #include "atomicio.h" 63 #include "misc.h" 64 65 static int agent_present = 0; 66 67 /* helper */ 68 int decode_reply(int type); 69 70 /* macro to check for "agent failure" message */ 71 #define agent_failed(x) \ 72 ((x == SSH_AGENT_FAILURE) || (x == SSH_COM_AGENT2_FAILURE) || \ 73 (x == SSH2_AGENT_FAILURE)) 74 75 int 76 ssh_agent_present(void) 77 { 78 int authfd; 79 80 if (agent_present) 81 return 1; 82 if ((authfd = ssh_get_authentication_socket()) == -1) 83 return 0; 84 else { 85 ssh_close_authentication_socket(authfd); 86 return 1; 87 } 88 } 89 90 /* Returns the number of the authentication fd, or -1 if there is none. */ 91 92 int 93 ssh_get_authentication_socket(void) 94 { 95 const char *authsocket; 96 int sock; 97 struct sockaddr_un sunaddr; 98 99 authsocket = getenv(SSH_AUTHSOCKET_ENV_NAME); 100 if (!authsocket) 101 return -1; 102 103 bzero(&sunaddr, sizeof(sunaddr)); 104 sunaddr.sun_family = AF_UNIX; 105 strlcpy(sunaddr.sun_path, authsocket, sizeof(sunaddr.sun_path)); 106 107 sock = socket(AF_UNIX, SOCK_STREAM, 0); 108 if (sock < 0) 109 return -1; 110 111 /* close on exec */ 112 if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) { 113 close(sock); 114 return -1; 115 } 116 if (connect(sock, (struct sockaddr *)&sunaddr, sizeof sunaddr) < 0) { 117 close(sock); 118 return -1; 119 } 120 agent_present = 1; 121 return sock; 122 } 123 124 static int 125 ssh_request_reply(AuthenticationConnection *auth, Buffer *request, Buffer *reply) 126 { 127 u_int l, len; 128 char buf[1024]; 129 130 /* Get the length of the message, and format it in the buffer. */ 131 len = buffer_len(request); 132 put_u32(buf, len); 133 134 /* Send the length and then the packet to the agent. */ 135 if (atomicio(vwrite, auth->fd, buf, 4) != 4 || 136 atomicio(vwrite, auth->fd, buffer_ptr(request), 137 buffer_len(request)) != buffer_len(request)) { 138 error("Error writing to authentication socket."); 139 return 0; 140 } 141 /* 142 * Wait for response from the agent. First read the length of the 143 * response packet. 144 */ 145 if (atomicio(read, auth->fd, buf, 4) != 4) { 146 error("Error reading response length from authentication socket."); 147 return 0; 148 } 149 150 /* Extract the length, and check it for sanity. */ 151 len = get_u32(buf); 152 if (len > 256 * 1024) 153 fatal("Authentication response too long: %u", len); 154 155 /* Read the rest of the response in to the buffer. */ 156 buffer_clear(reply); 157 while (len > 0) { 158 l = len; 159 if (l > sizeof(buf)) 160 l = sizeof(buf); 161 if (atomicio(read, auth->fd, buf, l) != l) { 162 error("Error reading response from authentication socket."); 163 return 0; 164 } 165 buffer_append(reply, buf, l); 166 len -= l; 167 } 168 return 1; 169 } 170 171 /* 172 * Closes the agent socket if it should be closed (depends on how it was 173 * obtained). The argument must have been returned by 174 * ssh_get_authentication_socket(). 175 */ 176 177 void 178 ssh_close_authentication_socket(int sock) 179 { 180 if (getenv(SSH_AUTHSOCKET_ENV_NAME)) 181 close(sock); 182 } 183 184 /* 185 * Opens and connects a private socket for communication with the 186 * authentication agent. Returns the file descriptor (which must be 187 * shut down and closed by the caller when no longer needed). 188 * Returns NULL if an error occurred and the connection could not be 189 * opened. 190 */ 191 192 AuthenticationConnection * 193 ssh_get_authentication_connection(void) 194 { 195 AuthenticationConnection *auth; 196 int sock; 197 198 sock = ssh_get_authentication_socket(); 199 200 /* 201 * Fail if we couldn't obtain a connection. This happens if we 202 * exited due to a timeout. 203 */ 204 if (sock < 0) 205 return NULL; 206 207 auth = xmalloc(sizeof(*auth)); 208 auth->fd = sock; 209 buffer_init(&auth->identities); 210 auth->howmany = 0; 211 212 return auth; 213 } 214 215 /* 216 * Closes the connection to the authentication agent and frees any associated 217 * memory. 218 */ 219 220 void 221 ssh_close_authentication_connection(AuthenticationConnection *auth) 222 { 223 buffer_free(&auth->identities); 224 close(auth->fd); 225 xfree(auth); 226 } 227 228 /* Lock/unlock agent */ 229 int 230 ssh_lock_agent(AuthenticationConnection *auth, int lock, const char *password) 231 { 232 int type; 233 Buffer msg; 234 235 buffer_init(&msg); 236 buffer_put_char(&msg, lock ? SSH_AGENTC_LOCK : SSH_AGENTC_UNLOCK); 237 buffer_put_cstring(&msg, password); 238 239 if (ssh_request_reply(auth, &msg, &msg) == 0) { 240 buffer_free(&msg); 241 return 0; 242 } 243 type = buffer_get_char(&msg); 244 buffer_free(&msg); 245 return decode_reply(type); 246 } 247 248 /* 249 * Returns the first authentication identity held by the agent. 250 */ 251 252 int 253 ssh_get_num_identities(AuthenticationConnection *auth, int version) 254 { 255 int type, code1 = 0, code2 = 0; 256 Buffer request; 257 258 switch (version) { 259 case 1: 260 code1 = SSH_AGENTC_REQUEST_RSA_IDENTITIES; 261 code2 = SSH_AGENT_RSA_IDENTITIES_ANSWER; 262 break; 263 case 2: 264 code1 = SSH2_AGENTC_REQUEST_IDENTITIES; 265 code2 = SSH2_AGENT_IDENTITIES_ANSWER; 266 break; 267 default: 268 return 0; 269 } 270 271 /* 272 * Send a message to the agent requesting for a list of the 273 * identities it can represent. 274 */ 275 buffer_init(&request); 276 buffer_put_char(&request, code1); 277 278 buffer_clear(&auth->identities); 279 if (ssh_request_reply(auth, &request, &auth->identities) == 0) { 280 buffer_free(&request); 281 return 0; 282 } 283 buffer_free(&request); 284 285 /* Get message type, and verify that we got a proper answer. */ 286 type = buffer_get_char(&auth->identities); 287 if (agent_failed(type)) { 288 return 0; 289 } else if (type != code2) { 290 fatal("Bad authentication reply message type: %d", type); 291 } 292 293 /* Get the number of entries in the response and check it for sanity. */ 294 auth->howmany = buffer_get_int(&auth->identities); 295 if ((u_int)auth->howmany > 1024) 296 fatal("Too many identities in authentication reply: %d", 297 auth->howmany); 298 299 return auth->howmany; 300 } 301 302 Key * 303 ssh_get_first_identity(AuthenticationConnection *auth, char **comment, int version) 304 { 305 /* get number of identities and return the first entry (if any). */ 306 if (ssh_get_num_identities(auth, version) > 0) 307 return ssh_get_next_identity(auth, comment, version); 308 return NULL; 309 } 310 311 Key * 312 ssh_get_next_identity(AuthenticationConnection *auth, char **comment, int version) 313 { 314 int keybits; 315 u_int bits; 316 u_char *blob; 317 u_int blen; 318 Key *key = NULL; 319 320 /* Return failure if no more entries. */ 321 if (auth->howmany <= 0) 322 return NULL; 323 324 /* 325 * Get the next entry from the packet. These will abort with a fatal 326 * error if the packet is too short or contains corrupt data. 327 */ 328 switch (version) { 329 case 1: 330 key = key_new(KEY_RSA1); 331 bits = buffer_get_int(&auth->identities); 332 buffer_get_bignum(&auth->identities, key->rsa->e); 333 buffer_get_bignum(&auth->identities, key->rsa->n); 334 *comment = buffer_get_string(&auth->identities, NULL); 335 keybits = BN_num_bits(key->rsa->n); 336 if (keybits < 0 || bits != (u_int)keybits) 337 logit("Warning: identity keysize mismatch: actual %d, announced %u", 338 BN_num_bits(key->rsa->n), bits); 339 break; 340 case 2: 341 blob = buffer_get_string(&auth->identities, &blen); 342 *comment = buffer_get_string(&auth->identities, NULL); 343 key = key_from_blob(blob, blen); 344 xfree(blob); 345 break; 346 default: 347 return NULL; 348 } 349 /* Decrement the number of remaining entries. */ 350 auth->howmany--; 351 return key; 352 } 353 354 /* 355 * Generates a random challenge, sends it to the agent, and waits for 356 * response from the agent. Returns true (non-zero) if the agent gave the 357 * correct answer, zero otherwise. Response type selects the style of 358 * response desired, with 0 corresponding to protocol version 1.0 (no longer 359 * supported) and 1 corresponding to protocol version 1.1. 360 */ 361 362 int 363 ssh_decrypt_challenge(AuthenticationConnection *auth, 364 Key* key, BIGNUM *challenge, 365 u_char session_id[16], 366 u_int response_type, 367 u_char response[16]) 368 { 369 Buffer buffer; 370 int success = 0; 371 int i; 372 int type; 373 374 if (key->type != KEY_RSA1) 375 return 0; 376 if (response_type == 0) { 377 logit("Compatibility with ssh protocol version 1.0 no longer supported."); 378 return 0; 379 } 380 buffer_init(&buffer); 381 buffer_put_char(&buffer, SSH_AGENTC_RSA_CHALLENGE); 382 buffer_put_int(&buffer, BN_num_bits(key->rsa->n)); 383 buffer_put_bignum(&buffer, key->rsa->e); 384 buffer_put_bignum(&buffer, key->rsa->n); 385 buffer_put_bignum(&buffer, challenge); 386 buffer_append(&buffer, session_id, 16); 387 buffer_put_int(&buffer, response_type); 388 389 if (ssh_request_reply(auth, &buffer, &buffer) == 0) { 390 buffer_free(&buffer); 391 return 0; 392 } 393 type = buffer_get_char(&buffer); 394 395 if (agent_failed(type)) { 396 logit("Agent admitted failure to authenticate using the key."); 397 } else if (type != SSH_AGENT_RSA_RESPONSE) { 398 fatal("Bad authentication response: %d", type); 399 } else { 400 success = 1; 401 /* 402 * Get the response from the packet. This will abort with a 403 * fatal error if the packet is corrupt. 404 */ 405 for (i = 0; i < 16; i++) 406 response[i] = (u_char)buffer_get_char(&buffer); 407 } 408 buffer_free(&buffer); 409 return success; 410 } 411 412 /* ask agent to sign data, returns -1 on error, 0 on success */ 413 int 414 ssh_agent_sign(AuthenticationConnection *auth, 415 Key *key, 416 u_char **sigp, u_int *lenp, 417 u_char *data, u_int datalen) 418 { 419 extern int datafellows; 420 Buffer msg; 421 u_char *blob; 422 u_int blen; 423 int type, flags = 0; 424 int ret = -1; 425 426 if (key_to_blob(key, &blob, &blen) == 0) 427 return -1; 428 429 if (datafellows & SSH_BUG_SIGBLOB) 430 flags = SSH_AGENT_OLD_SIGNATURE; 431 432 buffer_init(&msg); 433 buffer_put_char(&msg, SSH2_AGENTC_SIGN_REQUEST); 434 buffer_put_string(&msg, blob, blen); 435 buffer_put_string(&msg, data, datalen); 436 buffer_put_int(&msg, flags); 437 xfree(blob); 438 439 if (ssh_request_reply(auth, &msg, &msg) == 0) { 440 buffer_free(&msg); 441 return -1; 442 } 443 type = buffer_get_char(&msg); 444 if (agent_failed(type)) { 445 logit("Agent admitted failure to sign using the key."); 446 } else if (type != SSH2_AGENT_SIGN_RESPONSE) { 447 fatal("Bad authentication response: %d", type); 448 } else { 449 ret = 0; 450 *sigp = buffer_get_string(&msg, lenp); 451 } 452 buffer_free(&msg); 453 return ret; 454 } 455 456 /* Encode key for a message to the agent. */ 457 458 static void 459 ssh_encode_identity_rsa1(Buffer *b, RSA *key, const char *comment) 460 { 461 buffer_put_int(b, BN_num_bits(key->n)); 462 buffer_put_bignum(b, key->n); 463 buffer_put_bignum(b, key->e); 464 buffer_put_bignum(b, key->d); 465 /* To keep within the protocol: p < q for ssh. in SSL p > q */ 466 buffer_put_bignum(b, key->iqmp); /* ssh key->u */ 467 buffer_put_bignum(b, key->q); /* ssh key->p, SSL key->q */ 468 buffer_put_bignum(b, key->p); /* ssh key->q, SSL key->p */ 469 buffer_put_cstring(b, comment); 470 } 471 472 static void 473 ssh_encode_identity_ssh2(Buffer *b, Key *key, const char *comment) 474 { 475 buffer_put_cstring(b, key_ssh_name(key)); 476 switch (key->type) { 477 case KEY_RSA: 478 buffer_put_bignum2(b, key->rsa->n); 479 buffer_put_bignum2(b, key->rsa->e); 480 buffer_put_bignum2(b, key->rsa->d); 481 buffer_put_bignum2(b, key->rsa->iqmp); 482 buffer_put_bignum2(b, key->rsa->p); 483 buffer_put_bignum2(b, key->rsa->q); 484 break; 485 case KEY_RSA_CERT_V00: 486 case KEY_RSA_CERT: 487 if (key->cert == NULL || buffer_len(&key->cert->certblob) == 0) 488 fatal("%s: no cert/certblob", __func__); 489 buffer_put_string(b, buffer_ptr(&key->cert->certblob), 490 buffer_len(&key->cert->certblob)); 491 buffer_put_bignum2(b, key->rsa->d); 492 buffer_put_bignum2(b, key->rsa->iqmp); 493 buffer_put_bignum2(b, key->rsa->p); 494 buffer_put_bignum2(b, key->rsa->q); 495 break; 496 case KEY_DSA: 497 buffer_put_bignum2(b, key->dsa->p); 498 buffer_put_bignum2(b, key->dsa->q); 499 buffer_put_bignum2(b, key->dsa->g); 500 buffer_put_bignum2(b, key->dsa->pub_key); 501 buffer_put_bignum2(b, key->dsa->priv_key); 502 break; 503 case KEY_DSA_CERT_V00: 504 case KEY_DSA_CERT: 505 if (key->cert == NULL || buffer_len(&key->cert->certblob) == 0) 506 fatal("%s: no cert/certblob", __func__); 507 buffer_put_string(b, buffer_ptr(&key->cert->certblob), 508 buffer_len(&key->cert->certblob)); 509 buffer_put_bignum2(b, key->dsa->priv_key); 510 break; 511 case KEY_ECDSA: 512 buffer_put_cstring(b, key_curve_nid_to_name(key->ecdsa_nid)); 513 buffer_put_ecpoint(b, EC_KEY_get0_group(key->ecdsa), 514 EC_KEY_get0_public_key(key->ecdsa)); 515 buffer_put_bignum2(b, EC_KEY_get0_private_key(key->ecdsa)); 516 break; 517 case KEY_ECDSA_CERT: 518 if (key->cert == NULL || buffer_len(&key->cert->certblob) == 0) 519 fatal("%s: no cert/certblob", __func__); 520 buffer_put_string(b, buffer_ptr(&key->cert->certblob), 521 buffer_len(&key->cert->certblob)); 522 buffer_put_bignum2(b, EC_KEY_get0_private_key(key->ecdsa)); 523 break; 524 } 525 buffer_put_cstring(b, comment); 526 } 527 528 /* 529 * Adds an identity to the authentication server. This call is not meant to 530 * be used by normal applications. 531 */ 532 533 int 534 ssh_add_identity_constrained(AuthenticationConnection *auth, Key *key, 535 const char *comment, u_int life, u_int confirm) 536 { 537 Buffer msg; 538 int type, constrained = (life || confirm); 539 540 buffer_init(&msg); 541 542 switch (key->type) { 543 case KEY_RSA1: 544 type = constrained ? 545 SSH_AGENTC_ADD_RSA_ID_CONSTRAINED : 546 SSH_AGENTC_ADD_RSA_IDENTITY; 547 buffer_put_char(&msg, type); 548 ssh_encode_identity_rsa1(&msg, key->rsa, comment); 549 break; 550 case KEY_RSA: 551 case KEY_RSA_CERT: 552 case KEY_RSA_CERT_V00: 553 case KEY_DSA: 554 case KEY_DSA_CERT: 555 case KEY_DSA_CERT_V00: 556 case KEY_ECDSA: 557 case KEY_ECDSA_CERT: 558 type = constrained ? 559 SSH2_AGENTC_ADD_ID_CONSTRAINED : 560 SSH2_AGENTC_ADD_IDENTITY; 561 buffer_put_char(&msg, type); 562 ssh_encode_identity_ssh2(&msg, key, comment); 563 break; 564 default: 565 buffer_free(&msg); 566 return 0; 567 } 568 if (constrained) { 569 if (life != 0) { 570 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_LIFETIME); 571 buffer_put_int(&msg, life); 572 } 573 if (confirm != 0) 574 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_CONFIRM); 575 } 576 if (ssh_request_reply(auth, &msg, &msg) == 0) { 577 buffer_free(&msg); 578 return 0; 579 } 580 type = buffer_get_char(&msg); 581 buffer_free(&msg); 582 return decode_reply(type); 583 } 584 585 /* 586 * Removes an identity from the authentication server. This call is not 587 * meant to be used by normal applications. 588 */ 589 590 int 591 ssh_remove_identity(AuthenticationConnection *auth, Key *key) 592 { 593 Buffer msg; 594 int type; 595 u_char *blob; 596 u_int blen; 597 598 buffer_init(&msg); 599 600 if (key->type == KEY_RSA1) { 601 buffer_put_char(&msg, SSH_AGENTC_REMOVE_RSA_IDENTITY); 602 buffer_put_int(&msg, BN_num_bits(key->rsa->n)); 603 buffer_put_bignum(&msg, key->rsa->e); 604 buffer_put_bignum(&msg, key->rsa->n); 605 } else if (key_type_plain(key->type) == KEY_DSA || 606 key_type_plain(key->type) == KEY_RSA || 607 key_type_plain(key->type) == KEY_ECDSA) { 608 key_to_blob(key, &blob, &blen); 609 buffer_put_char(&msg, SSH2_AGENTC_REMOVE_IDENTITY); 610 buffer_put_string(&msg, blob, blen); 611 xfree(blob); 612 } else { 613 buffer_free(&msg); 614 return 0; 615 } 616 if (ssh_request_reply(auth, &msg, &msg) == 0) { 617 buffer_free(&msg); 618 return 0; 619 } 620 type = buffer_get_char(&msg); 621 buffer_free(&msg); 622 return decode_reply(type); 623 } 624 625 int 626 ssh_update_card(AuthenticationConnection *auth, int add, 627 const char *reader_id, const char *pin, u_int life, u_int confirm) 628 { 629 Buffer msg; 630 int type, constrained = (life || confirm); 631 632 if (add) { 633 type = constrained ? 634 SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED : 635 SSH_AGENTC_ADD_SMARTCARD_KEY; 636 } else 637 type = SSH_AGENTC_REMOVE_SMARTCARD_KEY; 638 639 buffer_init(&msg); 640 buffer_put_char(&msg, type); 641 buffer_put_cstring(&msg, reader_id); 642 buffer_put_cstring(&msg, pin); 643 644 if (constrained) { 645 if (life != 0) { 646 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_LIFETIME); 647 buffer_put_int(&msg, life); 648 } 649 if (confirm != 0) 650 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_CONFIRM); 651 } 652 653 if (ssh_request_reply(auth, &msg, &msg) == 0) { 654 buffer_free(&msg); 655 return 0; 656 } 657 type = buffer_get_char(&msg); 658 buffer_free(&msg); 659 return decode_reply(type); 660 } 661 662 /* 663 * Removes all identities from the agent. This call is not meant to be used 664 * by normal applications. 665 */ 666 667 int 668 ssh_remove_all_identities(AuthenticationConnection *auth, int version) 669 { 670 Buffer msg; 671 int type; 672 int code = (version==1) ? 673 SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES : 674 SSH2_AGENTC_REMOVE_ALL_IDENTITIES; 675 676 buffer_init(&msg); 677 buffer_put_char(&msg, code); 678 679 if (ssh_request_reply(auth, &msg, &msg) == 0) { 680 buffer_free(&msg); 681 return 0; 682 } 683 type = buffer_get_char(&msg); 684 buffer_free(&msg); 685 return decode_reply(type); 686 } 687 688 int 689 decode_reply(int type) 690 { 691 switch (type) { 692 case SSH_AGENT_FAILURE: 693 case SSH_COM_AGENT2_FAILURE: 694 case SSH2_AGENT_FAILURE: 695 logit("SSH_AGENT_FAILURE"); 696 return 0; 697 case SSH_AGENT_SUCCESS: 698 return 1; 699 default: 700 fatal("Bad response from authentication agent: %d", type); 701 } 702 /* NOTREACHED */ 703 return 0; 704 } 705