← Back to branch summary

~ubuntu-branches/ubuntu/utopic/unrar-nonfree/utopic-updates

« back to all changes in this revision

Viewing changes to find.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Chris Anderson
  • Date: 2004-07-02 01:53:47 UTC
  • Revision ID: james.westby@ubuntu.com-20040702015347-26ptn0errf3ew0u9
Tags: upstream-3.3.6
Import upstream version 3.3.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
find.cpp
 
1
#include "rar.hpp"
 
2
 
 
3
FindFile::FindFile()
 
4
{
 
5
  *FindMask=0;
 
6
  *FindMaskW=0;
 
7
  FirstCall=TRUE;
 
8
#ifdef _WIN_32
 
9
  hFind=INVALID_HANDLE_VALUE;
 
10
#else
 
11
  dirp=NULL;
 
12
#endif
 
13
}
 
14
 
 
15
 
 
16
FindFile::~FindFile()
 
17
{
 
18
#ifdef _WIN_32
 
19
  if (hFind!=INVALID_HANDLE_VALUE)
 
20
    FindClose(hFind);
 
21
#else
 
22
  if (dirp!=NULL)
 
23
    closedir(dirp);
 
24
#endif
 
25
}
 
26
 
 
27
 
 
28
void FindFile::SetMask(const char *FindMask)
 
29
{
 
30
  strcpy(FindFile::FindMask,FindMask);
 
31
  if (*FindMaskW==0)
 
32
    CharToWide(FindMask,FindMaskW);
 
33
  FirstCall=TRUE;
 
34
}
 
35
 
 
36
 
 
37
void FindFile::SetMaskW(const wchar *FindMaskW)
 
38
{
 
39
  if (FindMaskW==NULL)
 
40
    return;
 
41
  strcpyw(FindFile::FindMaskW,FindMaskW);
 
42
  if (*FindMask==0)
 
43
    WideToChar(FindMaskW,FindMask);
 
44
  FirstCall=TRUE;
 
45
}
 
46
 
 
47
 
 
48
bool FindFile::Next(struct FindData *fd,bool GetSymLink)
 
49
{
 
50
  fd->Error=false;
 
51
  if (*FindMask==0)
 
52
    return(false);
 
53
#ifdef _WIN_32
 
54
  if (FirstCall)
 
55
  {
 
56
    if ((hFind=Win32Find(INVALID_HANDLE_VALUE,FindMask,FindMaskW,fd))==INVALID_HANDLE_VALUE)
 
57
      return(false);
 
58
  }
 
59
  else
 
60
    if (Win32Find(hFind,FindMask,FindMaskW,fd)==INVALID_HANDLE_VALUE)
 
61
      return(false);
 
62
#else
 
63
  if (FirstCall)
 
64
  {
 
65
    char DirName[NM];
 
66
    strcpy(DirName,FindMask);
 
67
    RemoveNameFromPath(DirName);
 
68
    if (*DirName==0)
 
69
      strcpy(DirName,".");
 
70
/*
 
71
    else
 
72
    {
 
73
      int Length=strlen(DirName);
 
74
      if (Length>1 && DirName[Length-1]==CPATHDIVIDER && (Length!=3 || !IsDriveDiv(DirName[1])))
 
75
        DirName[Length-1]=0;
 
76
    }
 
77
*/
 
78
    if ((dirp=opendir(DirName))==NULL)
 
79
    {
 
80
      fd->Error=(errno!=ENOENT);
 
81
      return(false);
 
82
    }
 
83
  }
 
84
  while (1)
 
85
  {
 
86
    struct dirent *ent=readdir(dirp);
 
87
    if (ent==NULL)
 
88
      return(false);
 
89
    if (strcmp(ent->d_name,".")==0 || strcmp(ent->d_name,"..")==0)
 
90
      continue;
 
91
    if (CmpName(FindMask,ent->d_name,MATCH_NAMES))
 
92
    {
 
93
      char FullName[NM];
 
94
      strcpy(FullName,FindMask);
 
95
      strcpy(PointToName(FullName),ent->d_name);
 
96
      if (!FastFind(FullName,NULL,fd,GetSymLink))
 
97
      {
 
98
        ErrHandler.OpenErrorMsg(FullName);
 
99
        continue;
 
100
      }
 
101
      strcpy(fd->Name,FullName);
 
102
      break;
 
103
    }
 
104
  }
 
105
  *fd->NameW=0;
 
106
#ifdef _APPLE
 
107
  if (!LowAscii(fd->Name))
 
108
    UtfToWide(fd->Name,fd->NameW,sizeof(fd->NameW));
 
109
#endif
 
110
#endif
 
111
  fd->IsDir=IsDir(fd->FileAttr);
 
112
  FirstCall=FALSE;
 
113
  char *Name=PointToName(fd->Name);
 
114
  if (strcmp(Name,".")==0 || strcmp(Name,"..")==0)
 
115
    return(Next(fd));
 
116
  return(true);
 
117
}
 
118
 
 
119
 
 
120
bool FindFile::FastFind(const char *FindMask,const wchar *FindMaskW,struct FindData *fd,bool GetSymLink)
 
121
{
 
122
  fd->Error=false;
 
123
#ifndef _UNIX
 
124
  if (IsWildcard(FindMask,FindMaskW))
 
125
    return(false);
 
126
#endif    
 
127
#ifdef _WIN_32
 
128
  HANDLE hFind=Win32Find(INVALID_HANDLE_VALUE,FindMask,FindMaskW,fd);
 
129
  if (hFind==INVALID_HANDLE_VALUE)
 
130
    return(false);
 
131
  FindClose(hFind);
 
132
#else
 
133
  struct stat st;
 
134
  if (GetSymLink)
 
135
  {
 
136
#ifdef SAVE_LINKS
 
137
    if (lstat(FindMask,&st)!=0)
 
138
#else
 
139
    if (stat(FindMask,&st)!=0)
 
140
#endif
 
141
    {
 
142
      fd->Error=(errno!=ENOENT);
 
143
      return(false);
 
144
    }
 
145
  }
 
146
  else
 
147
    if (stat(FindMask,&st)!=0)
 
148
    {
 
149
      fd->Error=(errno!=ENOENT);
 
150
      return(false);
 
151
    }
 
152
#ifdef _DJGPP
 
153
  fd->FileAttr=chmod(FindMask,0);
 
154
#elif defined(_EMX)
 
155
  fd->FileAttr=st.st_attr;
 
156
#else
 
157
  fd->FileAttr=st.st_mode;
 
158
#endif
 
159
  fd->IsDir=IsDir(st.st_mode);
 
160
  fd->Size=st.st_size;
 
161
  fd->mtime=st.st_mtime;
 
162
  fd->atime=st.st_atime;
 
163
  fd->ctime=st.st_ctime;
 
164
  fd->FileTime=fd->mtime.GetDos();
 
165
  strcpy(fd->Name,FindMask);
 
166
  *fd->NameW=0;
 
167
#ifdef _APPLE
 
168
  if (!LowAscii(fd->Name))
 
169
    UtfToWide(fd->Name,fd->NameW,sizeof(fd->NameW));
 
170
#endif
 
171
#endif
 
172
  fd->IsDir=IsDir(fd->FileAttr);
 
173
  return(true);
 
174
}
 
175
 
 
176
 
 
177
#ifdef _WIN_32
 
178
HANDLE FindFile::Win32Find(HANDLE hFind,const char *Mask,const wchar *MaskW,struct FindData *fd)
 
179
{
 
180
#ifndef _WIN_CE
 
181
  if (WinNT())
 
182
#endif
 
183
  {
 
184
    wchar WideMask[NM];
 
185
    if (MaskW!=NULL && *MaskW!=0)
 
186
      strcpyw(WideMask,MaskW);
 
187
    else
 
188
      CharToWide(Mask,WideMask);
 
189
 
 
190
    WIN32_FIND_DATAW FindData;
 
191
    if (hFind==INVALID_HANDLE_VALUE)
 
192
    {
 
193
      hFind=FindFirstFileW(WideMask,&FindData);
 
194
      if (hFind==INVALID_HANDLE_VALUE)
 
195
      {
 
196
        int SysErr=GetLastError();
 
197
        fd->Error=(SysErr!=ERROR_FILE_NOT_FOUND &&
 
198
                   SysErr!=ERROR_PATH_NOT_FOUND &&
 
199
                   SysErr!=ERROR_NO_MORE_FILES);
 
200
      }
 
201
    }
 
202
    else
 
203
      if (!FindNextFileW(hFind,&FindData))
 
204
      {
 
205
        hFind=INVALID_HANDLE_VALUE;
 
206
        fd->Error=GetLastError()!=ERROR_NO_MORE_FILES;
 
207
      }
 
208
 
 
209
    if (hFind!=INVALID_HANDLE_VALUE)
 
210
    {
 
211
      strcpyw(fd->NameW,WideMask);
 
212
      strcpyw(PointToName(fd->NameW),FindData.cFileName);
 
213
      WideToChar(fd->NameW,fd->Name);
 
214
      fd->Size=int32to64(FindData.nFileSizeHigh,FindData.nFileSizeLow);
 
215
      fd->FileAttr=FindData.dwFileAttributes;
 
216
      fd->ftCreationTime=FindData.ftCreationTime;
 
217
      fd->ftLastAccessTime=FindData.ftLastAccessTime;
 
218
      fd->ftLastWriteTime=FindData.ftLastWriteTime;
 
219
      fd->mtime=FindData.ftLastWriteTime;
 
220
      fd->ctime=FindData.ftCreationTime;
 
221
      fd->atime=FindData.ftLastAccessTime;
 
222
      fd->FileTime=fd->mtime.GetDos();
 
223
 
 
224
#ifndef _WIN_CE
 
225
      if (LowAscii(fd->NameW))
 
226
        *fd->NameW=0;
 
227
#endif
 
228
    }
 
229
  }
 
230
#ifndef _WIN_CE
 
231
  else
 
232
  {
 
233
    char CharMask[NM];
 
234
    if (Mask!=NULL && *Mask!=0)
 
235
      strcpy(CharMask,Mask);
 
236
    else
 
237
      WideToChar(MaskW,CharMask);
 
238
 
 
239
    WIN32_FIND_DATA FindData;
 
240
    if (hFind==INVALID_HANDLE_VALUE)
 
241
    {
 
242
      hFind=FindFirstFile(CharMask,&FindData);
 
243
      if (hFind==INVALID_HANDLE_VALUE)
 
244
      {
 
245
        int SysErr=GetLastError();
 
246
        fd->Error=SysErr!=ERROR_FILE_NOT_FOUND && SysErr!=ERROR_PATH_NOT_FOUND;
 
247
      }
 
248
    }
 
249
    else
 
250
      if (!FindNextFile(hFind,&FindData))
 
251
      {
 
252
        hFind=INVALID_HANDLE_VALUE;
 
253
        fd->Error=GetLastError()!=ERROR_NO_MORE_FILES;
 
254
      }
 
255
 
 
256
    if (hFind!=INVALID_HANDLE_VALUE)
 
257
    {
 
258
      strcpy(fd->Name,CharMask);
 
259
      strcpy(PointToName(fd->Name),FindData.cFileName);
 
260
      CharToWide(fd->Name,fd->NameW);
 
261
      fd->Size=int32to64(FindData.nFileSizeHigh,FindData.nFileSizeLow);
 
262
      fd->FileAttr=FindData.dwFileAttributes;
 
263
      fd->ftCreationTime=FindData.ftCreationTime;
 
264
      fd->ftLastAccessTime=FindData.ftLastAccessTime;
 
265
      fd->ftLastWriteTime=FindData.ftLastWriteTime;
 
266
      fd->mtime=FindData.ftLastWriteTime;
 
267
      fd->ctime=FindData.ftCreationTime;
 
268
      fd->atime=FindData.ftLastAccessTime;
 
269
      fd->FileTime=fd->mtime.GetDos();
 
270
      if (LowAscii(fd->Name))
 
271
        *fd->NameW=0;
 
272
    }
 
273
  }
 
274
#endif
 
275
  return(hFind);
 
276
}
 
277
#endif
 
278