networking/sendmail.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * bare bones sendmail/fetchmail
   4  *
   5  * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
   6  *
   7  * Licensed under GPLv2, see file LICENSE in this tarball for details.
   8  */
   9 #include "libbb.h"
  10
  11 #define INITIAL_STDIN_FILENO 3
  12
  13 static void uuencode(char *fname, const char *text)
  14 {
  15         enum {
  16                 SRC_BUF_SIZE = 45,  /* This *MUST* be a multiple of 3 */
  17                 DST_BUF_SIZE = 4 * ((SRC_BUF_SIZE + 2) / 3),
  18         };
  19
  20 #define src_buf text
  21         int fd;
  22 #define len fd
  23         char dst_buf[DST_BUF_SIZE + 1];
  24
  25         if (fname) {
  26                 fd = INITIAL_STDIN_FILENO;
  27                 if (NOT_LONE_DASH(fname))
  28                         fd = xopen(fname, O_RDONLY);
  29                 src_buf = bb_common_bufsiz1;
  30         // N.B. strlen(NULL) segfaults!
  31         } else if (text) {
  32                 // though we do not call uuencode(NULL, NULL) explicitly
  33                 // still we do not want to break things suddenly
  34                 len = strlen(text);
  35         } else
  36                 return;
  37
  38         fflush(stdout); // sync stdio and unistd output
  39         while (1) {
  40                 size_t size;
  41                 if (fname) {
  42                         size = full_read(fd, (char *)src_buf, SRC_BUF_SIZE);
  43                         if ((ssize_t)size < 0)
  44                                 bb_perror_msg_and_die(bb_msg_read_error);
  45                 } else {
  46                         size = len;
  47                         if (len > SRC_BUF_SIZE)
  48                                 size = SRC_BUF_SIZE;
  49                 }
  50                 if (!size)
  51                         break;
  52                 // encode the buffer we just read in
  53                 bb_uuencode(dst_buf, src_buf, size, bb_uuenc_tbl_base64);
  54                 if (fname) {
  55                         xwrite(STDOUT_FILENO, "\r\n", 2);
  56                 } else {
  57                         src_buf += size;
  58                         len -= size;
  59                 }
  60                 xwrite(STDOUT_FILENO, dst_buf, 4 * ((size + 2) / 3));
  61         }
  62         if (fname)
  63                 close(fd);
  64 #undef src_buf
  65 #undef len
  66 }
  67
  68 struct globals {
  69         pid_t helper_pid;
  70         unsigned timeout;
  71         // arguments for SSL connection helper
  72         const char *xargs[9];
  73         // arguments for postprocess helper
  74         const char *fargs[3];
  75 };
  76 #define G (*ptr_to_globals)
  77 #define helper_pid      (G.helper_pid)
  78 #define timeout         (G.timeout   )
  79 #define xargs           (G.xargs     )
  80 #define fargs           (G.fargs     )
  81 #define INIT_G() do { \
  82         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
  83         xargs[0] = "openssl"; \
  84         xargs[1] = "s_client"; \
  85         xargs[2] = "-quiet"; \
  86         xargs[3] = "-connect"; \
  87         /*xargs[4] = "localhost";*/ \
  88         xargs[5] = "-tls1"; \
  89         xargs[6] = "-starttls"; \
  90         xargs[7] = "smtp"; \
  91         fargs[0] = "utf-8"; \
  92 } while (0)
  93
  94 #define opt_connect       (xargs[4])
  95 #define opt_after_connect (xargs[5])
  96 #define opt_charset       (fargs[0])
  97 #define opt_subject       (fargs[1])
  98
  99 static void kill_helper(void)
 100 {
 101         // TODO!!!: is there more elegant way to terminate child on program failure?
 102         if (helper_pid > 0)
 103                 kill(helper_pid, SIGTERM);
 104 }
 105
 106 // generic signal handler
 107 static void signal_handler(int signo)
 108 {
 109 #define err signo
 110
 111         if (SIGALRM == signo) {
 112                 kill_helper();
 113                 bb_error_msg_and_die("timed out");
 114         }
 115
 116         // SIGCHLD. reap zombies
 117         if (wait_any_nohang(&err) > 0)
 118                 if (WIFEXITED(err) && WEXITSTATUS(err))
 119                         bb_error_msg_and_die("child exited (%d)", WEXITSTATUS(err));
 120 #undef err
 121 }
 122
 123 static void launch_helper(const char **argv)
 124 {
 125         // setup vanilla unidirectional pipes interchange
 126         int idx;
 127         int pipes[4];
 128
 129         xpipe(pipes);
 130         xpipe(pipes+2);
 131         helper_pid = vfork();
 132         if (helper_pid < 0)
 133                 bb_perror_msg_and_die("vfork");
 134         idx = (!helper_pid) * 2;
 135         xdup2(pipes[idx], STDIN_FILENO);
 136         xdup2(pipes[3-idx], STDOUT_FILENO);
 137         if (ENABLE_FEATURE_CLEAN_UP)
 138                 for (int i = 4; --i >= 0; )
 139                         if (pipes[i] > STDOUT_FILENO)
 140                                 close(pipes[i]);
 141         if (!helper_pid) {
 142                 // child: try to execute connection helper
 143                 BB_EXECVP(*argv, (char **)argv);
 144                 _exit(127);
 145         }
 146         // parent: check whether child is alive
 147         bb_signals(0
 148                 + (1 << SIGCHLD)
 149                 + (1 << SIGALRM)
 150                 , signal_handler);
 151         signal_handler(SIGCHLD);
 152         // child seems OK -> parent goes on
 153 }
 154
 155 static const char *command(const char *fmt, const char *param)
 156 {
 157         const char *msg = fmt;
 158         alarm(timeout);
 159         if (msg) {
 160                 msg = xasprintf(fmt, param);
 161                 printf("%s\r\n", msg);
 162         }
 163         fflush(stdout);
 164         return msg;
 165 }
 166
 167 static int smtp_checkp(const char *fmt, const char *param, int code)
 168 {
 169         char *answer;
 170         const char *msg = command(fmt, param);
 171         // read stdin
 172         // if the string has a form \d\d\d- -- read next string. E.g. EHLO response
 173         // parse first bytes to a number
 174         // if code = -1 then just return this number
 175         // if code != -1 then checks whether the number equals the code
 176         // if not equal -> die saying msg
 177         while ((answer = xmalloc_fgetline(stdin)) != NULL)
 178                 if (strlen(answer) <= 3 || '-' != answer[3])
 179                         break;
 180         if (answer) {
 181                 int n = atoi(answer);
 182                 alarm(0);
 183                 if (ENABLE_FEATURE_CLEAN_UP) {
 184                         free(answer);
 185                 }
 186                 if (-1 == code || n == code) {
 187                         return n;
 188                 }
 189         }
 190         kill_helper();
 191         bb_error_msg_and_die("%s failed", msg);
 192 }
 193
 194 static inline int smtp_check(const char *fmt, int code)
 195 {
 196         return smtp_checkp(fmt, NULL, code);
 197 }
 198
 199 // strip argument of bad chars
 200 static char *sane(char *str)
 201 {
 202         char *s = str;
 203         char *p = s;
 204         while (*s) {
 205                 if (isalnum(*s) || '_' == *s || '-' == *s || '.' == *s || '@' == *s) {
 206                         *p++ = *s;
 207                 }
 208                 s++;
 209         }
 210         *p = '\0';
 211         return str;
 212 }
 213
 214 #if ENABLE_FETCHMAIL
 215 static void pop3_checkr(const char *fmt, const char *param, char **ret)
 216 {
 217         const char *msg = command(fmt, param);
 218         char *answer = xmalloc_fgetline(stdin);
 219         if (answer && '+' == *answer) {
 220                 alarm(0);
 221                 if (ret)
 222                         *ret = answer+4; // skip "+OK "
 223                 else if (ENABLE_FEATURE_CLEAN_UP)
 224                         free(answer);
 225                 return;
 226         }
 227         kill_helper();
 228         bb_error_msg_and_die("%s failed", msg);
 229 }
 230
 231 static inline void pop3_check(const char *fmt, const char *param)
 232 {
 233         pop3_checkr(fmt, param, NULL);
 234 }
 235
 236 static void pop3_message(const char *filename)
 237 {
 238         int fd;
 239         char *answer;
 240         // create and open file filename
 241         // read stdin, copy to created file
 242         fd = xopen(filename, O_CREAT | O_WRONLY | O_TRUNC | O_EXCL);
 243         while ((answer = xmalloc_fgets_str(stdin, "\r\n")) != NULL) {
 244                 char *s = answer;
 245                 if ('.' == *answer) {
 246                         if ('.' == answer[1])
 247                                 s++;
 248                         else if ('\r' == answer[1] && '\n' == answer[2] && '\0' == answer[3])
 249                                 break;
 250                 }
 251                 xwrite(fd, s, strlen(s));
 252                 free(answer);
 253         }
 254         close(fd);
 255 }
 256 #endif
 257
 258 static char *parse_url(char *url, char **user, char **pass)
 259 {
 260         // parse [user[:pass]@]host
 261         // return host
 262         char *s = strchr(url, '@');
 263         *user = *pass = NULL;
 264         if (s) {
 265                 *s++ = '\0';
 266                 *user = url;
 267                 url = s;
 268                 s = strchr(*user, ':');
 269                 if (s) {
 270                         *s++ = '\0';
 271                         *pass = s;
 272                 }
 273         }
 274         return url;
 275 }
 276
 277 static void rcptto(const char *s)
 278 {
 279         smtp_checkp("RCPT TO:<%s>", s, 250);
 280 }
 281
 282 int sendgetmail_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 283 int sendgetmail_main(int argc UNUSED_PARAM, char **argv)
 284 {
 285         llist_t *opt_attachments = NULL;
 286         char *opt_from;
 287         char *opt_user;
 288         char *opt_pass;
 289         enum {
 290                 OPT_w = 1 << 0,         // network timeout
 291                 OPT_H = 1 << 1,         // [user:password@]server[:port]
 292                 OPT_S = 1 << 2,         // connect using openssl s_client helper
 293
 294                 OPTS_t = 1 << 3,        // sendmail: read addresses from body
 295                 OPTF_t = 1 << 3,        // fetchmail: use "TOP" not "RETR"
 296
 297                 OPTS_s = 1 << 4,        // sendmail: subject
 298                 OPTF_z = 1 << 4,        // fetchmail: delete from server
 299
 300                 OPTS_c = 1 << 5,        // sendmail: assumed charset
 301                 OPTS_a = 1 << 6,        // sendmail: attachment(s)
 302                 OPTS_i = 1 << 7,        // sendmail: ignore lone dots in message body (implied)
 303
 304                 OPTS_N = 1 << 8,        // sendmail: request notification
 305                 OPTS_f = 1 << 9,        // sendmail: sender address
 306         };
 307         const char *options;
 308         int opts;
 309
 310         // init global variables
 311         INIT_G();
 312
 313         // parse options, different option sets for sendmail and fetchmail
 314         // N.B. opt_after_connect hereafter is NULL if we are called as fetchmail
 315         // and is NOT NULL if we are called as sendmail
 316         if (!ENABLE_FETCHMAIL || 's' == applet_name[0]) {
 317                 // SENDMAIL
 318                 // save initial stdin since body is piped!
 319                 xdup2(STDIN_FILENO, INITIAL_STDIN_FILENO);
 320                 opt_complementary = "w+:a::";
 321                 options = "w:H:St" "s:c:a:iN:f:";
 322                 // body is pseudo attachment read from stdin
 323                 llist_add_to_end(&opt_attachments, (char *)"-");
 324         } else {
 325                 // FETCHMAIL
 326                 opt_after_connect = NULL;
 327                 opt_complementary = "-1:w+";
 328                 options = "w:H:St" "z";
 329         }
 330         opts = getopt32(argv, options,
 331                 &timeout /* -w */, &opt_connect /* -H */,
 332                 &opt_subject, &opt_charset, &opt_attachments, NULL, &opt_from
 333         );
 334         //argc -= optind;
 335         argv += optind;
 336
 337         // connect to server
 338         // host[:port] not specified ? -> use $HOSTNAME. no $HOSTNAME ? -> use localhost
 339         if (!(opts & OPT_H)) {
 340                 opt_connect = getenv("HOSTNAME");
 341                 if (!opt_connect)
 342                         opt_connect = "127.0.0.1";
 343         }
 344         // fetch username and password, if any
 345         // NB: parse_url modifies opt_connect[] ONLY if '@' is there.
 346         // Thus "127.0.0.1" won't be modified, an is ok that it is RO.
 347         opt_connect = parse_url((char*)opt_connect, &opt_user, &opt_pass);
 348 //      bb_error_msg("H[%s] U[%s] P[%s]", opt_connect, opt_user, opt_pass);
 349
 350         // username must be defined!
 351         if (!opt_user) {
 352                 // N.B. IMHO getenv("USER") can be way easily spoofed!
 353                 opt_user = bb_getpwuid(NULL, -1, getuid());
 354         }
 355
 356         // SSL ordered? ->
 357         if (opts & OPT_S) {
 358                 // ... use openssl helper
 359                 launch_helper(xargs);
 360         // no SSL ordered? ->
 361         } else {
 362                 // ... make plain connect
 363                 int fd = create_and_connect_stream_or_die(opt_connect, 25);
 364                 // make ourselves a simple IO filter
 365                 // from now we know nothing about network :)
 366                 xmove_fd(fd, STDIN_FILENO);
 367                 xdup2(STDIN_FILENO, STDOUT_FILENO);
 368         }
 369
 370         // are we sendmail?
 371         if (!ENABLE_FETCHMAIL || opt_after_connect)
 372 /***************************************************
 373  * SENDMAIL
 374  ***************************************************/
 375         {
 376                 int code;
 377                 char *boundary;
 378                 const char *fmt;
 379                 const char *p;
 380                 char *q;
 381                 llist_t *l;
 382                 llist_t *headers = NULL;
 383
 384                 // got no sender address? -> use username as a resort
 385                 if (!(opts & OPTS_f)) {
 386                         char *domain = safe_getdomainname();
 387                         opt_from = xasprintf("%s@%s", opt_user, domain);
 388                         if (ENABLE_FEATURE_CLEAN_UP)
 389                                 free(domain);
 390                 }
 391
 392                 // introduce to server
 393
 394                 // we didn't use SSL helper? ->
 395                 if (!(opts & OPT_S)) {
 396                         // ... wait for initial server OK
 397                         smtp_check(NULL, 220);
 398                 }
 399
 400                 // we should start with modern EHLO
 401                 if (250 != smtp_checkp("EHLO %s", sane(opt_from), -1)) {
 402                         smtp_checkp("HELO %s", opt_from, 250);
 403                 }
 404
 405                 // set sender
 406                 // NOTE: if password has not been specified
 407                 // then no authentication is possible
 408                 code = (opt_pass) ? -1 : 250;
 409                 // first try softly without authentication
 410                 while (250 != smtp_checkp("MAIL FROM:<%s>", opt_from, code)) {
 411                         // MAIL FROM failed -> authentication needed
 412                         if (334 == smtp_check("AUTH LOGIN", -1)) {
 413                                 uuencode(NULL, opt_user); // opt_user != NULL
 414                                 smtp_check("", 334);
 415                                 uuencode(NULL, opt_pass);
 416                                 smtp_check("", 235);
 417                         }
 418                         // authenticated OK? -> retry to set sender
 419                         // but this time die on failure!
 420                         code = 250;
 421                 }
 422
 423                 // recipients specified as arguments
 424                 while (*argv) {
 425                         // loose test on email address validity
 426                         if (strchr(sane(*argv), '@')) {
 427                                 rcptto(sane(*argv));
 428                                 llist_add_to_end(&headers, xasprintf("To: %s", *argv));
 429                         }
 430                         argv++;
 431                 }
 432
 433                 // if -t specified or no recipients specified -> enter all-included mode
 434                 // i.e. scan stdin for To:, Cc:, Bcc:, and Subject: lines ...
 435                 // ... and then use the rest of stdin as message body
 436                 // N.B. subject read from body has priority
 437                 // over that specified on command line.
 438                 // recipients are merged
 439                 // N.B. other headers are collected and will be dumped verbatim
 440                 if (opts & OPTS_t || !headers) {
 441                         // fetch recipients and (optionally) subject
 442                         char *s;
 443                         while ((s = xmalloc_reads(INITIAL_STDIN_FILENO, NULL, NULL)) != NULL) {
 444                                 if (0 == strncasecmp("To: ", s, 4) || 0 == strncasecmp("Cc: ", s, 4)) {
 445                                         rcptto(sane(s+4));
 446                                         llist_add_to_end(&headers, s);
 447                                 } else if (0 == strncasecmp("Bcc: ", s, 5)) {
 448                                         rcptto(sane(s+5));
 449                                         if (ENABLE_FEATURE_CLEAN_UP)
 450                                                 free(s);
 451                                         // N.B. Bcc vanishes from headers!
 452 /*                              } else if (0 == strncmp("From: ", s, 6)) {
 453                                         opt_from = s+6;
 454                                         opts |= OPTS_f;
 455 */                              } else if (0 == strncmp("Subject: ", s, 9)) {
 456                                         opt_subject = s+9;
 457                                         opts |= OPTS_s;
 458                                 } else if (s[0]) {
 459                                         // misc header
 460                                         llist_add_to_end(&headers, s);
 461                                 } else {
 462                                         free(s);
 463                                         break; // empty line
 464                                 }
 465                         }
 466                 }
 467
 468                 // enter "put message" mode
 469                 smtp_check("DATA", 354);
 470
 471                 // put headers we could have preread with -t
 472                 for (l = headers; l; l = l->link) {
 473                         printf("%s\r\n", l->data);
 474                         if (ENABLE_FEATURE_CLEAN_UP)
 475                                 free(l->data);
 476                 }
 477
 478                 // put address header
 479                 printf("From: %s\r\n", opt_from);
 480
 481                 // put encoded subject
 482                 if (opts & OPTS_c)
 483                         sane((char *)opt_charset);
 484                 if (opts & OPTS_s) {
 485                         printf("Subject: =?%s?B?", opt_charset);
 486                         uuencode(NULL, opt_subject);
 487                         printf("?=\r\n");
 488                 }
 489
 490                 // put notification
 491                 if (opts & OPTS_N)
 492                         printf("Disposition-Notification-To: %s\r\n", opt_from);
 493
 494                 // make a random string -- it will delimit message parts
 495                 srand(monotonic_us());
 496                 boundary = xasprintf("%d-%d-%d", rand(), rand(), rand());
 497
 498                 // put common headers and body start
 499                 printf(
 500                         "Message-ID: <%s>\r\n"
 501                         "Mime-Version: 1.0\r\n"
 502                         "%smultipart/mixed; boundary=\"%s\"\r\n"
 503                         , boundary
 504                         , "Content-Type: "
 505                         , boundary
 506                 );
 507
 508                 // put body + attachment(s)
 509                 // N.B. all these weird things just to be tiny
 510                 // by reusing string patterns!
 511                 fmt =
 512                         "\r\n--%s\r\n"
 513                         "%stext/plain; charset=%s\r\n"
 514                         "%s%s\r\n"
 515                         "%s"
 516                 ;
 517                 p = opt_charset;
 518                 q = (char *)"";
 519                 l = opt_attachments;
 520                 while (l) {
 521                         printf(
 522                                 fmt
 523                                 , boundary
 524                                 , "Content-Type: "
 525                                 , p
 526                                 , "Content-Disposition: inline"
 527                                 , q
 528                                 , "Content-Transfer-Encoding: base64\r\n"
 529                         );
 530                         p = "";
 531                         fmt =
 532                                 "\r\n--%s\r\n"
 533                                 "%sapplication/octet-stream%s\r\n"
 534                                 "%s; filename=\"%s\"\r\n"
 535                                 "%s"
 536                         ;
 537                         uuencode(l->data, NULL);
 538                         l = l->link;
 539                         if (l)
 540                                 q = bb_get_last_path_component_strip(l->data);
 541                 }
 542
 543                 // put message terminator
 544                 printf("\r\n--%s--\r\n" "\r\n", boundary);
 545
 546                 // leave "put message" mode
 547                 smtp_check(".", 250);
 548                 // ... and say goodbye
 549                 smtp_check("QUIT", 221);
 550         }
 551 #if ENABLE_FETCHMAIL
 552 /***************************************************
 553  * FETCHMAIL
 554  ***************************************************/
 555         else {
 556                 char *buf;
 557                 unsigned nmsg;
 558                 char *hostname;
 559                 pid_t pid;
 560
 561                 // cache fetch command:
 562                 // TOP will return only the headers
 563                 // RETR will dump the whole message
 564                 const char *retr = (opts & OPTF_t) ? "TOP %u 0" : "RETR %u";
 565
 566                 // goto maildir
 567                 xchdir(*argv++);
 568
 569                 // cache postprocess program
 570                 *fargs = *argv;
 571
 572                 // authenticate
 573
 574                 // password is mandatory
 575                 if (!opt_pass) {
 576                         bb_error_msg_and_die("no password");
 577                 }
 578
 579                 // get server greeting
 580                 pop3_checkr(NULL, NULL, &buf);
 581
 582                 // server supports APOP?
 583                 if ('<' == *buf) {
 584                         md5_ctx_t md5;
 585                         // yes! compose <stamp><password>
 586                         char *s = strchr(buf, '>');
 587                         if (s)
 588                                 strcpy(s+1, opt_pass);
 589                         s = buf;
 590                         // get md5 sum of <stamp><password>
 591                         md5_begin(&md5);
 592                         md5_hash(s, strlen(s), &md5);
 593                         md5_end(s, &md5);
 594                         // NOTE: md5 struct contains enough space
 595                         // so we reuse md5 space instead of xzalloc(16*2+1)
 596 #define md5_hex ((uint8_t *)&md5)
 597 //                      uint8_t *md5_hex = (uint8_t *)&md5;
 598                         *bin2hex((char *)md5_hex, s, 16) = '\0';
 599                         // APOP
 600                         s = xasprintf("%s %s", opt_user, md5_hex);
 601 #undef md5_hex
 602                         pop3_check("APOP %s", s);
 603                         if (ENABLE_FEATURE_CLEAN_UP) {
 604                                 free(s);
 605                                 free(buf-4); // buf is "+OK " away from malloc'ed string
 606                         }
 607                 // server ignores APOP -> use simple text authentication
 608                 } else {
 609                         // USER
 610                         pop3_check("USER %s", opt_user);
 611                         // PASS
 612                         pop3_check("PASS %s", opt_pass);
 613                 }
 614
 615                 // get mailbox statistics
 616                 pop3_checkr("STAT", NULL, &buf);
 617
 618                 // prepare message filename suffix
 619                 hostname = safe_gethostname();
 620                 pid = getpid();
 621
 622                 // get messages counter
 623                 // NOTE: we don't use xatou(buf) since buf is "nmsg nbytes"
 624                 // we only need nmsg and atoi is just exactly what we need
 625                 // if atoi fails to convert buf into number it returns 0
 626                 // in this case the following loop simply will not be executed
 627                 nmsg = atoi(buf);
 628                 if (ENABLE_FEATURE_CLEAN_UP)
 629                         free(buf-4); // buf is "+OK " away from malloc'ed string
 630
 631                 // loop through messages
 632                 for (; nmsg; nmsg--) {
 633
 634                         // generate unique filename
 635                         char *filename = xasprintf("tmp/%llu.%u.%s",
 636                                         monotonic_us(), (unsigned)pid, hostname);
 637                         char *target;
 638                         int rc;
 639
 640                         // retrieve message in ./tmp/
 641                         pop3_check(retr, (const char *)(ptrdiff_t)nmsg);
 642                         pop3_message(filename);
 643                         // delete message from server
 644                         if (opts & OPTF_z)
 645                                 pop3_check("DELE %u", (const char*)(ptrdiff_t)nmsg);
 646
 647                         // run postprocessing program
 648                         if (*fargs) {
 649                                 fargs[1] = filename;
 650                                 rc = wait4pid(spawn((char **)fargs));
 651                                 if (99 == rc)
 652                                         break;
 653                                 if (1 == rc)
 654                                         goto skip;
 655                         }
 656
 657                         // atomically move message to ./new/
 658                         target = xstrdup(filename);
 659                         strncpy(target, "new", 3);
 660                         // ... or just stop receiving on error
 661                         if (rename_or_warn(filename, target))
 662                                 break;
 663                         free(target);
 664  skip:
 665                         free(filename);
 666                 }
 667
 668                 // Bye
 669                 pop3_check("QUIT", NULL);
 670         }
 671 #endif // ENABLE_FETCHMAIL
 672
 673         return 0;
 674 }