← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/System/Win32/Path.inc

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/System/Win32/Path.inc
1
 
//===- llvm/System/Win32/Path.cpp - Win32 Path Implementation ---*- C++ -*-===//
2
 
//
3
 
//                     The LLVM Compiler Infrastructure
4
 
//
5
 
// This file is distributed under the University of Illinois Open Source
6
 
// License. See LICENSE.TXT for details.
7
 
//
8
 
// Modified by Henrik Bach to comply with at least MinGW.
9
 
// Ported to Win32 by Jeff Cohen.
10
 
//
11
 
//===----------------------------------------------------------------------===//
12
 
//
13
 
// This file provides the Win32 specific implementation of the Path class.
14
 
//
15
 
//===----------------------------------------------------------------------===//
16
 
 
17
 
//===----------------------------------------------------------------------===//
18
 
//=== WARNING: Implementation here must contain only generic Win32 code that
19
 
//===          is guaranteed to work on *all* Win32 variants.
20
 
//===----------------------------------------------------------------------===//
21
 
 
22
 
#include "Win32.h"
23
 
#include <malloc.h>
24
 
#include <cstdio>
25
 
 
26
 
// We need to undo a macro defined in Windows.h, otherwise we won't compile:
27
 
#undef CopyFile
28
 
#undef GetCurrentDirectory
29
 
 
30
 
// Windows happily accepts either forward or backward slashes, though any path
31
 
// returned by a Win32 API will have backward slashes.  As LLVM code basically
32
 
// assumes forward slashes are used, backward slashs are converted where they
33
 
// can be introduced into a path.
34
 
//
35
 
// Another invariant is that a path ends with a slash if and only if the path
36
 
// is a root directory.  Any other use of a trailing slash is stripped.  Unlike
37
 
// in Unix, Windows has a rather complicated notion of a root path and this
38
 
// invariant helps simply the code.
39
 
 
40
 
static void FlipBackSlashes(std::string& s) {
41
 
  for (size_t i = 0; i < s.size(); i++)
42
 
    if (s[i] == '\\')
43
 
      s[i] = '/';
44
 
}
45
 
 
46
 
namespace llvm {
47
 
namespace sys {
48
 
const char PathSeparator = ';';
49
 
 
50
 
Path::Path(llvm::StringRef p)
51
 
  : path(p) {
52
 
  FlipBackSlashes(path);
53
 
}
54
 
 
55
 
Path::Path(const char *StrStart, unsigned StrLen)
56
 
  : path(StrStart, StrLen) {
57
 
  FlipBackSlashes(path);
58
 
}
59
 
 
60
 
Path&
61
 
Path::operator=(StringRef that) {
62
 
  path.assign(that.data(), that.size());
63
 
  FlipBackSlashes(path);
64
 
  return *this;
65
 
}
66
 
 
67
 
bool
68
 
Path::isValid() const {
69
 
  if (path.empty())
70
 
    return false;
71
 
 
72
 
  // If there is a colon, it must be the second character, preceded by a letter
73
 
  // and followed by something.
74
 
  size_t len = path.size();
75
 
  size_t pos = path.rfind(':',len);
76
 
  size_t rootslash = 0;
77
 
  if (pos != std::string::npos) {
78
 
    if (pos != 1 || !isalpha(path[0]) || len < 3)
79
 
      return false;
80
 
      rootslash = 2;
81
 
  }
82
 
 
83
 
  // Look for a UNC path, and if found adjust our notion of the root slash.
84
 
  if (len > 3 && path[0] == '/' && path[1] == '/') {
85
 
    rootslash = path.find('/', 2);
86
 
    if (rootslash == std::string::npos)
87
 
      rootslash = 0;
88
 
  }
89
 
 
90
 
  // Check for illegal characters.
91
 
  if (path.find_first_of("\\<>\"|\001\002\003\004\005\006\007\010\011\012"
92
 
                         "\013\014\015\016\017\020\021\022\023\024\025\026"
93
 
                         "\027\030\031\032\033\034\035\036\037")
94
 
      != std::string::npos)
95
 
    return false;
96
 
 
97
 
  // Remove trailing slash, unless it's a root slash.
98
 
  if (len > rootslash+1 && path[len-1] == '/')
99
 
    path.erase(--len);
100
 
 
101
 
  // Check each component for legality.
102
 
  for (pos = 0; pos < len; ++pos) {
103
 
    // A component may not end in a space.
104
 
    if (path[pos] == ' ') {
105
 
      if (path[pos+1] == '/' || path[pos+1] == '\0')
106
 
        return false;
107
 
    }
108
 
 
109
 
    // A component may not end in a period.
110
 
    if (path[pos] == '.') {
111
 
      if (path[pos+1] == '/' || path[pos+1] == '\0') {
112
 
        // Unless it is the pseudo-directory "."...
113
 
        if (pos == 0 || path[pos-1] == '/' || path[pos-1] == ':')
114
 
          return true;
115
 
        // or "..".
116
 
        if (pos > 0 && path[pos-1] == '.') {
117
 
          if (pos == 1 || path[pos-2] == '/' || path[pos-2] == ':')
118
 
            return true;
119
 
        }
120
 
        return false;
121
 
      }
122
 
    }
123
 
  }
124
 
 
125
 
  return true;
126
 
}
127
 
 
128
 
void Path::makeAbsolute() {
129
 
  TCHAR  FullPath[MAX_PATH + 1] = {0};
130
 
  LPTSTR FilePart = NULL;
131
 
 
132
 
  DWORD RetLength = ::GetFullPathNameA(path.c_str(),
133
 
                        sizeof(FullPath)/sizeof(FullPath[0]),
134
 
                        FullPath, &FilePart);
135
 
 
136
 
  if (0 == RetLength) {
137
 
    // FIXME: Report the error GetLastError()
138
 
    assert(0 && "Unable to make absolute path!");
139
 
  } else if (RetLength > MAX_PATH) {
140
 
    // FIXME: Report too small buffer (needed RetLength bytes).
141
 
    assert(0 && "Unable to make absolute path!");
142
 
  } else {
143
 
    path = FullPath;
144
 
  }
145
 
}
146
 
 
147
 
bool
148
 
Path::isAbsolute(const char *NameStart, unsigned NameLen) {
149
 
  assert(NameStart);
150
 
  // FIXME: This does not handle correctly an absolute path starting from
151
 
  // a drive letter or in UNC format.
152
 
  switch (NameLen) {
153
 
  case 0:
154
 
    return false;
155
 
  case 1:
156
 
  case 2:
157
 
    return NameStart[0] == '/';
158
 
  default:
159
 
    return (NameStart[0] == '/' || (NameStart[1] == ':' && NameStart[2] == '/')) ||
160
 
           (NameStart[0] == '\\' || (NameStart[1] == ':' && NameStart[2] == '\\'));
161
 
  }
162
 
}
163
 
 
164
 
bool
165
 
Path::isAbsolute() const {
166
 
  // FIXME: This does not handle correctly an absolute path starting from
167
 
  // a drive letter or in UNC format.
168
 
  switch (path.length()) {
169
 
    case 0:
170
 
      return false;
171
 
    case 1:
172
 
    case 2:
173
 
      return path[0] == '/';
174
 
    default:
175
 
      return path[0] == '/' || (path[1] == ':' && path[2] == '/');
176
 
  }
177
 
}
178
 
 
179
 
static Path *TempDirectory;
180
 
 
181
 
Path
182
 
Path::GetTemporaryDirectory(std::string* ErrMsg) {
183
 
  if (TempDirectory)
184
 
    return *TempDirectory;
185
 
 
186
 
  char pathname[MAX_PATH];
187
 
  if (!GetTempPath(MAX_PATH, pathname)) {
188
 
    if (ErrMsg)
189
 
      *ErrMsg = "Can't determine temporary directory";
190
 
    return Path();
191
 
  }
192
 
 
193
 
  Path result;
194
 
  result.set(pathname);
195
 
 
196
 
  // Append a subdirectory passed on our process id so multiple LLVMs don't
197
 
  // step on each other's toes.
198
 
#ifdef __MINGW32__
199
 
  // Mingw's Win32 header files are broken.
200
 
  sprintf(pathname, "LLVM_%u", unsigned(GetCurrentProcessId()));
201
 
#else
202
 
  sprintf(pathname, "LLVM_%u", GetCurrentProcessId());
203
 
#endif
204
 
  result.appendComponent(pathname);
205
 
 
206
 
  // If there's a directory left over from a previous LLVM execution that
207
 
  // happened to have the same process id, get rid of it.
208
 
  result.eraseFromDisk(true);
209
 
 
210
 
  // And finally (re-)create the empty directory.
211
 
  result.createDirectoryOnDisk(false);
212
 
  TempDirectory = new Path(result);
213
 
  return *TempDirectory;
214
 
}
215
 
 
216
 
// FIXME: the following set of functions don't map to Windows very well.
217
 
Path
218
 
Path::GetRootDirectory() {
219
 
  Path result;
220
 
  result.set("C:/");
221
 
  return result;
222
 
}
223
 
 
224
 
void
225
 
Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
226
 
  Paths.push_back(sys::Path("C:/WINDOWS/SYSTEM32"));
227
 
  Paths.push_back(sys::Path("C:/WINDOWS"));
228
 
}
229
 
 
230
 
void
231
 
Path::GetBitcodeLibraryPaths(std::vector<sys::Path>& Paths) {
232
 
  char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
233
 
  if (env_var != 0) {
234
 
    getPathList(env_var,Paths);
235
 
  }
236
 
#ifdef LLVM_LIBDIR
237
 
  {
238
 
    Path tmpPath;
239
 
    if (tmpPath.set(LLVM_LIBDIR))
240
 
      if (tmpPath.canRead())
241
 
        Paths.push_back(tmpPath);
242
 
  }
243
 
#endif
244
 
  GetSystemLibraryPaths(Paths);
245
 
}
246
 
 
247
 
Path
248
 
Path::GetLLVMDefaultConfigDir() {
249
 
  // TODO: this isn't going to fly on Windows
250
 
  return Path("/etc/llvm");
251
 
}
252
 
 
253
 
Path
254
 
Path::GetUserHomeDirectory() {
255
 
  // TODO: Typical Windows setup doesn't define HOME.
256
 
  const char* home = getenv("HOME");
257
 
  if (home) {
258
 
    Path result;
259
 
    if (result.set(home))
260
 
      return result;
261
 
  }
262
 
  return GetRootDirectory();
263
 
}
264
 
 
265
 
Path
266
 
Path::GetCurrentDirectory() {
267
 
  char pathname[MAX_PATH];
268
 
  ::GetCurrentDirectoryA(MAX_PATH,pathname);
269
 
  return Path(pathname);
270
 
}
271
 
 
272
 
/// GetMainExecutable - Return the path to the main executable, given the
273
 
/// value of argv[0] from program startup.
274
 
Path Path::GetMainExecutable(const char *argv0, void *MainAddr) {
275
 
  char pathname[MAX_PATH];
276
 
  DWORD ret = ::GetModuleFileNameA(NULL, pathname, MAX_PATH);
277
 
  return ret != MAX_PATH ? Path(pathname) : Path();
278
 
}
279
 
 
280
 
 
281
 
// FIXME: the above set of functions don't map to Windows very well.
282
 
 
283
 
 
284
 
StringRef Path::getDirname() const {
285
 
  return getDirnameCharSep(path, "/");
286
 
}
287
 
 
288
 
StringRef
289
 
Path::getBasename() const {
290
 
  // Find the last slash
291
 
  size_t slash = path.rfind('/');
292
 
  if (slash == std::string::npos)
293
 
    slash = 0;
294
 
  else
295
 
    slash++;
296
 
 
297
 
  size_t dot = path.rfind('.');
298
 
  if (dot == std::string::npos || dot < slash)
299
 
    return StringRef(path).substr(slash);
300
 
  else
301
 
    return StringRef(path).substr(slash, dot - slash);
302
 
}
303
 
 
304
 
StringRef
305
 
Path::getSuffix() const {
306
 
  // Find the last slash
307
 
  size_t slash = path.rfind('/');
308
 
  if (slash == std::string::npos)
309
 
    slash = 0;
310
 
  else
311
 
    slash++;
312
 
 
313
 
  size_t dot = path.rfind('.');
314
 
  if (dot == std::string::npos || dot < slash)
315
 
    return StringRef("");
316
 
  else
317
 
    return StringRef(path).substr(dot + 1);
318
 
}
319
 
 
320
 
bool
321
 
Path::exists() const {
322
 
  DWORD attr = GetFileAttributes(path.c_str());
323
 
  return attr != INVALID_FILE_ATTRIBUTES;
324
 
}
325
 
 
326
 
bool
327
 
Path::isDirectory() const {
328
 
  DWORD attr = GetFileAttributes(path.c_str());
329
 
  return (attr != INVALID_FILE_ATTRIBUTES) &&
330
 
         (attr & FILE_ATTRIBUTE_DIRECTORY);
331
 
}
332
 
 
333
 
bool
334
 
Path::canRead() const {
335
 
  // FIXME: take security attributes into account.
336
 
  DWORD attr = GetFileAttributes(path.c_str());
337
 
  return attr != INVALID_FILE_ATTRIBUTES;
338
 
}
339
 
 
340
 
bool
341
 
Path::canWrite() const {
342
 
  // FIXME: take security attributes into account.
343
 
  DWORD attr = GetFileAttributes(path.c_str());
344
 
  return (attr != INVALID_FILE_ATTRIBUTES) && !(attr & FILE_ATTRIBUTE_READONLY);
345
 
}
346
 
 
347
 
bool
348
 
Path::canExecute() const {
349
 
  // FIXME: take security attributes into account.
350
 
  DWORD attr = GetFileAttributes(path.c_str());
351
 
  return attr != INVALID_FILE_ATTRIBUTES;
352
 
}
353
 
 
354
 
bool
355
 
Path::isRegularFile() const {
356
 
  if (isDirectory())
357
 
    return false;
358
 
  return true;
359
 
}
360
 
 
361
 
StringRef
362
 
Path::getLast() const {
363
 
  // Find the last slash
364
 
  size_t pos = path.rfind('/');
365
 
 
366
 
  // Handle the corner cases
367
 
  if (pos == std::string::npos)
368
 
    return path;
369
 
 
370
 
  // If the last character is a slash, we have a root directory
371
 
  if (pos == path.length()-1)
372
 
    return path;
373
 
 
374
 
  // Return everything after the last slash
375
 
  return StringRef(path).substr(pos+1);
376
 
}
377
 
 
378
 
const FileStatus *
379
 
PathWithStatus::getFileStatus(bool update, std::string *ErrStr) const {
380
 
  if (!fsIsValid || update) {
381
 
    WIN32_FILE_ATTRIBUTE_DATA fi;
382
 
    if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi)) {
383
 
      MakeErrMsg(ErrStr, "getStatusInfo():" + std::string(path) +
384
 
                      ": Can't get status: ");
385
 
      return 0;
386
 
    }
387
 
 
388
 
    status.fileSize = fi.nFileSizeHigh;
389
 
    status.fileSize <<= sizeof(fi.nFileSizeHigh)*8;
390
 
    status.fileSize += fi.nFileSizeLow;
391
 
 
392
 
    status.mode = fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0555 : 0777;
393
 
    status.user = 9999;    // Not applicable to Windows, so...
394
 
    status.group = 9999;   // Not applicable to Windows, so...
395
 
 
396
 
    // FIXME: this is only unique if the file is accessed by the same file path.
397
 
    // How do we do this for C:\dir\file and ..\dir\file ? Unix has inode
398
 
    // numbers, but the concept doesn't exist in Windows.
399
 
    status.uniqueID = 0;
400
 
    for (unsigned i = 0; i < path.length(); ++i)
401
 
      status.uniqueID += path[i];
402
 
 
403
 
    ULARGE_INTEGER ui;
404
 
    ui.LowPart = fi.ftLastWriteTime.dwLowDateTime;
405
 
    ui.HighPart = fi.ftLastWriteTime.dwHighDateTime;
406
 
    status.modTime.fromWin32Time(ui.QuadPart);
407
 
 
408
 
    status.isDir = fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
409
 
    fsIsValid = true;
410
 
  }
411
 
  return &status;
412
 
}
413
 
 
414
 
bool Path::makeReadableOnDisk(std::string* ErrMsg) {
415
 
  // All files are readable on Windows (ignoring security attributes).
416
 
  return false;
417
 
}
418
 
 
419
 
bool Path::makeWriteableOnDisk(std::string* ErrMsg) {
420
 
  DWORD attr = GetFileAttributes(path.c_str());
421
 
 
422
 
  // If it doesn't exist, we're done.
423
 
  if (attr == INVALID_FILE_ATTRIBUTES)
424
 
    return false;
425
 
 
426
 
  if (attr & FILE_ATTRIBUTE_READONLY) {
427
 
    if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY)) {
428
 
      MakeErrMsg(ErrMsg, std::string(path) + ": Can't make file writable: ");
429
 
      return true;
430
 
    }
431
 
  }
432
 
  return false;
433
 
}
434
 
 
435
 
bool Path::makeExecutableOnDisk(std::string* ErrMsg) {
436
 
  // All files are executable on Windows (ignoring security attributes).
437
 
  return false;
438
 
}
439
 
 
440
 
bool
441
 
Path::getDirectoryContents(std::set<Path>& result, std::string* ErrMsg) const {
442
 
  WIN32_FILE_ATTRIBUTE_DATA fi;
443
 
  if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi)) {
444
 
    MakeErrMsg(ErrMsg, path + ": can't get status of file");
445
 
    return true;
446
 
  }
447
 
 
448
 
  if (!(fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
449
 
    if (ErrMsg)
450
 
      *ErrMsg = path + ": not a directory";
451
 
    return true;
452
 
  }
453
 
 
454
 
  result.clear();
455
 
  WIN32_FIND_DATA fd;
456
 
  std::string searchpath = path;
457
 
  if (path.size() == 0 || searchpath[path.size()-1] == '/')
458
 
    searchpath += "*";
459
 
  else
460
 
    searchpath += "/*";
461
 
 
462
 
  HANDLE h = FindFirstFile(searchpath.c_str(), &fd);
463
 
  if (h == INVALID_HANDLE_VALUE) {
464
 
    if (GetLastError() == ERROR_FILE_NOT_FOUND)
465
 
      return true; // not really an error, now is it?
466
 
    MakeErrMsg(ErrMsg, path + ": Can't read directory: ");
467
 
    return true;
468
 
  }
469
 
 
470
 
  do {
471
 
    if (fd.cFileName[0] == '.')
472
 
      continue;
473
 
    Path aPath(path);
474
 
    aPath.appendComponent(&fd.cFileName[0]);
475
 
    result.insert(aPath);
476
 
  } while (FindNextFile(h, &fd));
477
 
 
478
 
  DWORD err = GetLastError();
479
 
  FindClose(h);
480
 
  if (err != ERROR_NO_MORE_FILES) {
481
 
    SetLastError(err);
482
 
    MakeErrMsg(ErrMsg, path + ": Can't read directory: ");
483
 
    return true;
484
 
  }
485
 
  return false;
486
 
}
487
 
 
488
 
bool
489
 
Path::set(StringRef a_path) {
490
 
  if (a_path.empty())
491
 
    return false;
492
 
  std::string save(path);
493
 
  path = a_path;
494
 
  FlipBackSlashes(path);
495
 
  if (!isValid()) {
496
 
    path = save;
497
 
    return false;
498
 
  }
499
 
  return true;
500
 
}
501
 
 
502
 
bool
503
 
Path::appendComponent(StringRef name) {
504
 
  if (name.empty())
505
 
    return false;
506
 
  std::string save(path);
507
 
  if (!path.empty()) {
508
 
    size_t last = path.size() - 1;
509
 
    if (path[last] != '/')
510
 
      path += '/';
511
 
  }
512
 
  path += name;
513
 
  if (!isValid()) {
514
 
    path = save;
515
 
    return false;
516
 
  }
517
 
  return true;
518
 
}
519
 
 
520
 
bool
521
 
Path::eraseComponent() {
522
 
  size_t slashpos = path.rfind('/',path.size());
523
 
  if (slashpos == path.size() - 1 || slashpos == std::string::npos)
524
 
    return false;
525
 
  std::string save(path);
526
 
  path.erase(slashpos);
527
 
  if (!isValid()) {
528
 
    path = save;
529
 
    return false;
530
 
  }
531
 
  return true;
532
 
}
533
 
 
534
 
bool
535
 
Path::appendSuffix(StringRef suffix) {
536
 
  std::string save(path);
537
 
  path.append(".");
538
 
  path.append(suffix);
539
 
  if (!isValid()) {
540
 
    path = save;
541
 
    return false;
542
 
  }
543
 
  return true;
544
 
}
545
 
 
546
 
bool
547
 
Path::eraseSuffix() {
548
 
  size_t dotpos = path.rfind('.',path.size());
549
 
  size_t slashpos = path.rfind('/',path.size());
550
 
  if (dotpos != std::string::npos) {
551
 
    if (slashpos == std::string::npos || dotpos > slashpos+1) {
552
 
      std::string save(path);
553
 
      path.erase(dotpos, path.size()-dotpos);
554
 
      if (!isValid()) {
555
 
        path = save;
556
 
        return false;
557
 
      }
558
 
      return true;
559
 
    }
560
 
  }
561
 
  return false;
562
 
}
563
 
 
564
 
inline bool PathMsg(std::string* ErrMsg, const char* pathname, const char*msg) {
565
 
  if (ErrMsg)
566
 
    *ErrMsg = std::string(pathname) + ": " + std::string(msg);
567
 
  return true;
568
 
}
569
 
 
570
 
bool
571
 
Path::createDirectoryOnDisk(bool create_parents, std::string* ErrMsg) {
572
 
  // Get a writeable copy of the path name
573
 
  size_t len = path.length();
574
 
  char *pathname = reinterpret_cast<char *>(_alloca(len+2));
575
 
  path.copy(pathname, len);
576
 
  pathname[len] = 0;
577
 
 
578
 
  // Make sure it ends with a slash.
579
 
  if (len == 0 || pathname[len - 1] != '/') {
580
 
    pathname[len] = '/';
581
 
    pathname[++len] = 0;
582
 
  }
583
 
 
584
 
  // Determine starting point for initial / search.
585
 
  char *next = pathname;
586
 
  if (pathname[0] == '/' && pathname[1] == '/') {
587
 
    // Skip host name.
588
 
    next = strchr(pathname+2, '/');
589
 
    if (next == NULL)
590
 
      return PathMsg(ErrMsg, pathname, "badly formed remote directory");
591
 
 
592
 
    // Skip share name.
593
 
    next = strchr(next+1, '/');
594
 
    if (next == NULL)
595
 
      return PathMsg(ErrMsg, pathname,"badly formed remote directory");
596
 
 
597
 
    next++;
598
 
    if (*next == 0)
599
 
      return PathMsg(ErrMsg, pathname, "badly formed remote directory");
600
 
 
601
 
  } else {
602
 
    if (pathname[1] == ':')
603
 
      next += 2;    // skip drive letter
604
 
    if (*next == '/')
605
 
      next++;       // skip root directory
606
 
  }
607
 
 
608
 
  // If we're supposed to create intermediate directories
609
 
  if (create_parents) {
610
 
    // Loop through the directory components until we're done
611
 
    while (*next) {
612
 
      next = strchr(next, '/');
613
 
      *next = 0;
614
 
      if (!CreateDirectory(pathname, NULL) &&
615
 
          GetLastError() != ERROR_ALREADY_EXISTS)
616
 
          return MakeErrMsg(ErrMsg,
617
 
            std::string(pathname) + ": Can't create directory: ");
618
 
      *next++ = '/';
619
 
    }
620
 
  } else {
621
 
    // Drop trailing slash.
622
 
    pathname[len-1] = 0;
623
 
    if (!CreateDirectory(pathname, NULL) &&
624
 
        GetLastError() != ERROR_ALREADY_EXISTS) {
625
 
      return MakeErrMsg(ErrMsg, std::string(pathname) + ": Can't create directory: ");
626
 
    }
627
 
  }
628
 
  return false;
629
 
}
630
 
 
631
 
bool
632
 
Path::createFileOnDisk(std::string* ErrMsg) {
633
 
  // Create the file
634
 
  HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
635
 
                        FILE_ATTRIBUTE_NORMAL, NULL);
636
 
  if (h == INVALID_HANDLE_VALUE)
637
 
    return MakeErrMsg(ErrMsg, path + ": Can't create file: ");
638
 
 
639
 
  CloseHandle(h);
640
 
  return false;
641
 
}
642
 
 
643
 
bool
644
 
Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
645
 
  WIN32_FILE_ATTRIBUTE_DATA fi;
646
 
  if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
647
 
    return true;
648
 
 
649
 
  if (fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
650
 
    // If it doesn't exist, we're done.
651
 
    if (!exists())
652
 
      return false;
653
 
 
654
 
    char *pathname = reinterpret_cast<char *>(_alloca(path.length()+3));
655
 
    int lastchar = path.length() - 1 ;
656
 
    path.copy(pathname, lastchar+1);
657
 
 
658
 
    // Make path end with '/*'.
659
 
    if (pathname[lastchar] != '/')
660
 
      pathname[++lastchar] = '/';
661
 
    pathname[lastchar+1] = '*';
662
 
    pathname[lastchar+2] = 0;
663
 
 
664
 
    if (remove_contents) {
665
 
      WIN32_FIND_DATA fd;
666
 
      HANDLE h = FindFirstFile(pathname, &fd);
667
 
 
668
 
      // It's a bad idea to alter the contents of a directory while enumerating
669
 
      // its contents. So build a list of its contents first, then destroy them.
670
 
 
671
 
      if (h != INVALID_HANDLE_VALUE) {
672
 
        std::vector<Path> list;
673
 
 
674
 
        do {
675
 
          if (strcmp(fd.cFileName, ".") == 0)
676
 
            continue;
677
 
          if (strcmp(fd.cFileName, "..") == 0)
678
 
            continue;
679
 
 
680
 
          Path aPath(path);
681
 
          aPath.appendComponent(&fd.cFileName[0]);
682
 
          list.push_back(aPath);
683
 
        } while (FindNextFile(h, &fd));
684
 
 
685
 
        DWORD err = GetLastError();
686
 
        FindClose(h);
687
 
        if (err != ERROR_NO_MORE_FILES) {
688
 
          SetLastError(err);
689
 
          return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
690
 
        }
691
 
 
692
 
        for (std::vector<Path>::iterator I = list.begin(); I != list.end();
693
 
             ++I) {
694
 
          Path &aPath = *I;
695
 
          aPath.eraseFromDisk(true);
696
 
        }
697
 
      } else {
698
 
        if (GetLastError() != ERROR_FILE_NOT_FOUND)
699
 
          return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
700
 
      }
701
 
    }
702
 
 
703
 
    pathname[lastchar] = 0;
704
 
    if (!RemoveDirectory(pathname))
705
 
      return MakeErrMsg(ErrStr,
706
 
        std::string(pathname) + ": Can't destroy directory: ");
707
 
    return false;
708
 
  } else {
709
 
    // Read-only files cannot be deleted on Windows.  Must remove the read-only
710
 
    // attribute first.
711
 
    if (fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
712
 
      if (!SetFileAttributes(path.c_str(),
713
 
                             fi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
714
 
        return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
715
 
    }
716
 
 
717
 
    if (!DeleteFile(path.c_str()))
718
 
      return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
719
 
    return false;
720
 
  }
721
 
}
722
 
 
723
 
bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
724
 
  assert(len < 1024 && "Request for magic string too long");
725
 
  char* buf = reinterpret_cast<char*>(alloca(len));
726
 
 
727
 
  HANDLE h = CreateFile(path.c_str(),
728
 
                        GENERIC_READ,
729
 
                        FILE_SHARE_READ,
730
 
                        NULL,
731
 
                        OPEN_EXISTING,
732
 
                        FILE_ATTRIBUTE_NORMAL,
733
 
                        NULL);
734
 
  if (h == INVALID_HANDLE_VALUE)
735
 
    return false;
736
 
 
737
 
  DWORD nRead = 0;
738
 
  BOOL ret = ReadFile(h, buf, len, &nRead, NULL);
739
 
  CloseHandle(h);
740
 
 
741
 
  if (!ret || nRead != len)
742
 
    return false;
743
 
 
744
 
  Magic = std::string(buf, len);
745
 
  return true;
746
 
}
747
 
 
748
 
bool
749
 
Path::renamePathOnDisk(const Path& newName, std::string* ErrMsg) {
750
 
  if (!MoveFileEx(path.c_str(), newName.c_str(), MOVEFILE_REPLACE_EXISTING))
751
 
    return MakeErrMsg(ErrMsg, "Can't move '" + path + "' to '" + newName.path
752
 
        + "': ");
753
 
  return false;
754
 
}
755
 
 
756
 
bool
757
 
Path::setStatusInfoOnDisk(const FileStatus &si, std::string *ErrMsg) const {
758
 
  // FIXME: should work on directories also.
759
 
  if (!si.isFile) {
760
 
    return true;
761
 
  }
762
 
 
763
 
  HANDLE h = CreateFile(path.c_str(),
764
 
                        FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
765
 
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
766
 
                        NULL,
767
 
                        OPEN_EXISTING,
768
 
                        FILE_ATTRIBUTE_NORMAL,
769
 
                        NULL);
770
 
  if (h == INVALID_HANDLE_VALUE)
771
 
    return true;
772
 
 
773
 
  BY_HANDLE_FILE_INFORMATION bhfi;
774
 
  if (!GetFileInformationByHandle(h, &bhfi)) {
775
 
    DWORD err = GetLastError();
776
 
    CloseHandle(h);
777
 
    SetLastError(err);
778
 
    return MakeErrMsg(ErrMsg, path + ": GetFileInformationByHandle: ");
779
 
  }
780
 
 
781
 
  ULARGE_INTEGER ui;
782
 
  ui.QuadPart = si.modTime.toWin32Time();
783
 
  FILETIME ft;
784
 
  ft.dwLowDateTime = ui.LowPart;
785
 
  ft.dwHighDateTime = ui.HighPart;
786
 
  BOOL ret = SetFileTime(h, NULL, &ft, &ft);
787
 
  DWORD err = GetLastError();
788
 
  CloseHandle(h);
789
 
  if (!ret) {
790
 
    SetLastError(err);
791
 
    return MakeErrMsg(ErrMsg, path + ": SetFileTime: ");
792
 
  }
793
 
 
794
 
  // Best we can do with Unix permission bits is to interpret the owner
795
 
  // writable bit.
796
 
  if (si.mode & 0200) {
797
 
    if (bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
798
 
      if (!SetFileAttributes(path.c_str(),
799
 
              bhfi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
800
 
        return MakeErrMsg(ErrMsg, path + ": SetFileAttributes: ");
801
 
    }
802
 
  } else {
803
 
    if (!(bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
804
 
      if (!SetFileAttributes(path.c_str(),
805
 
              bhfi.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
806
 
        return MakeErrMsg(ErrMsg, path + ": SetFileAttributes: ");
807
 
    }
808
 
  }
809
 
 
810
 
  return false;
811
 
}
812
 
 
813
 
bool
814
 
CopyFile(const sys::Path &Dest, const sys::Path &Src, std::string* ErrMsg) {
815
 
  // Can't use CopyFile macro defined in Windows.h because it would mess up the
816
 
  // above line.  We use the expansion it would have in a non-UNICODE build.
817
 
  if (!::CopyFileA(Src.c_str(), Dest.c_str(), false))
818
 
    return MakeErrMsg(ErrMsg, "Can't copy '" + Src.str() +
819
 
               "' to '" + Dest.str() + "': ");
820
 
  return false;
821
 
}
822
 
 
823
 
bool
824
 
Path::makeUnique(bool reuse_current, std::string* ErrMsg) {
825
 
  if (reuse_current && !exists())
826
 
    return false; // File doesn't exist already, just use it!
827
 
 
828
 
  // Reserve space for -XXXXXX at the end.
829
 
  char *FNBuffer = (char*) alloca(path.size()+8);
830
 
  unsigned offset = path.size();
831
 
  path.copy(FNBuffer, offset);
832
 
 
833
 
  // Find a numeric suffix that isn't used by an existing file.  Assume there
834
 
  // won't be more than 1 million files with the same prefix.  Probably a safe
835
 
  // bet.
836
 
  static unsigned FCounter = 0;
837
 
  do {
838
 
    sprintf(FNBuffer+offset, "-%06u", FCounter);
839
 
    if (++FCounter > 999999)
840
 
      FCounter = 0;
841
 
    path = FNBuffer;
842
 
  } while (exists());
843
 
  return false;
844
 
}
845
 
 
846
 
bool
847
 
Path::createTemporaryFileOnDisk(bool reuse_current, std::string* ErrMsg) {
848
 
  // Make this into a unique file name
849
 
  makeUnique(reuse_current, ErrMsg);
850
 
 
851
 
  // Now go and create it
852
 
  HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
853
 
                        FILE_ATTRIBUTE_NORMAL, NULL);
854
 
  if (h == INVALID_HANDLE_VALUE)
855
 
    return MakeErrMsg(ErrMsg, path + ": can't create file");
856
 
 
857
 
  CloseHandle(h);
858
 
  return false;
859
 
}
860
 
 
861
 
/// MapInFilePages - Not yet implemented on win32.
862
 
const char *Path::MapInFilePages(int FD, uint64_t FileSize) {
863
 
  return 0;
864
 
}
865
 
 
866
 
/// MapInFilePages - Not yet implemented on win32.
867
 
void Path::UnMapFilePages(const char *Base, uint64_t FileSize) {
868
 
  assert(0 && "NOT IMPLEMENTED");
869
 
}
870
 
 
871
 
}
872
 
}