Changeset 2460


Ignore:
Timestamp:
Mar 21, 2009, 6:48:19 PM (6 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.