Changeset 2460


Ignore:
Timestamp:
03/21/09 18:48:19 (5 years ago)
Author:
chris
Message:

Fix tests (hopefully) on Win32 for struct stat ino_t change from 16 to
64 bits.

Location:
box/trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • box/trunk/bin/bbackupd/BackupClientDirectoryRecord.cpp

    r2401 r2460  
    150150        MD5Digest currentStateChecksum; 
    151151         
    152         struct stat dest_st; 
     152        EMU_STRUCT_STAT dest_st; 
    153153        // Stat the directory, to get attribute info 
    154154        // If it's a symbolic link, we want the link target here 
    155155        // (as we're about to back up the contents of the directory) 
    156156        { 
    157                 if(::stat(rLocalPath.c_str(), &dest_st) != 0) 
     157                if(EMU_STAT(rLocalPath.c_str(), &dest_st) != 0) 
    158158                { 
    159159                        // The directory has probably been deleted, so 
     
    200200        bool downloadDirectoryRecordBecauseOfFutureFiles = false; 
    201201 
    202         struct stat link_st; 
    203         if(::lstat(rLocalPath.c_str(), &link_st) != 0) 
     202        EMU_STRUCT_STAT link_st; 
     203        if(EMU_LSTAT(rLocalPath.c_str(), &link_st) != 0) 
    204204        { 
    205205                // Report the error (logs and  
     
    259259         
    260260                        struct dirent *en = 0; 
    261                         struct stat file_st; 
     261                        EMU_STRUCT_STAT file_st; 
    262262                        std::string filename; 
    263263                        while((en = ::readdir(dirHandle)) != 0) 
     
    293293                                int type = en->d_type; 
    294294                                #else 
    295                                 if(::lstat(filename.c_str(), &file_st) != 0) 
     295                                if(EMU_LSTAT(filename.c_str(), &file_st) != 0) 
    296296                                { 
    297297                                        // Report the error (logs and  
     
    388388                                // We didn't stat the file before, 
    389389                                // but now we need the information. 
    390                                 if(::lstat(filename.c_str(), &file_st) != 0) 
     390                                if(emu_stat(filename.c_str(), &file_st) != 0) 
    391391                                { 
    392392                                        rNotifier.NotifyFileStatFailed(this,  
     
    688688                { 
    689689                        // Stat the file 
    690                         struct stat st; 
    691                         if(::lstat(filename.c_str(), &st) != 0) 
     690                        EMU_STRUCT_STAT st; 
     691                        if(EMU_LSTAT(filename.c_str(), &st) != 0) 
    692692                        { 
    693693                                rNotifier.NotifyFileStatFailed(this,  
     
    758758                                        { 
    759759                                                // Check that the object we found in the ID map doesn't exist on disc 
    760                                                 struct stat st; 
    761                                                 if(::stat(localPotentialOldName.c_str(), &st) != 0 && errno == ENOENT) 
     760                                                EMU_STRUCT_STAT st; 
     761                                                if(EMU_STAT(localPotentialOldName.c_str(), &st) != 0 && errno == ENOENT) 
    762762                                                { 
    763763                                                        // Doesn't exist locally, but does exist on the server. 
     
    12791279                                                { 
    12801280                                                        // Check that the object doesn't exist already 
    1281                                                         struct stat st; 
    1282                                                         if(::stat(localPotentialOldName.c_str(), &st) != 0 && errno == ENOENT) 
     1281                                                        EMU_STRUCT_STAT st; 
     1282                                                        if(EMU_STAT(localPotentialOldName.c_str(), &st) != 0 && errno == ENOENT) 
    12831283                                                        { 
    12841284                                                                // Doesn't exist locally, but does exist on the server. 
  • box/trunk/bin/bbackupd/Win32ServiceFunctions.cpp

    r2127 r2460  
    204204        if (pConfigFileName != NULL) 
    205205        { 
    206                 struct stat st; 
     206                EMU_STRUCT_STAT st; 
    207207 
    208208                if (emu_stat(pConfigFileName, &st) != 0) 
  • box/trunk/bin/bbackupquery/BackupQueries.cpp

    r2448 r2460  
    915915         
    916916        // Does file exist? 
    917         struct stat st; 
    918         if(::stat(args[1].c_str(), &st) == 0 || errno != ENOENT) 
     917        EMU_STRUCT_STAT st; 
     918        if(EMU_STAT(args[1].c_str(), &st) == 0 || errno != ENOENT) 
    919919        { 
    920920                BOX_ERROR("The local file '" << args[1] << " already exists."); 
     
    11471147         
    11481148        // Does local file already exist? (don't want to overwrite) 
    1149         struct stat st; 
    1150         if(::stat(localName.c_str(), &st) == 0 || errno != ENOENT) 
     1149        EMU_STRUCT_STAT st; 
     1150        if(EMU_STAT(localName.c_str(), &st) == 0 || errno != ENOENT) 
    11511151        { 
    11521152                BOX_ERROR("The local file " << localName << " already exists, " 
     
    12281228                syncTimeFilename += "last_sync_start"; 
    12291229                // Stat it to get file time 
    1230                 struct stat st; 
    1231                 if(::stat(syncTimeFilename.c_str(), &st) == 0) 
     1230                EMU_STRUCT_STAT st; 
     1231                if(EMU_STAT(syncTimeFilename.c_str(), &st) == 0) 
    12321232                { 
    12331233                        // Files modified after this time shouldn't be on the server, so report errors slightly differently 
     
    14051405                bool modifiedAfterLastSync = false; 
    14061406                 
    1407                 struct stat st; 
    1408                 if(::stat(rLocalDir.c_str(), &st) == 0) 
     1407                EMU_STRUCT_STAT st; 
     1408                if(EMU_STAT(rLocalDir.c_str(), &st) == 0) 
    14091409                { 
    14101410                        if(FileAttrModificationTime(st) > 
     
    14401440 
    14411441        // Get info on the local directory 
    1442         struct stat st; 
    1443         if(::lstat(rLocalDir.c_str(), &st) != 0) 
     1442        EMU_STRUCT_STAT st; 
     1443        if(EMU_LSTAT(rLocalDir.c_str(), &st) != 0) 
    14441444        { 
    14451445                // What kind of error? 
     
    14951495                        bool modifiedAfterLastSync = false; 
    14961496                         
    1497                         struct stat st; 
    1498                         if(::stat(rLocalDir.c_str(), &st) == 0) 
     1497                        EMU_STRUCT_STAT st; 
     1498                        if(EMU_STAT(rLocalDir.c_str(), &st) == 0) 
    14991499                        { 
    15001500                                if(FileAttrModificationTime(st) > 
     
    15481548                        std::string fn(MakeFullPath 
    15491549                                (rLocalDir, localDirEn->d_name)); 
    1550                         struct stat st; 
    1551                         if(::lstat(fn.c_str(), &st) != 0) 
     1550                        EMU_STRUCT_STAT st; 
     1551                        if(EMU_LSTAT(fn.c_str(), &st) != 0) 
    15521552                        { 
    15531553                            THROW_EXCEPTION(CommonException, OSFileError) 
     
    16391639                                int64_t fileSize = 0; 
    16401640 
    1641                                 struct stat st; 
    1642                                 if(::stat(localPath.c_str(), &st) == 0) 
     1641                                EMU_STRUCT_STAT st; 
     1642                                if(EMU_STAT(localPath.c_str(), &st) == 0) 
    16431643                                { 
    16441644                                        fileSize = st.st_size; 
     
    17721772                                bool modifiedAfterLastSync = false; 
    17731773                                 
    1774                                 struct stat st; 
    1775                                 if(::stat(localPath.c_str(), &st) == 0) 
     1774                                EMU_STRUCT_STAT st; 
     1775                                if(EMU_STAT(localPath.c_str(), &st) == 0) 
    17761776                                { 
    17771777                                        if(FileModificationTime(st) > 
     
    18461846                                 
    18471847                                // Check the dir modification time 
    1848                                 struct stat st; 
    1849                                 if(::stat(localPath.c_str(), &st) == 0 && 
     1848                                EMU_STRUCT_STAT st; 
     1849                                if(EMU_STAT(localPath.c_str(), &st) == 0 && 
    18501850                                        FileModificationTime(st) > 
    18511851                                        rParams.LatestFileUploadTime()) 
  • box/trunk/lib/backupclient/BackupClientFileAttributes.cpp

    r2360 r2460  
    303303        try 
    304304        { 
    305                 struct stat st; 
    306                 if(::lstat(Filename, &st) != 0) 
     305                EMU_STRUCT_STAT st; 
     306                if(EMU_LSTAT(Filename, &st) != 0) 
    307307                { 
    308308                        BOX_LOG_SYS_ERROR("Failed to stat file: '" << 
     
    396396// 
    397397// -------------------------------------------------------------------------- 
    398 void BackupClientFileAttributes::FillAttributes(StreamableMemBlock &outputBlock, const char *Filename, struct stat &st, bool ZeroModificationTimes) 
     398void BackupClientFileAttributes::FillAttributes(StreamableMemBlock &outputBlock, const char *Filename, EMU_STRUCT_STAT &st, bool ZeroModificationTimes) 
    399399{ 
    400400        outputBlock.ResizeBlock(sizeof(attr_StreamFormat)); 
     
    10381038// 
    10391039// -------------------------------------------------------------------------- 
    1040 uint64_t BackupClientFileAttributes::GenerateAttributeHash(struct stat &st, const std::string &filename, const std::string &leafname) 
     1040uint64_t BackupClientFileAttributes::GenerateAttributeHash(EMU_STRUCT_STAT &st, const std::string &filename, const std::string &leafname) 
    10411041{ 
    10421042        if(sAttributeHashSecretLength == 0) 
  • box/trunk/lib/backupclient/BackupClientFileAttributes.h

    r1618 r2460  
    1616#include "BoxTime.h" 
    1717 
    18 struct stat; 
     18EMU_STRUCT_STAT; // declaration 
    1919 
    2020// -------------------------------------------------------------------------- 
     
    5454        static void SetAttributeHashSecret(const void *pSecret, int SecretLength); 
    5555         
    56         static uint64_t GenerateAttributeHash(struct stat &st, const std::string &filename, const std::string &leafname); 
     56        static uint64_t GenerateAttributeHash(EMU_STRUCT_STAT &st, const std::string &filename, const std::string &leafname); 
    5757        static void FillExtendedAttr(StreamableMemBlock &outputBlock, const char *Filename); 
    5858 
    5959private: 
    60         static void FillAttributes(StreamableMemBlock &outputBlock, const char *Filename, struct stat &st, bool ZeroModificationTimes); 
     60        static void FillAttributes(StreamableMemBlock &outputBlock, 
     61                const char *Filename, EMU_STRUCT_STAT &st, 
     62                bool ZeroModificationTimes); 
    6163        static void FillAttributesLink(StreamableMemBlock &outputBlock, const char *Filename, struct stat &st); 
    6264        void WriteExtendedAttr(const char *Filename, int xattrOffset) const; 
  • box/trunk/lib/backupclient/BackupStoreFile.cpp

    r2245 r2460  
    273273{ 
    274274        // Does file exist? 
    275         struct stat st; 
    276         if(::stat(DecodedFilename, &st) == 0) 
     275        EMU_STRUCT_STAT st; 
     276        if(EMU_STAT(DecodedFilename, &st) == 0) 
    277277        { 
    278278                THROW_EXCEPTION(BackupStoreException, OutputFileAlreadyExists) 
     
    12611261        bool sourceIsSymlink = false; 
    12621262        { 
    1263                 struct stat st; 
    1264                 if(::lstat(Filename, &st) == -1) 
     1263                EMU_STRUCT_STAT st; 
     1264                if(EMU_LSTAT(Filename, &st) == -1) 
    12651265                { 
    12661266                        THROW_EXCEPTION(CommonException, OSFileError) 
  • box/trunk/lib/backupclient/BackupStoreFileDiff.cpp

    r2415 r2460  
    131131        // Is it a symlink? 
    132132        { 
    133                 struct stat st; 
    134                 if(::lstat(Filename, &st) != 0) 
     133                EMU_STRUCT_STAT st; 
     134                if(EMU_LSTAT(Filename, &st) != 0) 
    135135                { 
    136136                        THROW_EXCEPTION(CommonException, OSFileError) 
  • box/trunk/lib/backupstore/BackupStoreAccountDatabase.cpp

    r217 r2460  
    209209box_time_t BackupStoreAccountDatabase::GetDBFileModificationTime() const 
    210210{ 
    211         struct stat st; 
    212         if(::stat(pImpl->mFilename.c_str(), &st) == -1) 
     211        EMU_STRUCT_STAT st; 
     212        if(EMU_STAT(pImpl->mFilename.c_str(), &st) == -1) 
    213213        { 
    214214                THROW_EXCEPTION(CommonException, OSFileError) 
  • box/trunk/lib/common/BoxPlatform.h

    r2395 r2460  
    3939                #define __MSVCRT_VERSION__ 0x0601 
    4040        #endif 
    41  
    42         // stop sys/types.h from defining its own ino_t as short, 
    43         // because we want a bigger one :) 
    44         #define _INO_T_ 
    4541#endif 
    4642 
  • box/trunk/lib/common/FileModificationTime.h

    r2080 r2460  
    1515#include "BoxTime.h" 
    1616 
    17 inline box_time_t FileModificationTime(struct stat &st) 
     17inline box_time_t FileModificationTime(EMU_STRUCT_STAT &st) 
    1818{ 
    1919#ifndef HAVE_STRUCT_STAT_ST_MTIMESPEC 
     
    2727} 
    2828 
    29 inline box_time_t FileAttrModificationTime(struct stat &st) 
     29inline box_time_t FileAttrModificationTime(EMU_STRUCT_STAT &st) 
    3030{ 
    3131        box_time_t statusmodified = 
     
    4646} 
    4747 
    48 inline box_time_t FileModificationTimeMaxModAndAttr(struct stat &st) 
     48inline box_time_t FileModificationTimeMaxModAndAttr(EMU_STRUCT_STAT &st) 
    4949{ 
    5050#ifndef HAVE_STRUCT_STAT_ST_MTIMESPEC 
  • box/trunk/lib/common/FileStream.cpp

    r2432 r2460  
    225225IOStream::pos_type FileStream::BytesLeftToRead() 
    226226{ 
    227         struct stat st; 
    228         if(::fstat(mOSFileHandle, &st) != 0) 
     227        EMU_STRUCT_STAT st; 
     228        if(EMU_FSTAT(mOSFileHandle, &st) != 0) 
    229229        { 
    230230                THROW_EXCEPTION(CommonException, OSFileError) 
  • box/trunk/lib/common/Test.cpp

    r2229 r2460  
    2626bool TestFileExists(const char *Filename) 
    2727{ 
    28         struct stat st; 
    29         return ::stat(Filename, &st) == 0 && (st.st_mode & S_IFDIR) == 0; 
     28        EMU_STRUCT_STAT st; 
     29        return EMU_STAT(Filename, &st) == 0 && (st.st_mode & S_IFDIR) == 0; 
    3030} 
    3131 
    3232bool TestFileNotEmpty(const char *Filename) 
    3333{ 
    34         struct stat st; 
    35         return ::stat(Filename, &st) == 0 && (st.st_mode & S_IFDIR) == 0 && 
     34        EMU_STRUCT_STAT st; 
     35        return EMU_STAT(Filename, &st) == 0 && (st.st_mode & S_IFDIR) == 0 && 
    3636                st.st_size > 0; 
    3737} 
     
    3939bool TestDirExists(const char *Filename) 
    4040{ 
    41         struct stat st; 
    42         return ::stat(Filename, &st) == 0 && (st.st_mode & S_IFDIR) == S_IFDIR; 
     41        EMU_STRUCT_STAT st; 
     42        return EMU_STAT(Filename, &st) == 0 && (st.st_mode & S_IFDIR) == S_IFDIR; 
    4343} 
    4444 
     
    4646int TestGetFileSize(const char *Filename) 
    4747{ 
    48         struct stat st; 
    49         if(::stat(Filename, &st) == 0) 
     48        EMU_STRUCT_STAT st; 
     49        if(EMU_STAT(Filename, &st) == 0) 
    5050        { 
    5151                return st.st_size; 
  • box/trunk/lib/common/Utils.cpp

    r2415 r2460  
    164164bool FileExists(const char *Filename, int64_t *pFileSize, bool TreatLinksAsNotExisting) 
    165165{ 
    166         struct stat st; 
    167         if(::lstat(Filename, &st) != 0) 
     166        EMU_STRUCT_STAT st; 
     167        if(EMU_LSTAT(Filename, &st) != 0) 
    168168        { 
    169169                if(errno == ENOENT) 
     
    209209int ObjectExists(const std::string& rFilename) 
    210210{ 
    211         struct stat st; 
    212         if(::stat(rFilename.c_str(), &st) != 0) 
     211        EMU_STRUCT_STAT st; 
     212        if(EMU_STAT(rFilename.c_str(), &st) != 0) 
    213213        { 
    214214                if(errno == ENOENT) 
  • box/trunk/lib/raidfile/RaidFileUtil.cpp

    r2415 r2460  
    5858                        if(pRevisionID != 0) 
    5959                        { 
    60                                 (*pRevisionID) = FileModificationTime(st); 
     60                                #ifdef WIN32 
     61                                        *pRevisionID = st.st_mtime; 
     62                                #else 
     63                                        *pRevisionID = FileModificationTime(st); 
     64                                #endif 
     65 
    6166#ifdef BOX_RELEASE_BUILD 
    6267                                // The resolution of timestamps may be very 
     
    99104                        if(pRevisionID != 0) 
    100105                        { 
    101                                 int64_t rid = FileModificationTime(st); 
     106                                #ifdef WIN32 
     107                                        int64_t rid = st.st_mtime; 
     108                                #else 
     109                                        int64_t rid = FileModificationTime(st); 
     110                                #endif 
     111 
    102112                                if(rid > revisionID) revisionID = rid; 
    103113                                revisionIDplus += st.st_size; 
  • box/trunk/lib/server/Daemon.cpp

    r2415 r2460  
    963963box_time_t Daemon::GetConfigFileModifiedTime() const 
    964964{ 
    965         struct stat st; 
    966  
    967         if(::stat(GetConfigFileName().c_str(), &st) != 0) 
     965        EMU_STRUCT_STAT st; 
     966 
     967        if(EMU_STAT(GetConfigFileName().c_str(), &st) != 0) 
    968968        { 
    969969                if (errno == ENOENT) 
  • box/trunk/lib/win32/emu.cpp

    r2416 r2460  
    2222 
    2323// message resource definitions for syslog() 
    24  
    2524#include "messages.h" 
    2625 
    27 // our implementation for a timer, based on a  
    28 // simple thread which sleeps for a period of time 
    29  
    30 static bool gTimerInitialised = false; 
    31 static bool gFinishTimer; 
    32 static CRITICAL_SECTION gLock; 
    33  
    3426DWORD winerrno; 
    35  
    36 typedef struct  
    37 { 
    38         int countDown; 
    39         int interval; 
    40 } 
    41 Timer_t; 
    42  
    43 std::list<Timer_t> gTimerList; 
    44 static void (__cdecl *gTimerFunc) (int) = NULL; 
    45  
    46 int setitimer(int type, struct itimerval *timeout, void *arg) 
    47 { 
    48         assert(gTimerInitialised); 
    49          
    50         if (ITIMER_REAL != type) 
    51         { 
    52                 errno = ENOSYS; 
    53                 return -1; 
    54         } 
    55  
    56         EnterCriticalSection(&gLock); 
    57  
    58         // we only need seconds for the mo! 
    59         if (timeout->it_value.tv_sec  == 0 &&  
    60             timeout->it_value.tv_usec == 0) 
    61         { 
    62                 gTimerList.clear(); 
    63         } 
    64         else 
    65         { 
    66                 Timer_t ourTimer; 
    67                 ourTimer.countDown = timeout->it_value.tv_sec; 
    68                 ourTimer.interval  = timeout->it_interval.tv_sec; 
    69                 gTimerList.push_back(ourTimer); 
    70         } 
    71  
    72         LeaveCriticalSection(&gLock); 
    73          
    74         // indicate success 
    75         return 0; 
    76 } 
    77  
    78 static unsigned int WINAPI RunTimer(LPVOID lpParameter) 
    79 { 
    80         gFinishTimer = false; 
    81  
    82         while (!gFinishTimer) 
    83         { 
    84                 std::list<Timer_t>::iterator it; 
    85                 EnterCriticalSection(&gLock); 
    86  
    87                 for (it = gTimerList.begin(); it != gTimerList.end(); it++) 
    88                 { 
    89                         Timer_t& rTimer(*it); 
    90  
    91                         rTimer.countDown --; 
    92                         if (rTimer.countDown == 0) 
    93                         { 
    94                                 if (gTimerFunc != NULL) 
    95                                 { 
    96                                         gTimerFunc(0); 
    97                                 } 
    98                                 if (rTimer.interval) 
    99                                 { 
    100                                         rTimer.countDown = rTimer.interval; 
    101                                 } 
    102                                 else 
    103                                 { 
    104                                         // mark for deletion 
    105                                         rTimer.countDown = -1; 
    106                                 } 
    107                         } 
    108                 } 
    109  
    110                 for (it = gTimerList.begin(); it != gTimerList.end(); it++) 
    111                 { 
    112                         Timer_t& rTimer(*it); 
    113  
    114                         if (rTimer.countDown == -1) 
    115                         { 
    116                                 gTimerList.erase(it); 
    117                                  
    118                                 // the iterator is now invalid, so restart search 
    119                                 it = gTimerList.begin(); 
    120  
    121                                 // if the list is now empty, don't try to increment  
    122                                 // the iterator again 
    123                                 if (it == gTimerList.end()) break; 
    124                         } 
    125                 } 
    126  
    127                 LeaveCriticalSection(&gLock); 
    128                 // we only need to have a 1 second resolution 
    129                 Sleep(1000); 
    130         } 
    131  
    132         return 0; 
    133 } 
    134  
    135 int SetTimerHandler(void (__cdecl *func ) (int)) 
    136 { 
    137         gTimerFunc = func; 
    138         return 0; 
    139 } 
    140  
    141 void InitTimer(void) 
    142 { 
    143         assert(!gTimerInitialised); 
    144  
    145         InitializeCriticalSection(&gLock); 
    146          
    147         // create our thread 
    148         HANDLE ourThread = (HANDLE)_beginthreadex(NULL, 0, RunTimer, 0,  
    149                 CREATE_SUSPENDED, NULL); 
    150         SetThreadPriority(ourThread, THREAD_PRIORITY_LOWEST); 
    151         ResumeThread(ourThread); 
    152  
    153         gTimerInitialised = true; 
    154 } 
    155  
    156 void FiniTimer(void) 
    157 { 
    158         assert(gTimerInitialised); 
    159         gFinishTimer = true; 
    160         EnterCriticalSection(&gLock); 
    161         DeleteCriticalSection(&gLock); 
    162         gTimerInitialised = false; 
    163 } 
    164  
    165 //Our constants we need to keep track of 
    166 //globals 
    16727struct passwd gTempPasswd; 
    16828 
     
    716576// Function 
    717577//              Name:    emu_fstat 
    718 //              Purpose: replacement for fstat supply a windows handle 
     578//              Purpose: replacement for fstat. Supply a windows handle. 
     579//                       Returns a struct emu_stat to have room for 64-bit 
     580//                       file identifier in st_ino (mingw allows only 16!) 
    719581//              Created: 25th October 2004 
    720582// 
    721583// -------------------------------------------------------------------------- 
    722 int emu_fstat(HANDLE hdir, struct stat * st) 
     584int emu_fstat(HANDLE hdir, struct emu_stat * st) 
    723585{ 
    724586        if (hdir == INVALID_HANDLE_VALUE) 
     
    752614        conv.HighPart = fi.nFileIndexHigh; 
    753615        conv.LowPart  = fi.nFileIndexLow; 
    754         st->st_ino = (_ino_t)conv.QuadPart; 
     616        st->st_ino = conv.QuadPart; 
    755617 
    756618        // get the time information 
     
    899761// Function 
    900762//              Name:    emu_stat  
    901 //              Purpose: replacement for the lstat and stat functions,  
    902 //                      works with unicode filenames supplied in utf8 format 
     763//              Purpose: replacement for the lstat and stat functions.  
     764//                       Works with unicode filenames supplied in utf8. 
     765//                       Returns a struct emu_stat to have room for 64-bit 
     766//                       file identifier in st_ino (mingw allows only 16!) 
    903767//              Created: 25th October 2004 
    904768// 
    905769// -------------------------------------------------------------------------- 
    906 int emu_stat(const char * pName, struct stat * st) 
     770int emu_stat(const char * pName, struct emu_stat * st) 
    907771{ 
    908772        HANDLE handle = OpenFileByNameUtf8(pName,  
  • box/trunk/lib/win32/emu.h

    r2416 r2460  
    11// emulates unix syscalls to win32 functions 
     2 
     3#ifdef WIN32 
     4        #define EMU_STRUCT_STAT struct emu_stat 
     5        #define EMU_STAT  emu_stat 
     6        #define EMU_FSTAT emu_fstat 
     7        #define EMU_LSTAT emu_stat 
     8#else 
     9        #define EMU_STRUCT_STAT struct stat 
     10        #define EMU_STAT  ::stat 
     11        #define EMU_FSTAT ::fstat 
     12        #define EMU_LSTAT ::lstat 
     13#endif 
    214 
    315#if ! defined EMU_INCLUDE && defined WIN32 
     
    2638#ifdef __MINGW32__ 
    2739        typedef uint32_t u_int32_t; 
    28         typedef uint64_t _ino_t; 
    29         typedef _ino_t ino_t; 
    30         #define _INO_T_ 
    3140#else 
    3241        typedef unsigned int mode_t; 
    3342        typedef unsigned int pid_t; 
    34  
    35         // must define _INO_T_DEFINED before including <sys/types.h> 
    36         // to replace it with our own. 
    37         typedef u_int64_t _ino_t; 
    38         #define _INO_T_DEFINED 
    3943#endif 
    4044 
     
    8286#endif 
    8387 
    84 int SetTimerHandler(void (__cdecl *func ) (int)); 
    85 int setitimer(int type, struct itimerval *timeout, void *arg); 
    86 void InitTimer(void); 
    87 void FiniTimer(void); 
    88  
    8988struct passwd { 
    9089        char *pw_name; 
     
    188187#define timespec timeval 
    189188 
    190 //not available in win32 
    191 struct itimerval 
    192 { 
    193         timeval         it_interval; 
    194         timeval         it_value; 
    195 }; 
    196  
    197189//win32 deals in usec not nsec - so need to ensure this follows through 
    198190#define tv_nsec tv_usec  
     
    314306}; 
    315307 
    316 #if 0 
    317 // I think this should get us going 
    318 // Although there is a warning about  
    319 // mount points in win32 can now exists - which means inode number can be  
    320 // duplicated, so potential of a problem - perhaps this needs to be  
    321 // implemented with a little more thought... TODO 
    322  
    323 struct stat { 
    324         //_dev_t st_dev; 
    325         u_int64_t st_ino; 
     308struct emu_stat { 
     309        int st_dev; 
     310        uint64_t st_ino; 
    326311        DWORD st_mode; 
    327312        short st_nlink; 
     
    329314        short st_gid; 
    330315        //_dev_t st_rdev; 
    331         u_int64_t st_size; 
     316        uint64_t st_size; 
    332317        time_t st_atime; 
    333318        time_t st_mtime; 
    334319        time_t st_ctime; 
    335320}; 
    336 #endif // 0 
    337321 
    338322// need this for conversions 
     
    343327int   emu_mkdir  (const char* pPathName); 
    344328int   emu_unlink (const char* pFileName); 
    345 int   emu_fstat  (HANDLE file,       struct stat* st); 
    346 int   emu_stat   (const char* pName, struct stat* st); 
     329int   emu_fstat  (HANDLE file,       struct emu_stat* st); 
     330int   emu_stat   (const char* pName, struct emu_stat* st); 
    347331int   emu_utimes (const char* pName, const struct timeval[]); 
    348332int   emu_chmod  (const char* pName, mode_t mode); 
     
    353337#define mkdir(path,     mode)   emu_mkdir  (path) 
    354338#define unlink(file)            emu_unlink (file) 
    355 #define stat(filename,  struct) emu_stat   (filename, struct) 
    356 #define lstat(filename, struct) emu_stat   (filename, struct) 
    357 #define fstat(handle,   struct) emu_fstat  (handle,   struct) 
    358339#define utimes(buffer,  times)  emu_utimes (buffer,   times) 
    359340#define chmod(file,     mode)   emu_chmod  (file,     mode) 
    360341#define getcwd(buffer,  size)   emu_getcwd (buffer,   size) 
    361342#define rename(oldname, newname) emu_rename (oldname, newname) 
     343 
     344// Not safe to replace stat/fstat/lstat on mingw at least, as struct stat 
     345// has a 16-bit st_ino and we need a 64-bit one. 
     346// 
     347// #define stat(filename,  struct) emu_stat   (filename, struct) 
     348// #define lstat(filename, struct) emu_stat   (filename, struct) 
     349// #define fstat(handle,   struct) emu_fstat  (handle,   struct) 
     350// 
     351// But lstat doesn't exist on Windows, so we have to provide something: 
     352 
     353#define lstat(filename, struct) stat(filename, struct) 
    362354 
    363355int statfs(const char * name, struct statfs * s); 
  • box/trunk/test/bbackupd/testbbackupd.cpp

    r2452 r2460  
    259259bool attrmatch(const char *f1, const char *f2) 
    260260{ 
    261         struct stat s1, s2; 
    262         TEST_THAT(::lstat(f1, &s1) == 0); 
    263         TEST_THAT(::lstat(f2, &s2) == 0); 
     261        EMU_STRUCT_STAT s1, s2; 
     262        TEST_THAT(EMU_LSTAT(f1, &s1) == 0); 
     263        TEST_THAT(EMU_LSTAT(f2, &s2) == 0); 
    264264 
    265265#ifdef HAVE_SYS_XATTR_H 
     
    20282028                        "their contents can be restored.\n"); 
    20292029 
     2030                int compareReturnValue; 
     2031 
    20302032                { 
    20312033                        #ifdef WIN32 
     
    20402042                        wait_for_sync_end(); // should be backed up now 
    20412043 
    2042                         int compareReturnValue = ::system(BBACKUPQUERY " " 
     2044                        compareReturnValue = ::system(BBACKUPQUERY " " 
    20432045                                "-Wwarning " 
    20442046                                "-c testfiles/bbackupd.conf " 
     
    20832085 
    20842086                } 
    2085  
    2086                 int compareReturnValue; 
    20872087 
    20882088#ifdef WIN32 
Note: See TracChangeset for help on using the changeset viewer.