The Tor Browser: uriloader/exthandler/mac/nsDecodeAppleFile.cpp@4ab42b5ab56c (annotated)

uriloader/exthandler/mac/nsDecodeAppleFile.cpp@4ab42b5ab56c (annotated)

uriloader/exthandler/mac/nsDecodeAppleFile.cpp

Wed, 31 Dec 2014 07:53:36 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:53:36 +0100
branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c
permissions: -rw-r--r--

Correct small whitespace inconsistency, lost while renaming variables.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsDecodeAppleFile.h"
 #include "prmem.h"
 #include "nsCRT.h"
 NS_IMPL_ADDREF(nsDecodeAppleFile)
 NS_IMPL_RELEASE(nsDecodeAppleFile)
 NS_INTERFACE_MAP_BEGIN(nsDecodeAppleFile)
    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIOutputStream)
    NS_INTERFACE_MAP_ENTRY(nsIOutputStream)
 NS_INTERFACE_MAP_END_THREADSAFE
 nsDecodeAppleFile::nsDecodeAppleFile()
 {
   m_state = parseHeaders;
   m_dataBufferLength = 0;
   m_dataBuffer = (unsigned char*) PR_MALLOC(MAX_BUFFERSIZE);
   m_entries = nullptr;
   m_rfRefNum = -1;
   m_totalDataForkWritten = 0;
   m_totalResourceForkWritten = 0;
   m_headerOk = false;
   m_comment[0] = 0;
   memset(&m_dates, 0, sizeof(m_dates));
   memset(&m_finderInfo, 0, sizeof(m_dates));
   memset(&m_finderExtraInfo, 0, sizeof(m_dates));
 }
 nsDecodeAppleFile::~nsDecodeAppleFile()
 {
   PR_FREEIF(m_dataBuffer);
   if (m_entries)
     delete [] m_entries;
 }
 NS_IMETHODIMP nsDecodeAppleFile::Initialize(nsIOutputStream *output, nsIFile *file)
 {
   m_output = output;
   nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(file);
   macFile->GetTargetFSSpec(&m_fsFileSpec);
   m_offset = 0;
   m_dataForkOffset = 0;
   return NS_OK;
 }
 NS_IMETHODIMP nsDecodeAppleFile::Close(void)
 {
   nsresult rv;
   rv = m_output->Close();
   int32_t i;
   if (m_rfRefNum != -1)
     FSClose(m_rfRefNum);
   /* Check if the file is complete and if it's the case, write file attributes */
   if (m_headerOk)
   {
     bool dataOk = true; /* It's ok if the file doesn't have a datafork, therefore set it to true by default. */
     if (m_headers.magic == APPLESINGLE_MAGIC)
     {
       for (i = 0; i < m_headers.entriesCount; i ++)
         if (ENT_DFORK == m_entries[i].id)
         {
           dataOk = (bool)(m_totalDataForkWritten == m_entries[i].length);
           break;
         }
     }
     bool resourceOk = FALSE;
     for (i = 0; i < m_headers.entriesCount; i ++)
       if (ENT_RFORK == m_entries[i].id)
       {
         resourceOk = (bool)(m_totalResourceForkWritten == m_entries[i].length);
         break;
       }
     if (dataOk && resourceOk)
     {
       HFileInfo *fpb;
       CInfoPBRec cipbr;
       fpb = (HFileInfo *) &cipbr;
       fpb->ioVRefNum = m_fsFileSpec.vRefNum;
       fpb->ioDirID   = m_fsFileSpec.parID;
       fpb->ioNamePtr = m_fsFileSpec.name;
       fpb->ioFDirIndex = 0;
       PBGetCatInfoSync(&cipbr);
       /* set finder info */
       memcpy(&fpb->ioFlFndrInfo, &m_finderInfo, sizeof (FInfo));
       memcpy(&fpb->ioFlXFndrInfo, &m_finderExtraInfo, sizeof (FXInfo));
       fpb->ioFlFndrInfo.fdFlags &= 0xfc00; /* clear flags maintained by finder */
       /* set file dates */
       fpb->ioFlCrDat = m_dates.create - CONVERT_TIME;
       fpb->ioFlMdDat = m_dates.modify - CONVERT_TIME;
       fpb->ioFlBkDat = m_dates.backup - CONVERT_TIME;
       /* update file info */
       fpb->ioDirID = fpb->ioFlParID;
       PBSetCatInfoSync(&cipbr);
       /* set comment */
       IOParam vinfo;
       GetVolParmsInfoBuffer vp;
       DTPBRec dtp;
       memset((void *) &vinfo, 0, sizeof (vinfo));
       vinfo.ioVRefNum = fpb->ioVRefNum;
       vinfo.ioBuffer  = (Ptr) &vp;
       vinfo.ioReqCount = sizeof (vp);
       if (PBHGetVolParmsSync((HParmBlkPtr) &vinfo) == noErr && ((vp.vMAttrib >> bHasDesktopMgr) & 1))
       {
         memset((void *) &dtp, 0, sizeof (dtp));
         dtp.ioVRefNum = fpb->ioVRefNum;
         if (PBDTGetPath(&dtp) == noErr)
         {
           dtp.ioDTBuffer = (Ptr) &m_comment[1];
           dtp.ioNamePtr  = fpb->ioNamePtr;
           dtp.ioDirID    = fpb->ioDirID;
           dtp.ioDTReqCount = m_comment[0];
           if (PBDTSetCommentSync(&dtp) == noErr)
             PBDTFlushSync(&dtp);
         }
       }
     }
   }
   return rv;
 }
 NS_IMETHODIMP nsDecodeAppleFile::Flush(void)
 {
   return m_output->Flush();
 }
 NS_IMETHODIMP nsDecodeAppleFile::WriteFrom(nsIInputStream *inStr, uint32_t count, uint32_t *_retval)
 {
   return m_output->WriteFrom(inStr, count, _retval);
 }
 NS_IMETHODIMP nsDecodeAppleFile::WriteSegments(nsReadSegmentFun reader, void * closure, uint32_t count, uint32_t *_retval)
 {
   return m_output->WriteSegments(reader, closure, count, _retval);
 }
 NS_IMETHODIMP nsDecodeAppleFile::IsNonBlocking(bool *aNonBlocking)
 {
   return m_output->IsNonBlocking(aNonBlocking);
 }
 NS_IMETHODIMP nsDecodeAppleFile::Write(const char *buffer, uint32_t bufferSize, uint32_t* writeCount)
 {
   /* WARNING: to simplify my life, I presume that I should get all appledouble headers in the first block,
               else I would have to implement a buffer */
   const char * buffPtr = buffer;
   uint32_t dataCount;
   int32_t i;
   nsresult rv = NS_OK;
   *writeCount = 0;
   while (bufferSize > 0 && NS_SUCCEEDED(rv))
   {
     switch (m_state)
     {
       case parseHeaders :
         dataCount = sizeof(ap_header) - m_dataBufferLength;
         if (dataCount > bufferSize)
           dataCount = bufferSize;
         memcpy(&m_dataBuffer[m_dataBufferLength], buffPtr, dataCount);
         m_dataBufferLength += dataCount;
         if (m_dataBufferLength == sizeof(ap_header))
         {
           memcpy(&m_headers, m_dataBuffer, sizeof(ap_header));
           /* Check header to be sure we are dealing with the right kind of data, else just write it to the data fork. */
           if ((m_headers.magic == APPLEDOUBLE_MAGIC || m_headers.magic == APPLESINGLE_MAGIC) &&
               m_headers.version == VERSION && m_headers.entriesCount)
           {
             /* Just to be sure, the filler must contains only 0 */
             for (i = 0; i < 4 && m_headers.fill[i] == 0L; i ++)
               ;
             if (i == 4)
               m_state = parseEntries;
           }
           m_dataBufferLength = 0;
           if (m_state == parseHeaders)
           {
             dataCount = 0;
             m_state = parseWriteThrough;
           }
         }
         break;
       case parseEntries :
         if (!m_entries)
         {
           m_entries = new ap_entry[m_headers.entriesCount];
           if (!m_entries)
             return NS_ERROR_OUT_OF_MEMORY;
         }
         uint32_t entriesSize = sizeof(ap_entry) * m_headers.entriesCount;
         dataCount = entriesSize - m_dataBufferLength;
         if (dataCount > bufferSize)
           dataCount = bufferSize;
         memcpy(&m_dataBuffer[m_dataBufferLength], buffPtr, dataCount);
         m_dataBufferLength += dataCount;
         if (m_dataBufferLength == entriesSize)
         {
           for (i = 0; i < m_headers.entriesCount; i ++)
           {
             memcpy(&m_entries[i], &m_dataBuffer[i * sizeof(ap_entry)], sizeof(ap_entry));
             if (m_headers.magic == APPLEDOUBLE_MAGIC)
             {
               uint32_t offset = m_entries[i].offset + m_entries[i].length;
               if (offset > m_dataForkOffset)
                 m_dataForkOffset = offset;
             }
           }
           m_headerOk = true;
           m_state = parseLookupPart;
         }
         break;
       case parseLookupPart :
         /* which part are we parsing? */
         m_currentPartID = -1;
         for (i = 0; i < m_headers.entriesCount; i ++)
           if (m_offset == m_entries[i].offset && m_entries[i].length)
           {
               m_currentPartID = m_entries[i].id;
               m_currentPartLength = m_entries[i].length;
               m_currentPartCount = 0;
               switch (m_currentPartID)
               {
                 case ENT_DFORK    : m_state = parseDataFork;           break;
                 case ENT_RFORK    : m_state = parseResourceFork;       break;
                 case ENT_COMMENT  :
                 case ENT_DATES    :
                 case ENT_FINFO    :
                   m_dataBufferLength = 0;
                   m_state = parsePart;
                   break;
                 default           : m_state = parseSkipPart;           break;
               }
               break;
           }
         if (m_currentPartID == -1)
         {
           /* maybe is the datafork of an appledouble file? */
           if (m_offset == m_dataForkOffset)
           {
               m_currentPartID = ENT_DFORK;
               m_currentPartLength = -1;
               m_currentPartCount = 0;
               m_state = parseDataFork;
           }
           else
             dataCount = 1;
         }
         break;
       case parsePart :
         dataCount = m_currentPartLength - m_dataBufferLength;
         if (dataCount > bufferSize)
           dataCount = bufferSize;
         memcpy(&m_dataBuffer[m_dataBufferLength], buffPtr, dataCount);
         m_dataBufferLength += dataCount;
         if (m_dataBufferLength == m_currentPartLength)
         {
           switch (m_currentPartID)
           {
             case ENT_COMMENT  :
               m_comment[0] = m_currentPartLength > 255 ? 255 : m_currentPartLength;
               memcpy(&m_comment[1], buffPtr, m_comment[0]);
               break;
             case ENT_DATES    :
               if (m_currentPartLength == sizeof(m_dates))
                 memcpy(&m_dates, buffPtr, m_currentPartLength);
               break;
             case ENT_FINFO    :
               if (m_currentPartLength == (sizeof(m_finderInfo) + sizeof(m_finderExtraInfo)))
               {
                 memcpy(&m_finderInfo, buffPtr, sizeof(m_finderInfo));
                 memcpy(&m_finderExtraInfo, buffPtr + sizeof(m_finderInfo), sizeof(m_finderExtraInfo));
               }
               break;
           }
           m_state = parseLookupPart;
         }
         break;
       case parseSkipPart :
         dataCount = m_currentPartLength - m_currentPartCount;
         if (dataCount > bufferSize)
           dataCount = bufferSize;
         else
           m_state = parseLookupPart;
         break;
       case parseDataFork :
         if (m_headers.magic == APPLEDOUBLE_MAGIC)
           dataCount = bufferSize;
         else
         {
           dataCount = m_currentPartLength - m_currentPartCount;
           if (dataCount > bufferSize)
             dataCount = bufferSize;
           else
             m_state = parseLookupPart;
         }
         if (m_output)
         {
           uint32_t writeCount;
           rv = m_output->Write((const char *)buffPtr, dataCount, &writeCount);
           if (dataCount != writeCount)
             rv = NS_ERROR_FAILURE;
           m_totalDataForkWritten += dataCount;
         }
         break;
       case parseResourceFork :
         dataCount = m_currentPartLength - m_currentPartCount;
         if (dataCount > bufferSize)
           dataCount = bufferSize;
         else
           m_state = parseLookupPart;
         if (m_rfRefNum == -1)
         {
           if (noErr != FSpOpenRF(&m_fsFileSpec, fsWrPerm, &m_rfRefNum))
             return NS_ERROR_FAILURE;
         }
         long count = dataCount;
         if (noErr != FSWrite(m_rfRefNum, &count, buffPtr) || count != dataCount)
             return NS_ERROR_FAILURE;
         m_totalResourceForkWritten += dataCount;
         break;
       case parseWriteThrough :
         dataCount = bufferSize;
         if (m_output)
         {
           uint32_t writeCount;
           rv = m_output->Write((const char *)buffPtr, dataCount, &writeCount);
           if (dataCount != writeCount)
             rv = NS_ERROR_FAILURE;
         }
         break;
     }
     if (dataCount)
     {
       *writeCount += dataCount;
       bufferSize -= dataCount;
       buffPtr += dataCount;
       m_currentPartCount += dataCount;
       m_offset += dataCount;
       dataCount = 0;
     }
   }
   return rv;
 }

The Tor Browser / annotate

uriloader/exthandler/mac/nsDecodeAppleFile.cpp@4ab42b5ab56c (annotated)

uriloader/exthandler/mac/nsDecodeAppleFile.cpp