g10/plaintext.c

   1 /* plaintext.c -  process plaintext packets
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3  *               2006, 2009, 2010 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27 #include <sys/types.h>
  28 #ifdef HAVE_DOSISH_SYSTEM
  29 # include <fcntl.h> /* for setmode() */
  30 #endif
  31
  32 #include "gpg.h"
  33 #include "util.h"
  34 #include "options.h"
  35 #include "packet.h"
  36 #include "ttyio.h"
  37 #include "filter.h"
  38 #include "main.h"
  39 #include "status.h"
  40 #include "i18n.h"
  41
  42
  43 /* Handle a plaintext packet.  If MFX is not NULL, update the MDs
  44  * Note: We should have used the filter stuff here, but we have to add
  45  * some easy mimic to set a read limit, so we calculate only the bytes
  46  * from the plaintext.  */
  47 int
  48 handle_plaintext (PKT_plaintext * pt, md_filter_context_t * mfx,
  49                   int nooutput, int clearsig)
  50 {
  51   char *fname = NULL;
  52   estream_t fp = NULL;
  53   static off_t count = 0;
  54   int err = 0;
  55   int c;
  56   int convert = (pt->mode == 't' || pt->mode == 'u');
  57 #ifdef __riscos__
  58   int filetype = 0xfff;
  59 #endif
  60
  61   /* Let people know what the plaintext info is. This allows the
  62      receiving program to try and do something different based on the
  63      format code (say, recode UTF-8 to local). */
  64   if (!nooutput && is_status_enabled ())
  65     {
  66       char status[50];
  67
  68       /* Better make sure that stdout has been flushed in case the
  69          output will be written to it.  This is to make sure that no
  70          not-yet-flushed stuff will be written after the plaintext
  71          status message.  */
  72       es_fflush (es_stdout);
  73
  74       snprintf (status, sizeof status,
  75                 "%X %lu ", (byte) pt->mode, (ulong) pt->timestamp);
  76       write_status_text_and_buffer (STATUS_PLAINTEXT,
  77                                     status, pt->name, pt->namelen, 0);
  78
  79       if (!pt->is_partial)
  80         {
  81           snprintf (status, sizeof status, "%lu", (ulong) pt->len);
  82           write_status_text (STATUS_PLAINTEXT_LENGTH, status);
  83         }
  84     }
  85
  86   /* Create the filename as C string.  */
  87   if (nooutput)
  88     ;
  89   else if (opt.outfp)
  90     {
  91       fname = xtrystrdup ("[FP]");
  92       if (!fname)
  93         {
  94           err = gpg_error_from_syserror ();
  95           goto leave;
  96         }
  97     }
  98   else if (opt.outfile)
  99     {
 100       fname = xtrystrdup (opt.outfile);
 101       if (!fname)
 102         {
 103           err = gpg_error_from_syserror ();
 104           goto leave;
 105         }
 106     }
 107   else if (pt->namelen == 8 && !memcmp (pt->name, "_CONSOLE", 8))
 108     {
 109       log_info (_("data not saved; use option \"--output\" to save it\n"));
 110       nooutput = 1;
 111     }
 112   else if (!opt.flags.use_embedded_filename)
 113     {
 114       fname = make_outfile_name (iobuf_get_real_fname (pt->buf));
 115       if (!fname)
 116         fname = ask_outfile_name (pt->name, pt->namelen);
 117       if (!fname)
 118         {
 119           err = gpg_error (GPG_ERR_GENERAL);    /* Can't create file. */
 120           goto leave;
 121         }
 122     }
 123   else
 124     fname = utf8_to_native (pt->name, pt->namelen, 0);
 125
 126   if (nooutput)
 127     ;
 128   else if (opt.outfp)
 129     {
 130       fp = opt.outfp;
 131       es_set_binary (fp);
 132     }
 133   else if (iobuf_is_pipe_filename (fname) || !*fname)
 134     {
 135       /* No filename or "-" given; write to stdout. */
 136       fp = es_stdout;
 137       es_set_binary (fp);
 138     }
 139   else
 140     {
 141       while (!overwrite_filep (fname))
 142         {
 143           char *tmp = ask_outfile_name (NULL, 0);
 144           if (!tmp || !*tmp)
 145             {
 146               xfree (tmp);
 147               /* FIXME: Below used to be GPG_ERR_CREATE_FILE */
 148               err = gpg_error (GPG_ERR_GENERAL);
 149               goto leave;
 150             }
 151           xfree (fname);
 152           fname = tmp;
 153         }
 154     }
 155
 156 #ifndef __riscos__
 157   if (opt.outfp && is_secured_file (es_fileno (opt.outfp)))
 158     {
 159       err = gpg_error (GPG_ERR_EPERM);
 160       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
 161       goto leave;
 162     }
 163   else if (fp || nooutput)
 164     ;
 165   else if (is_secured_filename (fname))
 166     {
 167       gpg_err_set_errno (EPERM);
 168       err = gpg_error_from_syserror ();
 169       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
 170       goto leave;
 171     }
 172   else if (!(fp = es_fopen (fname, "wb")))
 173     {
 174       err = gpg_error_from_syserror ();
 175       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
 176       goto leave;
 177     }
 178 #else /* __riscos__ */
 179   /* If no output filename was given, i.e. we constructed it, convert
 180      all '.' in fname to '/' but not vice versa as we don't create
 181      directories! */
 182   if (!opt.outfile)
 183     for (c = 0; fname[c]; ++c)
 184       if (fname[c] == '.')
 185         fname[c] = '/';
 186
 187   if (fp || nooutput)
 188     ;
 189   else
 190     {
 191       /* Note: riscos stuff is not expected to wrok anymore.  If we
 192          want to port it again to riscos we should do most of the suff
 193          in estream.  FIXME: Consider to remove all riscos special
 194          cases.  */
 195       fp = fopen (fname, "wb");
 196       if (!fp)
 197         {
 198           log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
 199           err = GPG_ERR_CREATE_FILE;
 200           if (errno == 106)
 201             log_info ("Do output file and input file have the same name?\n");
 202           goto leave;
 203         }
 204
 205       /* If there's a ,xxx extension in the embedded filename,
 206          use that, else check whether the user input (in fname)
 207          has a ,xxx appended, then use that in preference */
 208       if ((c = riscos_get_filetype_from_string (pt->name, pt->namelen)) != -1)
 209         filetype = c;
 210       if ((c = riscos_get_filetype_from_string (fname, strlen (fname))) != -1)
 211         filetype = c;
 212       riscos_set_filetype_by_number (fname, filetype);
 213     }
 214 #endif /* __riscos__ */
 215
 216   if (!pt->is_partial)
 217     {
 218       /* We have an actual length (which might be zero). */
 219
 220       if (clearsig)
 221         {
 222           log_error ("clearsig encountered while not expected\n");
 223           err = gpg_error (GPG_ERR_UNEXPECTED);
 224           goto leave;
 225         }
 226
 227       if (convert) /* Text mode.  */
 228         {
 229           for (; pt->len; pt->len--)
 230             {
 231               if ((c = iobuf_get (pt->buf)) == -1)
 232                 {
 233                   err = gpg_error_from_syserror ();
 234                   log_error ("problem reading source (%u bytes remaining)\n",
 235                              (unsigned) pt->len);
 236                   goto leave;
 237                 }
 238               if (mfx->md)
 239                 gcry_md_putc (mfx->md, c);
 240 #ifndef HAVE_DOSISH_SYSTEM
 241               if (c == '\r')    /* convert to native line ending */
 242                 continue;       /* fixme: this hack might be too simple */
 243 #endif
 244               if (fp)
 245                 {
 246                   if (opt.max_output && (++count) > opt.max_output)
 247                     {
 248                       log_error ("error writing to '%s': %s\n",
 249                                  fname, "exceeded --max-output limit\n");
 250                       err = gpg_error (GPG_ERR_TOO_LARGE);
 251                       goto leave;
 252                     }
 253                   else if (es_putc (c, fp) == EOF)
 254                     {
 255                       if (es_ferror (fp))
 256                         err = gpg_error_from_syserror ();
 257                       else
 258                         err = gpg_error (GPG_ERR_EOF);
 259                       log_error ("error writing to '%s': %s\n",
 260                                  fname, gpg_strerror (err));
 261                       goto leave;
 262                     }
 263                 }
 264             }
 265         }
 266       else  /* Binary mode.  */
 267         {
 268           byte *buffer = xmalloc (32768);
 269           while (pt->len)
 270             {
 271               int len = pt->len > 32768 ? 32768 : pt->len;
 272               len = iobuf_read (pt->buf, buffer, len);
 273               if (len == -1)
 274                 {
 275                   err = gpg_error_from_syserror ();
 276                   log_error ("problem reading source (%u bytes remaining)\n",
 277                              (unsigned) pt->len);
 278                   xfree (buffer);
 279                   goto leave;
 280                 }
 281               if (mfx->md)
 282                 gcry_md_write (mfx->md, buffer, len);
 283               if (fp)
 284                 {
 285                   if (opt.max_output && (count += len) > opt.max_output)
 286                     {
 287                       log_error ("error writing to '%s': %s\n",
 288                                  fname, "exceeded --max-output limit\n");
 289                       err = gpg_error (GPG_ERR_TOO_LARGE);
 290                       xfree (buffer);
 291                       goto leave;
 292                     }
 293                   else if (es_fwrite (buffer, 1, len, fp) != len)
 294                     {
 295                       err = gpg_error_from_syserror ();
 296                       log_error ("error writing to '%s': %s\n",
 297                                  fname, gpg_strerror (err));
 298                       xfree (buffer);
 299                       goto leave;
 300                     }
 301                 }
 302               pt->len -= len;
 303             }
 304           xfree (buffer);
 305         }
 306     }
 307   else if (!clearsig)
 308     {
 309       if (convert)
 310         {                       /* text mode */
 311           while ((c = iobuf_get (pt->buf)) != -1)
 312             {
 313               if (mfx->md)
 314                 gcry_md_putc (mfx->md, c);
 315 #ifndef HAVE_DOSISH_SYSTEM
 316               if (convert && c == '\r')
 317                 continue;       /* fixme: this hack might be too simple */
 318 #endif
 319               if (fp)
 320                 {
 321                   if (opt.max_output && (++count) > opt.max_output)
 322                     {
 323                       log_error ("Error writing to '%s': %s\n",
 324                                  fname, "exceeded --max-output limit\n");
 325                       err = gpg_error (GPG_ERR_TOO_LARGE);
 326                       goto leave;
 327                     }
 328                   else if (es_putc (c, fp) == EOF)
 329                     {
 330                       if (es_ferror (fp))
 331                         err = gpg_error_from_syserror ();
 332                       else
 333                         err = gpg_error (GPG_ERR_EOF);
 334                       log_error ("error writing to '%s': %s\n",
 335                                  fname, gpg_strerror (err));
 336                       goto leave;
 337                     }
 338                 }
 339             }
 340         }
 341       else
 342         {                       /* binary mode */
 343           byte *buffer;
 344           int eof_seen = 0;
 345
 346           buffer = xtrymalloc (32768);
 347           if (!buffer)
 348             {
 349               err = gpg_error_from_syserror ();
 350               goto leave;
 351             }
 352
 353           while (!eof_seen)
 354             {
 355               /* Why do we check for len < 32768:
 356                * If we won't, we would practically read 2 EOFs but
 357                * the first one has already popped the block_filter
 358                * off and therefore we don't catch the boundary.
 359                * So, always assume EOF if iobuf_read returns less bytes
 360                * then requested */
 361               int len = iobuf_read (pt->buf, buffer, 32768);
 362               if (len == -1)
 363                 break;
 364               if (len < 32768)
 365                 eof_seen = 1;
 366               if (mfx->md)
 367                 gcry_md_write (mfx->md, buffer, len);
 368               if (fp)
 369                 {
 370                   if (opt.max_output && (count += len) > opt.max_output)
 371                     {
 372                       log_error ("error writing to '%s': %s\n",
 373                                  fname, "exceeded --max-output limit\n");
 374                       err = gpg_error (GPG_ERR_TOO_LARGE);
 375                       xfree (buffer);
 376                       goto leave;
 377                     }
 378                   else if (es_fwrite (buffer, 1, len, fp) != len)
 379                     {
 380                       err = gpg_error_from_syserror ();
 381                       log_error ("error writing to '%s': %s\n",
 382                                  fname, gpg_strerror (err));
 383                       xfree (buffer);
 384                       goto leave;
 385                     }
 386                 }
 387             }
 388           xfree (buffer);
 389         }
 390       pt->buf = NULL;
 391     }
 392   else /* Clear text signature - don't hash the last CR,LF.   */
 393     {
 394       int state = 0;
 395
 396       while ((c = iobuf_get (pt->buf)) != -1)
 397         {
 398           if (fp)
 399             {
 400               if (opt.max_output && (++count) > opt.max_output)
 401                 {
 402                   log_error ("error writing to '%s': %s\n",
 403                              fname, "exceeded --max-output limit\n");
 404                   err = gpg_error (GPG_ERR_TOO_LARGE);
 405                   goto leave;
 406                 }
 407               else if (es_putc (c, fp) == EOF)
 408                 {
 409                   err = gpg_error_from_syserror ();
 410                   log_error ("error writing to '%s': %s\n",
 411                              fname, gpg_strerror (err));
 412                   goto leave;
 413                 }
 414             }
 415           if (!mfx->md)
 416             continue;
 417           if (state == 2)
 418             {
 419               gcry_md_putc (mfx->md, '\r');
 420               gcry_md_putc (mfx->md, '\n');
 421               state = 0;
 422             }
 423           if (!state)
 424             {
 425               if (c == '\r')
 426                 state = 1;
 427               else if (c == '\n')
 428                 state = 2;
 429               else
 430                 gcry_md_putc (mfx->md, c);
 431             }
 432           else if (state == 1)
 433             {
 434               if (c == '\n')
 435                 state = 2;
 436               else
 437                 {
 438                   gcry_md_putc (mfx->md, '\r');
 439                   if (c == '\r')
 440                     state = 1;
 441                   else
 442                     {
 443                       state = 0;
 444                       gcry_md_putc (mfx->md, c);
 445                     }
 446                 }
 447             }
 448         }
 449       pt->buf = NULL;
 450     }
 451
 452   if (fp && fp != es_stdout && fp != opt.outfp && es_fclose (fp))
 453     {
 454       err = gpg_error_from_syserror ();
 455       log_error ("error closing '%s': %s\n", fname, gpg_strerror (err));
 456       fp = NULL;
 457       goto leave;
 458     }
 459   fp = NULL;
 460
 461  leave:
 462   /* Make sure that stdout gets flushed after the plaintext has been
 463      handled.  This is for extra security as we do a flush anyway
 464      before checking the signature.  */
 465   if (es_fflush (es_stdout))
 466     {
 467       /* We need to check the return code to detect errors like disk
 468          full for short plaintexts.  See bug#1207.  Checking return
 469          values is a good idea in any case.  */
 470       if (!err)
 471         err = gpg_error_from_syserror ();
 472       log_error ("error flushing '%s': %s\n", "[stdout]",
 473                  gpg_strerror (err));
 474     }
 475
 476   if (fp && fp != es_stdout && fp != opt.outfp)
 477     es_fclose (fp);
 478   xfree (fname);
 479   return err;
 480 }
 481
 482
 483 static void
 484 do_hash (gcry_md_hd_t md, gcry_md_hd_t md2, IOBUF fp, int textmode)
 485 {
 486   text_filter_context_t tfx;
 487   int c;
 488
 489   if (textmode)
 490     {
 491       memset (&tfx, 0, sizeof tfx);
 492       iobuf_push_filter (fp, text_filter, &tfx);
 493     }
 494   if (md2)
 495     {                           /* work around a strange behaviour in pgp2 */
 496       /* It seems that at least PGP5 converts a single CR to a CR,LF too */
 497       int lc = -1;
 498       while ((c = iobuf_get (fp)) != -1)
 499         {
 500           if (c == '\n' && lc == '\r')
 501             gcry_md_putc (md2, c);
 502           else if (c == '\n')
 503             {
 504               gcry_md_putc (md2, '\r');
 505               gcry_md_putc (md2, c);
 506             }
 507           else if (c != '\n' && lc == '\r')
 508             {
 509               gcry_md_putc (md2, '\n');
 510               gcry_md_putc (md2, c);
 511             }
 512           else
 513             gcry_md_putc (md2, c);
 514
 515           if (md)
 516             gcry_md_putc (md, c);
 517           lc = c;
 518         }
 519     }
 520   else
 521     {
 522       while ((c = iobuf_get (fp)) != -1)
 523         {
 524           if (md)
 525             gcry_md_putc (md, c);
 526         }
 527     }
 528 }
 529
 530
 531 /****************
 532  * Ask for the detached datafile and calculate the digest from it.
 533  * INFILE is the name of the input file.
 534  */
 535 int
 536 ask_for_detached_datafile (gcry_md_hd_t md, gcry_md_hd_t md2,
 537                            const char *inname, int textmode)
 538 {
 539   progress_filter_context_t *pfx;
 540   char *answer = NULL;
 541   IOBUF fp;
 542   int rc = 0;
 543
 544   pfx = new_progress_context ();
 545   fp = open_sigfile (inname, pfx);      /* Open default file. */
 546
 547   if (!fp && !opt.batch)
 548     {
 549       int any = 0;
 550       tty_printf (_("Detached signature.\n"));
 551       do
 552         {
 553           char *name;
 554
 555           xfree (answer);
 556           tty_enable_completion (NULL);
 557           name = cpr_get ("detached_signature.filename",
 558                           _("Please enter name of data file: "));
 559           tty_disable_completion ();
 560           cpr_kill_prompt ();
 561           answer = make_filename (name, (void *) NULL);
 562           xfree (name);
 563
 564           if (any && !*answer)
 565             {
 566               rc = gpg_error (GPG_ERR_GENERAL); /*G10ERR_READ_FILE */
 567               goto leave;
 568             }
 569           fp = iobuf_open (answer);
 570           if (fp && is_secured_file (iobuf_get_fd (fp)))
 571             {
 572               iobuf_close (fp);
 573               fp = NULL;
 574               gpg_err_set_errno (EPERM);
 575             }
 576           if (!fp && errno == ENOENT)
 577             {
 578               tty_printf ("No such file, try again or hit enter to quit.\n");
 579               any++;
 580             }
 581           else if (!fp)
 582             {
 583               rc = gpg_error_from_syserror ();
 584               log_error (_("can't open '%s': %s\n"), answer,
 585                          strerror (errno));
 586               goto leave;
 587             }
 588         }
 589       while (!fp);
 590     }
 591
 592   if (!fp)
 593     {
 594       if (opt.verbose)
 595         log_info (_("reading stdin ...\n"));
 596       fp = iobuf_open (NULL);
 597       assert (fp);
 598     }
 599   do_hash (md, md2, fp, textmode);
 600   iobuf_close (fp);
 601
 602 leave:
 603   xfree (answer);
 604   release_progress_context (pfx);
 605   return rc;
 606 }
 607
 608
 609
 610 /* Hash the given files and append the hash to hash contexts MD and
 611  * MD2.  If FILES is NULL, stdin is hashed.  */
 612 int
 613 hash_datafiles (gcry_md_hd_t md, gcry_md_hd_t md2, strlist_t files,
 614                 const char *sigfilename, int textmode)
 615 {
 616   progress_filter_context_t *pfx;
 617   IOBUF fp;
 618   strlist_t sl;
 619
 620   pfx = new_progress_context ();
 621
 622   if (!files)
 623     {
 624       /* Check whether we can open the signed material.  We avoid
 625          trying to open a file if run in batch mode.  This assumed
 626          data file for a sig file feature is just a convenience thing
 627          for the command line and the user needs to read possible
 628          warning messages. */
 629       if (!opt.batch)
 630         {
 631           fp = open_sigfile (sigfilename, pfx);
 632           if (fp)
 633             {
 634               do_hash (md, md2, fp, textmode);
 635               iobuf_close (fp);
 636               release_progress_context (pfx);
 637               return 0;
 638             }
 639         }
 640       log_error (_("no signed data\n"));
 641       release_progress_context (pfx);
 642       return gpg_error (GPG_ERR_NO_DATA);
 643     }
 644
 645
 646   for (sl = files; sl; sl = sl->next)
 647     {
 648       fp = iobuf_open (sl->d);
 649       if (fp && is_secured_file (iobuf_get_fd (fp)))
 650         {
 651           iobuf_close (fp);
 652           fp = NULL;
 653           gpg_err_set_errno (EPERM);
 654         }
 655       if (!fp)
 656         {
 657           int rc = gpg_error_from_syserror ();
 658           log_error (_("can't open signed data '%s'\n"),
 659                      print_fname_stdin (sl->d));
 660           release_progress_context (pfx);
 661           return rc;
 662         }
 663       handle_progress (pfx, fp, sl->d);
 664       do_hash (md, md2, fp, textmode);
 665       iobuf_close (fp);
 666     }
 667
 668   release_progress_context (pfx);
 669   return 0;
 670 }
 671
 672
 673 /* Hash the data from file descriptor DATA_FD and append the hash to hash
 674    contexts MD and MD2.  */
 675 int
 676 hash_datafile_by_fd (gcry_md_hd_t md, gcry_md_hd_t md2, int data_fd,
 677                      int textmode)
 678 {
 679   progress_filter_context_t *pfx = new_progress_context ();
 680   iobuf_t fp;
 681
 682   if (is_secured_file (data_fd))
 683     {
 684       fp = NULL;
 685       gpg_err_set_errno (EPERM);
 686     }
 687   else
 688     fp = iobuf_fdopen_nc (data_fd, "rb");
 689
 690   if (!fp)
 691     {
 692       int rc = gpg_error_from_syserror ();
 693       log_error (_("can't open signed data fd=%d: %s\n"),
 694                  data_fd, strerror (errno));
 695       release_progress_context (pfx);
 696       return rc;
 697     }
 698
 699   handle_progress (pfx, fp, NULL);
 700
 701   do_hash (md, md2, fp, textmode);
 702
 703   iobuf_close (fp);
 704
 705   release_progress_context (pfx);
 706   return 0;
 707 }
 708
 709
 710 /* Set up a plaintext packet with the appropriate filename.  If there
 711    is a --set-filename, use it (it's already UTF8).  If there is a
 712    regular filename, UTF8-ize it if necessary.  If there is no
 713    filenames at all, set the field empty. */
 714
 715 PKT_plaintext *
 716 setup_plaintext_name (const char *filename, IOBUF iobuf)
 717 {
 718   PKT_plaintext *pt;
 719
 720   if ((filename && !iobuf_is_pipe_filename (filename))
 721        || (opt.set_filename && !iobuf_is_pipe_filename (opt.set_filename)))
 722     {
 723       char *s;
 724
 725       if (opt.set_filename)
 726         s = make_basename (opt.set_filename, iobuf_get_real_fname (iobuf));
 727       else if (filename && !opt.flags.utf8_filename)
 728         {
 729           char *tmp = native_to_utf8 (filename);
 730           s = make_basename (tmp, iobuf_get_real_fname (iobuf));
 731           xfree (tmp);
 732         }
 733       else
 734         s = make_basename (filename, iobuf_get_real_fname (iobuf));
 735
 736       pt = xmalloc (sizeof *pt + strlen (s) - 1);
 737       pt->namelen = strlen (s);
 738       memcpy (pt->name, s, pt->namelen);
 739       xfree (s);
 740     }
 741   else
 742     {
 743       /* no filename */
 744       pt = xmalloc (sizeof *pt - 1);
 745       pt->namelen = 0;
 746     }
 747
 748   return pt;
 749 }