widget/src/photon/nsClipboard.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is mozilla.org code.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications Corporation.
  20  * Portions created by the Initial Developer are Copyright (C) 1999-2000
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Stuart Parmenter <pavlov@netscape.com>
  25  *   Mike Pinkerton <pinkerton@netscape.com>
  26  *   Dan Rosen <dr@netscape.com>
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * either the GNU General Public License Version 2 or later (the "GPL"), or
  30  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  31  * in which case the provisions of the GPL or the LGPL are applicable instead
  32  * of those above. If you wish to allow use of your version of this file only
  33  * under the terms of either the GPL or the LGPL, and not to allow others to
  34  * use your version of this file under the terms of the MPL, indicate your
  35  * decision by deleting the provisions above and replace them with the notice
  36  * and other provisions required by the GPL or the LGPL. If you do not delete
  37  * the provisions above, a recipient may use your version of this file under
  38  * the terms of any one of the MPL, the GPL or the LGPL.
  39  *
  40  * ***** END LICENSE BLOCK ***** */
  41
  42 #include "nsClipboard.h"
  43
  44 #include <Pt.h>
  45
  46 #include "nsCOMPtr.h"
  47 #include "nsCRT.h"
  48 #include "nsISupportsArray.h"
  49 #include "nsISupportsPrimitives.h"
  50 #include "nsReadableUtils.h"
  51
  52 #include "nsIComponentManager.h"
  53 #include "nsIServiceManager.h"
  54 #include "nsWidgetsCID.h"
  55 #include "nsXPIDLString.h"
  56 #include "nsReadableUtils.h"
  57 #include "nsPrimitiveHelpers.h"
  58
  59 #include "nsTextFormatter.h"
  60
  61 #include "nsIServiceManager.h"
  62 #include "nsICharsetConverterManager.h"
  63
  64 #include "prtime.h"
  65 #include "prthread.h"
  66
  67 // unicode conversion
  68 #include "nsIPlatformCharset.h"
  69 #include "nsICharsetConverterManager.h"
  70
  71 //#define DEBUG_CLIPBOARD
  72
  73
  74 // Define this to enable the obsolete X cut buffer mechanism
  75 // In general, a bad idea (see http://www.jwz.org/doc/x-cut-and-paste.html)
  76 // but it might have its uses for backwards compatibility.
  77
  78 NS_IMPL_ISUPPORTS1(nsClipboard, nsIClipboard)
  79
  80 #define Ph_CLIPBOARD_TYPE_MOZ_BOOKMARK  "BOOK"
  81 #define Ph_CLIPBOARD_TYPE_IMAGE                 "IMAG"
  82 #define Ph_CLIPBOARD_TYPE_HTML                  "HTML"
  83
  84 //-------------------------------------------------------------------------
  85 //
  86 // nsClipboard constructor
  87 //
  88 //-------------------------------------------------------------------------
  89 nsClipboard::nsClipboard()
  90 {
  91 #ifdef DEBUG_CLIPBOARD
  92   printf("nsClipboard::nsClipboard()\n");
  93 #endif /* DEBUG_CLIPBOARD */
  94
  95   mIgnoreEmptyNotification = PR_FALSE;
  96   mGlobalTransferable = nsnull;
  97   mSelectionTransferable = nsnull;
  98   mGlobalOwner = nsnull;
  99   mSelectionOwner = nsnull;
 100   mInputGroup = 1;
 101 }
 102
 103 //-------------------------------------------------------------------------
 104 //
 105 // nsClipboard destructor
 106 //
 107 //-------------------------------------------------------------------------
 108 nsClipboard::~nsClipboard()
 109 {
 110 #ifdef DEBUG_CLIPBOARD
 111   printf("nsClipboard::~nsClipboard()\n");
 112 #endif /* DEBUG_CLIPBOARD */
 113 }
 114
 115 /**
 116   * Sets the transferable object
 117   *
 118   */
 119 NS_IMETHODIMP nsClipboard::SetData(nsITransferable * aTransferable,
 120                                    nsIClipboardOwner * anOwner,
 121                                    PRInt32 aWhichClipboard)
 122 {
 123         if (aWhichClipboard == kSelectionClipboard)
 124                 return (NS_ERROR_FAILURE);
 125
 126         if ((aTransferable == mGlobalTransferable.get() && anOwner == mGlobalOwner.get() &&
 127                         aWhichClipboard == kGlobalClipboard ) || (aTransferable == mSelectionTransferable.get() &&
 128                         anOwner == mSelectionOwner.get() && aWhichClipboard == kSelectionClipboard))
 129         {
 130                 return NS_OK;
 131         }
 132
 133         EmptyClipboard(aWhichClipboard);
 134
 135         switch (aWhichClipboard)
 136         {
 137                 case kSelectionClipboard:
 138                         mSelectionOwner = anOwner;
 139                         mSelectionTransferable = aTransferable;
 140                         break;
 141                 case kGlobalClipboard:
 142                         mGlobalOwner = anOwner;
 143                         mGlobalTransferable = aTransferable;
 144                         break;
 145         }
 146
 147         return SetNativeClipboardData(aWhichClipboard);
 148 }
 149
 150 /**
 151   * Gets the transferable object
 152   *
 153   */
 154 NS_IMETHODIMP nsClipboard::GetData(nsITransferable * aTransferable, PRInt32 aWhichClipboard)
 155 {
 156         if (aWhichClipboard == kSelectionClipboard)
 157                 return (NS_ERROR_FAILURE);
 158         if (nsnull != aTransferable)
 159                 return GetNativeClipboardData(aTransferable, aWhichClipboard);
 160         else
 161         {
 162 #ifdef DEBUG_CLIPBOARD
 163                 printf("  nsClipboard::GetData(), aTransferable is NULL.\n");
 164 #endif
 165         }
 166
 167         return NS_ERROR_FAILURE;
 168 }
 169
 170
 171 /**
 172   *
 173   *
 174   */
 175 NS_IMETHODIMP nsClipboard::EmptyClipboard(PRInt32 aWhichClipboard)
 176 {
 177         if (mIgnoreEmptyNotification)
 178                 return NS_OK;
 179
 180         if (aWhichClipboard == kSelectionClipboard)
 181                 return (NS_ERROR_FAILURE);
 182
 183         switch(aWhichClipboard)
 184         {
 185                 case kSelectionClipboard:
 186                         return NS_ERROR_FAILURE;
 187                         if (mSelectionOwner)
 188                         {
 189                                 mSelectionOwner->LosingOwnership(mSelectionTransferable);
 190                                 mSelectionOwner = nsnull;
 191                         }
 192                         mSelectionTransferable = nsnull;
 193                         break;
 194                 case kGlobalClipboard:
 195                         if (mGlobalOwner)
 196                         {
 197                                 mGlobalOwner->LosingOwnership(mGlobalTransferable);
 198                                 mGlobalOwner = nsnull;
 199                         }
 200                         mGlobalTransferable = nsnull;
 201                         break;
 202         }
 203
 204         return NS_OK;
 205 }
 206
 207 NS_IMETHODIMP nsClipboard::SupportsSelectionClipboard(PRBool *_retval)
 208 {
 209   NS_ENSURE_ARG_POINTER(_retval);
 210
 211   *_retval = PR_FALSE; // we support the selection clipboard on unix.
 212   return NS_ERROR_FAILURE;
 213 }
 214
 215 //-------------------------------------------------------------------------
 216 NS_IMETHODIMP nsClipboard::SetNativeClipboardData(PRInt32 aWhichClipboard)
 217 {
 218         mIgnoreEmptyNotification = PR_TRUE;
 219         if (aWhichClipboard == kSelectionClipboard)
 220                 return (NS_ERROR_FAILURE);
 221
 222 #ifdef DEBUG_CLIPBOARD
 223         printf("  nsClipboard::SetNativeClipboardData(%i)\n", aWhichClipboard);
 224 #endif /* DEBUG_CLIPBOARD */
 225
 226                 nsCOMPtr<nsITransferable> transferable(GetTransferable(aWhichClipboard));
 227
 228         // make sure we have a good transferable
 229         if (nsnull == transferable)
 230         {
 231 #ifdef DEBUG_CLIPBOARD
 232                 printf("nsClipboard::SetNativeClipboardData(): no transferable!\n");
 233 #endif
 234                 return NS_ERROR_FAILURE;
 235         }
 236
 237         // get flavor list that includes all flavors that can be written (including ones
 238         // obtained through conversion)
 239         nsCOMPtr<nsISupportsArray> flavorList;
 240         nsresult errCode = transferable->FlavorsTransferableCanExport ( getter_AddRefs(flavorList) );
 241         if ( NS_FAILED(errCode) )
 242                 return NS_ERROR_FAILURE;
 243
 244         PRUint32 cnt, index = 0;
 245         flavorList->Count(&cnt);
 246         PhClipHeader *cliphdr = (PhClipHeader *) calloc( cnt, sizeof( PhClipHeader ));
 247         if( !cliphdr ) return NS_ERROR_FAILURE;
 248
 249         for ( PRUint32 k=0; k<cnt; ++k )
 250         {
 251                 void      *data = nsnull;
 252                 PRUint32   dataLen;
 253
 254                 nsCOMPtr<nsISupports> genericFlavor;
 255                 flavorList->GetElementAt ( k, getter_AddRefs(genericFlavor) );
 256                 nsCOMPtr<nsISupportsCString> currentFlavor ( do_QueryInterface(genericFlavor) );
 257                 if ( currentFlavor )
 258                 {
 259                         nsXPIDLCString flavorStr;
 260                         currentFlavor->ToString(getter_Copies(flavorStr));
 261
 262         nsresult err = GetFormat( flavorStr, cliphdr[index].type );
 263                         if( err != NS_OK )
 264                                 continue;
 265
 266                         // Get data out of transferable.
 267                         nsCOMPtr<nsISupports> genericDataWrapper;
 268                         transferable->GetTransferData( flavorStr, getter_AddRefs(genericDataWrapper), &dataLen );
 269                         nsPrimitiveHelpers::CreateDataFromPrimitive ( flavorStr, genericDataWrapper, &data, dataLen );
 270
 271                         if( !strcmp(cliphdr[index].type, Ph_CLIPBOARD_TYPE_TEXT) ||
 272                                         !strcmp(cliphdr[index].type, Ph_CLIPBOARD_TYPE_HTML) ||
 273                                         !strcmp(cliphdr[index].type, Ph_CLIPBOARD_TYPE_MOZ_BOOKMARK) )
 274                         {
 275                                 PRUnichar* castedUnicode = reinterpret_cast<PRUnichar*>(data);
 276                                 char *utf8String = ToNewUTF8String(nsDependentString(castedUnicode, dataLen/2));
 277                                 nsMemory::Free(reinterpret_cast<char*>(data));
 278
 279                                 if( !strcmp(cliphdr[index].type, Ph_CLIPBOARD_TYPE_TEXT) )
 280                                 {
 281                                         /* we have to create a null terminated string, because
 282                                                 PhClipboardCopyString does that and some other applications
 283                                                 rely on the null terminated thing
 284                                         */
 285                                         PRInt32 len = strlen(utf8String);
 286                                         char *temp = ( char * ) nsMemory::Alloc( len + 1 );
 287                                         memcpy( temp, utf8String, len );
 288                                         temp[len] = 0;
 289                                         nsMemory::Free(reinterpret_cast<char*>(utf8String));
 290
 291                 cliphdr[index].length = len+1;
 292                 cliphdr[index].data = temp;
 293                                 }
 294                         else {
 295                                 cliphdr[index].length = strlen(utf8String);
 296                                 cliphdr[index].data = utf8String;
 297                                 }
 298                         }
 299         index++;
 300                 }
 301         }
 302
 303         PhClipboardCopy( mInputGroup, index, cliphdr );
 304         for( PRUint32 k=0; k<index; k++)
 305                 nsMemory::Free(reinterpret_cast<char*>(cliphdr[k].data));
 306
 307         free( cliphdr );
 308
 309         mIgnoreEmptyNotification = PR_FALSE;
 310
 311         return NS_OK;
 312 }
 313
 314
 315 //-------------------------------------------------------------------------
 316 //
 317 // The blocking Paste routine
 318 //
 319 //-------------------------------------------------------------------------
 320 NS_IMETHODIMP
 321 nsClipboard::GetNativeClipboardData(nsITransferable * aTransferable,
 322                                     PRInt32 aWhichClipboard)
 323 {
 324         if (aWhichClipboard == kSelectionClipboard)
 325                 return (NS_ERROR_FAILURE);
 326
 327 #ifdef DEBUG_CLIPBOARD
 328         printf("nsClipboard::GetNativeClipboardData(%i)\n", aWhichClipboard);
 329 #endif /* DEBUG_CLIPBOARD */
 330
 331         // make sure we have a good transferable
 332         if (nsnull == aTransferable)
 333         {
 334 #ifdef DEBUG_CLIPBOARD
 335     printf("  GetNativeClipboardData: Transferable is null!\n");
 336 #endif
 337         return NS_ERROR_FAILURE;
 338         }
 339
 340         // get flavor list that includes all acceptable flavors (including ones obtained through
 341         // conversion)
 342         nsCOMPtr<nsISupportsArray> flavorList;
 343         nsresult errCode = aTransferable->FlavorsTransferableCanImport ( getter_AddRefs(flavorList) );
 344         if ( NS_FAILED(errCode) )
 345                 return NS_ERROR_FAILURE;
 346
 347         // Walk through flavors and see which flavor matches the one being pasted:
 348         PRUint32 cnt;
 349         flavorList->Count(&cnt);
 350         nsCAutoString foundFlavor;
 351
 352         if (cnt > 0)
 353         {
 354         void         *clipPtr;
 355         PhClipHeader *cliphdr;
 356         char         *data = nsnull, type[8];
 357         PRUint32      dataLen;
 358
 359         clipPtr = PhClipboardPasteStart( mInputGroup );
 360         if(!clipPtr) return NS_ERROR_FAILURE;
 361
 362         /*
 363                 Look at the timestamps of the data in the clipboard and eliminate the flavours if they are not synchronized.
 364                 We can have a HTML flavour from a previous copy and a TEXT flavour from a more recent copy from another application
 365                 ( from instance from ped or pterm ). The HTML flavour and TEXT flavour are desynchronized and we have
 366                 to use only the most recent one */
 367                 unsigned long *dont_use_flavour = ( unsigned long * ) calloc( cnt, sizeof( unsigned long ) );
 368                 if( !dont_use_flavour ) {
 369                         PhClipboardPasteFinish( clipPtr );
 370                         return NS_ERROR_FAILURE;
 371                         }
 372
 373                 unsigned long max_time = 0;
 374                 PRUint32 i;
 375
 376                 for ( i = 0; i < cnt; ++i )
 377                 {
 378                         nsCOMPtr<nsISupports> genericFlavor;
 379                         flavorList->GetElementAt ( i, getter_AddRefs(genericFlavor) );
 380                         nsCOMPtr<nsISupportsCString> currentFlavor ( do_QueryInterface(genericFlavor) );
 381                         if ( currentFlavor )
 382                         {
 383                                 nsXPIDLCString flavorStr;
 384                                 currentFlavor->ToString ( getter_Copies(flavorStr) );
 385
 386                                 nsresult err = GetFormat( flavorStr, type );
 387                                 if (err != NS_OK)
 388                                         continue;
 389
 390                         dont_use_flavour[i] = GetFlavourTimestamp( type );
 391                         if( dont_use_flavour[i] > max_time ) max_time = dont_use_flavour[i];
 392                         }
 393                 }
 394
 395                 for ( i = 0; i < cnt; ++i )
 396                 {
 397                 if( abs( dont_use_flavour[i] - max_time ) >= 4 )
 398                         dont_use_flavour[i] = 1; /* this flavour is desynchronized */
 399                 else dont_use_flavour[i] = 0; /* this flavour is ok */
 400                 }
 401
 402                 for ( i = 0; i < cnt; ++i )
 403                 {
 404                         if( dont_use_flavour[i] ) continue; /* this flavour is desynchronized */
 405                         nsCOMPtr<nsISupports> genericFlavor;
 406                         flavorList->GetElementAt ( i, getter_AddRefs(genericFlavor) );
 407                         nsCOMPtr<nsISupportsCString> currentFlavor ( do_QueryInterface(genericFlavor) );
 408                         if ( currentFlavor )
 409                         {
 410                                 nsXPIDLCString flavorStr;
 411                                 currentFlavor->ToString ( getter_Copies(flavorStr) );
 412
 413                                 nsresult err = GetFormat( flavorStr, type );
 414                                 if (err != NS_OK)
 415                                         continue;
 416
 417                                 cliphdr = PhClipboardPasteType( clipPtr, type );
 418                                 if (cliphdr)
 419                                 {
 420                                         data = (char*)cliphdr->data;
 421
 422                                         if( !strcmp(type, Ph_CLIPBOARD_TYPE_TEXT) )
 423                                                 /* for the Ph_CLIPBOARD_TYPE_TEXT, we null terminate the data, since PhClipboardCopyString() does that */
 424                                                 dataLen = cliphdr->length - 1;
 425                                         else dataLen = cliphdr->length;
 426
 427
 428                                         if( !strcmp(type, Ph_CLIPBOARD_TYPE_TEXT) ||
 429                                                         !strcmp(type, Ph_CLIPBOARD_TYPE_HTML) ||
 430                                                         !strcmp(type, Ph_CLIPBOARD_TYPE_MOZ_BOOKMARK) )
 431                                         {
 432                                                 nsresult rv;
 433                                                 PRInt32 outUnicodeLen;
 434                                                 PRUnichar *unicodeData = nsnull;
 435
 436                                 // get the decoder
 437                                 nsCOMPtr<nsIUnicodeDecoder> decoder;
 438                                 nsCOMPtr<nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
 439                                 rv = ccm->GetUnicodeDecoderRaw("UTF-8", getter_AddRefs(decoder));
 440
 441                                 if( NS_SUCCEEDED(rv) )
 442                                                         {
 443
 444                                         decoder->GetMaxLength(data, dataLen, &outUnicodeLen);   // |outUnicodeLen| is number of chars
 445                                         if (outUnicodeLen) {
 446                                         unicodeData = reinterpret_cast<PRUnichar*>(nsMemory::Alloc((outUnicodeLen + 1) * sizeof(PRUnichar)));
 447                                         if ( unicodeData ) {
 448                                                 PRInt32 numberTmp = dataLen;
 449                                                 rv = decoder->Convert(data, &numberTmp, unicodeData, &outUnicodeLen);
 450 #ifdef DEBUG_CLIPBOARD
 451                                                 if (numberTmp != dataLen)
 452                                                   printf("didn't consume all the bytes\n");
 453 #endif
 454
 455                                                 (unicodeData)[outUnicodeLen] = '\0';    // null terminate. Convert() doesn't do it for us
 456                                                 }
 457                                                                 } // if valid length
 458
 459
 460                                         data = reinterpret_cast<char*>(unicodeData);
 461                                         dataLen = outUnicodeLen * 2;
 462
 463                                                         nsCOMPtr<nsISupports> genericDataWrapper;
 464                                                         nsPrimitiveHelpers::CreatePrimitiveForData( flavorStr, data, dataLen, getter_AddRefs(genericDataWrapper) );
 465                                                         aTransferable->SetTransferData( flavorStr, genericDataWrapper, dataLen );
 466
 467                                                         /* free the allocated memory */
 468                                                         nsMemory::Free( unicodeData );
 469
 470                                         break;
 471                                                         }
 472                                         }
 473                 }
 474                         }
 475                 }
 476
 477                 free( dont_use_flavour );
 478                 PhClipboardPasteFinish( clipPtr );
 479         }
 480
 481         return NS_OK;
 482 }
 483
 484 NS_IMETHODIMP
 485 nsClipboard::HasDataMatchingFlavors(const char** aFlavorList,
 486                                     PRUint32 aLength,
 487                                     PRInt32 aWhichClipboard,
 488                                     PRBool * outResult)
 489 {
 490         if (aWhichClipboard == kSelectionClipboard)
 491                 return (NS_ERROR_FAILURE);
 492   // XXX this doesn't work right.  need to fix it.
 493
 494   // Note to implementor...(from pink the clipboard bitch).
 495   //
 496   // If a client asks for unicode, first check if unicode is present. If not, then
 497   // check for plain text. If it's there, say "yes" as we will do the conversion
 498   // in GetNativeClipboardData(). From this point on, no client will
 499   // ever ask for text/plain explicitly. If they do, you must ASSERT!
 500 #ifdef DEBUG_CLIPBOARD
 501         printf("  nsClipboard::HasDataMatchingFlavors()\n  {\n");
 502 #endif
 503
 504   nsresult res = NS_OK;
 505   * outResult = PR_FALSE;
 506
 507  // Walk through flavors and see which flavor matches the one being pasted:
 508   nsCAutoString foundFlavor;
 509   if (aLength > 0) {
 510     void         *clipPtr;
 511                 char                                    type[8];
 512     PhClipHeader *cliphdr;
 513
 514     clipPtr = PhClipboardPasteStart( 1 );
 515     if(nsnull == clipPtr)
 516         return res;
 517
 518     for ( PRUint32 i = 0; i < aLength; ++i ) {
 519       nsresult err = GetFormat( aFlavorList[i], type );
 520       if (err != NS_OK) continue;
 521
 522       cliphdr = PhClipboardPasteType( clipPtr, type );
 523       if (cliphdr)
 524       {
 525         res = NS_OK;
 526         *outResult = PR_TRUE;
 527         break;
 528       }
 529     }
 530     PhClipboardPasteFinish( clipPtr );
 531   }
 532
 533   return res;
 534 }
 535
 536
 537 nsresult nsClipboard::GetFormat(const char* aMimeStr, char *format )
 538 {
 539         nsDependentCString mimeStr(aMimeStr);
 540         int ret = NS_OK;
 541
 542         if( mimeStr.Equals(kUnicodeMime) || mimeStr.Equals(kTextMime) )
 543         strcpy( format, Ph_CLIPBOARD_TYPE_TEXT );
 544         else if( mimeStr.Equals(kHTMLMime) )
 545         strcpy( format, Ph_CLIPBOARD_TYPE_HTML );
 546         else if (mimeStr.Equals("moz/bookmarkclipboarditem"))
 547         strcpy( format, Ph_CLIPBOARD_TYPE_MOZ_BOOKMARK );
 548         else ret = NS_ERROR_FAILURE;
 549         return ret;
 550 }
 551
 552 /* inline */
 553 nsITransferable *nsClipboard::GetTransferable(PRInt32 aWhichClipboard)
 554 {
 555   nsITransferable *transferable = nsnull;
 556   switch (aWhichClipboard)
 557   {
 558   case kGlobalClipboard:
 559     transferable = mGlobalTransferable;
 560     break;
 561   case kSelectionClipboard:
 562     break;
 563   }
 564   return transferable;
 565 }
 566
 567 unsigned long nsClipboard::GetFlavourTimestamp( char *type)
 568 {
 569         char fname[512];
 570         extern struct _Ph_ctrl *_Ph_;
 571
 572   strcpy( fname, "/var/clipboard/" );
 573   if( access( fname, X_OK ) != 0 )
 574                 return 0;
 575
 576         struct stat buf;
 577         if( fstat( _Ph_->fd, &buf ) != 0 )
 578                 return 0;
 579
 580   if(gethostname(&fname[strlen(fname)],PATH_MAX-40)!=0)
 581     strcpy(&fname[strlen(fname)],"localhost");
 582
 583   sprintf( &fname[strlen(fname)], "/%08x/%d.%s",buf.st_uid, mInputGroup, type );
 584         struct stat st;
 585         if( stat( fname, &st ) != 0 )
 586                 return 0;
 587
 588         return st.st_mtime;
 589 }