2 // compat.cpp -- compatibilty layer to make bacula-fd run
3 // natively under windows
5 // Copyright transferred from Raider Solutions, Inc to
6 // Kern Sibbald and John Walker by express permission.
8 // Copyright (C) 2004 Kern Sibbald and John Walker
10 // This program is free software; you can redistribute it and/or
11 // modify it under the terms of the GNU General Public License as
12 // published by the Free Software Foundation; either version 2 of
13 // the License, or (at your option) any later version.
15 // This program is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // General Public License for more details.
20 // You should have received a copy of the GNU General Public
21 // License along with this program; if not, write to the Free
22 // Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
23 // MA 02111-1307, USA.
25 // Author : Christopher S. Hull
26 // Created On : Sat Jan 31 15:55:00 2004
34 #define USE_WIN32_COMPAT_IO 1
36 extern void d_msg(const char *file, int line, int level, const char *fmt,...);
37 extern DWORD g_platform_id;
39 // from CYGWIN (should be diff between Jan 1 1601 and Jan 1 1970
41 #define WIN32_FILETIME_ADJUST 0x19DB1DED53E8000UL //Not sure it works
43 #define WIN32_FILETIME_ADJUST 0x19DB1DED53E8000I64
46 #define WIN32_FILETIME_SCALE 10000000 // 100ns/second
49 cygwin_conv_to_win32_path(const char *name, char *win32_name)
51 const char *fname = name;
53 /* Check for Unix separator and convert to Win32 */
55 *win32_name++ = '\\'; /* convert char */
56 /* If Win32 separated that is "quoted", remove quote */
57 } else if (*name == '\\' && name[1] == '\\') {
59 name++; /* skip first \ */
61 *win32_name++ = *name; /* copy character */
65 /* Strip any trailing slash, if we stored something */
66 if (*fname != 0 && win32_name[-1] == '\\') {
75 wchar_win32_path(const char *name, WCHAR *win32_name)
77 const char *fname = name;
79 /* Check for Unix separator and convert to Win32 */
81 *win32_name++ = '\\'; /* convert char */
82 /* If Win32 separated that is "quoted", remove quote */
83 } else if (*name == '\\' && name[1] == '\\') {
85 name++; /* skip first \ */
87 *win32_name++ = *name; /* copy character */
91 /* Strip any trailing slash, if we stored something */
92 if (*fname != 0 && win32_name[-1] == '\\') {
106 chmod(const char *, mode_t)
112 chown(const char *k, uid_t, gid_t)
118 lchown(const char *k, uid_t, gid_t)
132 srandom(unsigned int seed)
136 // /////////////////////////////////////////////////////////////////
137 // convert from Windows concept of time to Unix concept of time
138 // /////////////////////////////////////////////////////////////////
140 cvt_utime_to_ftime(const time_t &time, FILETIME &wintime)
142 uint64_t mstime = time;
143 mstime *= WIN32_FILETIME_SCALE;
144 mstime += WIN32_FILETIME_ADJUST;
147 wintime.dwLowDateTime = (DWORD)(mstime & 0xffffffffUL);
149 wintime.dwLowDateTime = (DWORD)(mstime & 0xffffffffI64);
151 wintime.dwHighDateTime = (DWORD) ((mstime>>32)& 0xffffffffUL);
155 cvt_ftime_to_utime(const FILETIME &time)
157 uint64_t mstime = time.dwHighDateTime;
159 mstime |= time.dwLowDateTime;
161 mstime -= WIN32_FILETIME_ADJUST;
162 mstime /= WIN32_FILETIME_SCALE; // convert to seconds.
164 return (time_t) (mstime & 0xffffffff);
172 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
173 FORMAT_MESSAGE_FROM_SYSTEM |
174 FORMAT_MESSAGE_IGNORE_INSERTS,
177 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default lang
182 return (const char *) lpMsgBuf;
188 statDir(const char *file, struct stat *sb)
190 WIN32_FIND_DATA info; // window's file info
192 if (file[1] == ':' && file[2] == 0) {
193 d_msg(__FILE__, __LINE__, 99, "faking ROOT attrs(%s).\n", file);
194 sb->st_mode = S_IFDIR;
195 sb->st_mode |= S_IREAD|S_IEXEC|S_IWRITE;
201 HANDLE h = FindFirstFile(file, &info);
203 if (h == INVALID_HANDLE_VALUE) {
204 const char *err = errorString();
205 d_msg(__FILE__, __LINE__, 99, "FindFirstFile(%s):%s\n", file, err);
206 LocalFree((void *)err);
207 errno = GetLastError();
211 sb->st_mode = 0777; /* start with everything */
212 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
213 sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
214 if (info.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
215 sb->st_mode &= ~S_IRWXO; /* remove everything for other */
216 if (info.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
217 sb->st_mode |= S_ISVTX; /* use sticky bit -> hidden */
218 sb->st_mode |= S_IFDIR;
220 sb->st_size = info.nFileSizeHigh;
222 sb->st_size |= info.nFileSizeLow;
223 sb->st_blksize = 4096;
224 sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096;
226 sb->st_atime = cvt_ftime_to_utime(info.ftLastAccessTime);
227 sb->st_mtime = cvt_ftime_to_utime(info.ftLastWriteTime);
228 sb->st_ctime = cvt_ftime_to_utime(info.ftLastWriteTime);
235 stat2(const char *file, struct stat *sb)
237 BY_HANDLE_FILE_INFORMATION info;
241 cygwin_conv_to_win32_path(file, tmpbuf);
243 DWORD attr = GetFileAttributes(tmpbuf);
246 const char *err = errorString();
247 d_msg(__FILE__, __LINE__, 99,
248 "GetFileAttrubtes(%s): %s\n", tmpbuf, err);
249 LocalFree((void *)err);
250 errno = GetLastError();
254 if (attr & FILE_ATTRIBUTE_DIRECTORY)
255 return statDir(tmpbuf, sb);
257 h = CreateFile(tmpbuf, GENERIC_READ,
258 FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
260 if (h == INVALID_HANDLE_VALUE) {
261 const char *err = errorString();
262 d_msg(__FILE__, __LINE__, 99,
263 "Cannot open file for stat (%s):%s\n", tmpbuf, err);
264 LocalFree((void *)err);
266 errno = GetLastError();
270 if (!GetFileInformationByHandle(h, &info)) {
271 const char *err = errorString();
272 d_msg(__FILE__, __LINE__, 99,
273 "GetfileInformationByHandle(%s): %s\n", tmpbuf, err);
274 LocalFree((void *)err);
276 errno = GetLastError();
280 sb->st_dev = info.dwVolumeSerialNumber;
281 sb->st_ino = info.nFileIndexHigh;
283 sb->st_ino |= info.nFileIndexLow;
284 sb->st_nlink = (short)info.nNumberOfLinks;
286 sb->st_mode = 0777; /* start with everything */
287 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
288 sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
289 if (info.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
290 sb->st_mode &= ~S_IRWXO; /* remove everything for other */
291 if (info.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
292 sb->st_mode |= S_ISVTX; /* use sticky bit -> hidden */
293 sb->st_mode |= S_IFREG;
295 sb->st_size = info.nFileSizeHigh;
297 sb->st_size |= info.nFileSizeLow;
298 sb->st_blksize = 4096;
299 sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096;
300 sb->st_atime = cvt_ftime_to_utime(info.ftLastAccessTime);
301 sb->st_mtime = cvt_ftime_to_utime(info.ftLastWriteTime);
302 sb->st_ctime = cvt_ftime_to_utime(info.ftLastWriteTime);
310 stat(const char *file, struct stat *sb)
312 WIN32_FILE_ATTRIBUTE_DATA data;
316 memset(sb, 0, sizeof(*sb));
318 if (g_platform_id == VER_PLATFORM_WIN32_WINDOWS)
319 return stat2(file, sb);
321 // otherwise we're on NT
329 wchar_win32_path(file, buf+4);
331 if (!GetFileAttributesExW((WCHAR *)buf, GetFileExInfoStandard, &data))
332 return stat2(file, sb);
334 if (!GetFileAttributesEx(file, GetFileExInfoStandard, &data))
335 return stat2(file, sb);
338 sb->st_mode = 0777; /* start with everything */
339 if (data.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
340 sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
341 if (data.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
342 sb->st_mode &= ~S_IRWXO; /* remove everything for other */
343 if (data.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
344 sb->st_mode |= S_ISVTX; /* use sticky bit -> hidden */
346 if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
347 sb->st_mode |= S_IFDIR;
349 sb->st_mode |= S_IFREG;
352 sb->st_size = data.nFileSizeHigh;
354 sb->st_size |= data.nFileSizeLow;
355 sb->st_blksize = 4096;
356 sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096;
357 sb->st_atime = cvt_ftime_to_utime(data.ftLastAccessTime);
358 sb->st_mtime = cvt_ftime_to_utime(data.ftLastWriteTime);
359 sb->st_ctime = cvt_ftime_to_utime(data.ftLastWriteTime);
366 lstat(const char *file, struct stat *sb)
368 return stat(file, sb);
384 execvp(const char *, char *[]) {
402 waitpid(int, int*, int)
408 readlink(const char *, char *, int)
416 strcasecmp(const char *s1, const char *s2)
418 register int ch1, ch2;
421 return 0; /* strings are equal if same object. */
432 } while (ch1 != 0 && tolower(ch1) == tolower(ch2));
439 strncasecmp(const char *s1, const char *s2, int len)
441 register int ch1, ch2;
444 return 0; /* strings are equal if same object. */
455 } while (len-- && ch1 != 0 && tolower(ch1) == tolower(ch2));
461 gettimeofday(struct timeval *tv, struct timezone *)
467 if (tv == NULL) return -1;
468 if (!SystemTimeToFileTime(&now, &tmp)) return -1;
470 int64_t _100nsec = tmp.dwHighDateTime;
472 _100nsec |= tmp.dwLowDateTime;
473 _100nsec -= WIN32_FILETIME_ADJUST;
475 tv->tv_sec =(long) (_100nsec / 10000000);
476 tv->tv_usec = (long) ((_100nsec % 10000000)/10);
482 syslog(int type, const char *fmt, const char *msg)
484 /*#ifndef HAVE_CONSOLE
485 MessageBox(NULL, msg, "Bacula", MB_OK);
502 // implement opendir/readdir/closedir on top of window's API
505 WIN32_FIND_DATA data; // window's file info
506 const char *spec; // the directory we're traversing
507 HANDLE dirh; // the search handle
508 BOOL valid; // the info in data field is valid
509 UINT32 offset; // pseudo offset for d_off
513 opendir(const char *path)
515 int max_len = strlen(path) + 16;
517 if (path == NULL) return NULL;
519 rval = (_dir *)malloc(sizeof(_dir));
520 if (rval == NULL) return NULL;
521 char *tspec = (char *)malloc(max_len);
522 if (tspec == NULL) goto err1;
524 if (g_platform_id != VER_PLATFORM_WIN32_WINDOWS) {
525 // allow path to be 32767 bytes
531 cygwin_conv_to_win32_path(path, tspec+4);
533 cygwin_conv_to_win32_path(path, tspec);
536 strncat(tspec, "\\*", max_len);
539 rval->dirh = FindFirstFile(rval->spec, &rval->data);
540 d_msg(__FILE__, __LINE__,
541 99, "opendir(%s)\n\tspec=%s,\n\tFindFirstFile returns %d\n",
542 path, rval->spec, rval->dirh);
545 if (rval->dirh == INVALID_HANDLE_VALUE)
548 d_msg(__FILE__, __LINE__,
549 99, "\tFirstFile=%s\n", rval->data.cFileName);
552 free((void *)rval->spec);
561 _dir *dp = (_dir *)dirp;
563 free((void *)dp->spec);
569 typedef struct _WIN32_FIND_DATA {
570 DWORD dwFileAttributes;
571 FILETIME ftCreationTime;
572 FILETIME ftLastAccessTime;
573 FILETIME ftLastWriteTime;
578 TCHAR cFileName[MAX_PATH];
579 TCHAR cAlternateFileName[14];
580 } WIN32_FIND_DATA, *PWIN32_FIND_DATA;
584 copyin(struct dirent &dp, const char *fname)
588 char *cp = dp.d_name;
598 readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result)
601 _dir *dp = (_dir *)dirp;
603 entry->d_off = dp->offset;
604 dp->offset += copyin(*entry, dp->data.cFileName);
605 *result = entry; /* return entry address */
606 d_msg(__FILE__, __LINE__,
607 99, "readdir_r(%p, { d_name=\"%s\", d_reclen=%d, d_off=%d\n",
608 dirp, entry->d_name, entry->d_reclen, entry->d_off);
610 // d_msg(__FILE__, __LINE__, 99, "readdir_r !valid\n");
613 dp->valid = FindNextFile(dp->dirh, &dp->data);
618 inet_aton(const char *a, struct in_addr *inp)
622 uint32_t acc = 0, tmp = 0;
624 if (!isdigit(*a)) return 0;
627 tmp = (tmp * 10) + (*cp -'0');
628 else if (*cp == '.') {
629 if (tmp > 255) return 0;
630 acc = (acc << 8) + tmp;
636 if (dotc != 3) return 0;
642 nanosleep(const struct timespec *req, struct timespec *rem)
645 rem->tv_sec = rem->tv_nsec = 0;
646 Sleep((req->tv_sec * 1000) + (req->tv_nsec/100000));
651 init_signals(void terminate(int sig))
657 init_stack_dump(void)
664 pathconf(const char *path, int name)
668 if (strncmp(path, "\\\\?\\", 4) == 0)
680 WORD wVersionRequested = MAKEWORD( 1, 1);
683 int err = WSAStartup(wVersionRequested, &wsaData);
688 printf("Can not start Windows Sockets\n");
697 win32_chdir(const char *dir)
699 if (0 == SetCurrentDirectory(dir)) return -1;
704 win32_getcwd(char *buf, int maxlen)
706 int n = GetCurrentDirectory(maxlen, buf);
708 if (n == 0 || n > maxlen) return NULL;
710 if (n+1 > maxlen) return NULL;
719 #include "mswinver.h"
721 char WIN_VERSION_LONG[64];
722 char WIN_VERSION[32];
729 static winver INIT; // cause constructor to be called before main()
736 const char *version = "";
737 const char *platform = "";
738 OSVERSIONINFO osvinfo;
739 osvinfo.dwOSVersionInfoSize = sizeof(osvinfo);
741 // Get the current OS version
742 if (!GetVersionEx(&osvinfo)) {
744 platform = "Unknown";
747 switch (_mkversion(osvinfo.dwPlatformId, osvinfo.dwMajorVersion, osvinfo.dwMinorVersion))
749 case MS_WINDOWS_95: (version = "Windows 95"); break;
750 case MS_WINDOWS_98: (version = "Windows 98"); break;
751 case MS_WINDOWS_ME: (version = "Windows ME"); break;
752 case MS_WINDOWS_NT4:(version = "Windows NT 4.0"); platform = "NT"; break;
753 case MS_WINDOWS_2K: (version = "Windows 2000");platform = "NT"; break;
754 case MS_WINDOWS_XP: (version = "Windows XP");platform = "NT"; break;
755 case MS_WINDOWS_S2003: (version = "Windows Server 2003");platform = "NT"; break;
756 default: version = "Windows ??"; break;
759 bstrncpy(WIN_VERSION_LONG, version, sizeof(WIN_VERSION_LONG));
760 snprintf(WIN_VERSION, sizeof(WIN_VERSION), "%s %d.%d.%d",
761 platform, osvinfo.dwMajorVersion, osvinfo.dwMinorVersion, osvinfo.dwBuildNumber);
764 HANDLE h = CreateFile("G:\\foobar", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
768 BPIPE *b = open_bpipe("ls -l", 10, "r");
770 while (!feof(b->rfd)) {
771 fgets(buf, sizeof(buf), b->rfd);
777 BOOL CreateChildProcess(VOID);
778 VOID WriteToPipe(VOID);
779 VOID ReadFromPipe(VOID);
780 VOID ErrorExit(LPTSTR);
781 VOID ErrMsg(LPTSTR, BOOL);
785 getArgv0(const char *cmdline)
787 const char *cp = cmdline;
789 while (*cp && !isspace(*cp)) cp++;
791 int len = cp - cmdline;
792 char *rval = (char *)malloc(len+1);
804 CreateChildProcess(const char *cmdline, HANDLE in, HANDLE out, HANDLE err)
806 PROCESS_INFORMATION piProcInfo;
807 STARTUPINFO siStartInfo;
808 BOOL bFuncRetn = FALSE;
810 // Set up members of the PROCESS_INFORMATION structure.
812 ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
814 // Set up members of the STARTUPINFO structure.
816 ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
817 siStartInfo.cb = sizeof(STARTUPINFO);
818 // setup new process to use supplied handles for stdin,stdout,stderr
819 // if supplied handles are not used the send a copy of our STD_HANDLE
821 siStartInfo.dwFlags = STARTF_USESTDHANDLES;
823 if (in != INVALID_HANDLE_VALUE)
824 siStartInfo.hStdInput = in;
826 siStartInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
828 if (out != INVALID_HANDLE_VALUE)
829 siStartInfo.hStdOutput = out;
831 siStartInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
832 if (err != INVALID_HANDLE_VALUE)
833 siStartInfo.hStdError = err;
835 siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
836 // Create the child process.
840 // retrive the first compont of the command line which should be the
842 const char *exeName = getArgv0(cmdline);
843 // check to see if absolute path was passed to us already?
844 if (exeName[1] != ':'
845 || (strchr(cmdline, '/') == NULL
846 && strchr(cmdline, '\\') == NULL))
848 // only command name so perform search of PATH to find
850 DWORD rval = SearchPath(NULL,
857 return INVALID_HANDLE_VALUE;
858 if (rval > sizeof(exeFile))
859 return INVALID_HANDLE_VALUE;
863 strcpy(exeFile, exeName);
865 // exeFile now has absolute path to program to execute.
866 free((void *)exeName);
867 // copy original command line to pass to create process
868 strcpy(cmdLine, cmdline);
869 // try to execute program
870 bFuncRetn = CreateProcess(exeFile,
871 cmdLine, // command line
872 NULL, // process security attributes
873 NULL, // primary thread security attributes
874 TRUE, // handles are inherited
876 NULL, // use parent's environment
877 NULL, // use parent's current directory
878 &siStartInfo, // STARTUPINFO pointer
879 &piProcInfo); // receives PROCESS_INFORMATION
881 if (bFuncRetn == 0) {
882 ErrorExit("CreateProcess failed\n");
883 return INVALID_HANDLE_VALUE;
885 // we don't need a handle on the process primary thread so we close
887 CloseHandle(piProcInfo.hThread);
889 return piProcInfo.hProcess;
894 ErrorExit (LPTSTR lpszMessage)
896 d_msg(__FILE__, __LINE__, 0, "%s", lpszMessage);
901 typedef struct s_bpipe {
912 CloseIfValid(HANDLE handle)
914 if (handle != INVALID_HANDLE_VALUE)
920 open_bpipe(char *prog, int wait, const char *mode)
922 HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup,
923 hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup,
926 SECURITY_ATTRIBUTES saAttr;
930 hChildStdinRd = hChildStdinWr = hChildStdinWrDup =
931 hChildStdoutRd = hChildStdoutWr = hChildStdoutRdDup =
932 hInputFile = INVALID_HANDLE_VALUE;
934 BPIPE *bpipe = (BPIPE *)malloc(sizeof(BPIPE));
935 memset((void *)bpipe, 0, sizeof(BPIPE));
937 int mode_read = (mode[0] == 'r');
938 int mode_write = (mode[0] == 'w' || mode[1] == 'w');
941 // Set the bInheritHandle flag so pipe handles are inherited.
943 saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
944 saAttr.bInheritHandle = TRUE;
945 saAttr.lpSecurityDescriptor = NULL;
949 // Create a pipe for the child process's STDOUT.
950 if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) {
951 ErrorExit("Stdout pipe creation failed\n");
954 // Create noninheritable read handle and close the inheritable read
957 fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,
958 GetCurrentProcess(), &hChildStdoutRdDup , 0,
960 DUPLICATE_SAME_ACCESS);
962 ErrorExit("DuplicateHandle failed");
966 CloseHandle(hChildStdoutRd);
971 // Create a pipe for the child process's STDIN.
973 if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) {
974 ErrorExit("Stdin pipe creation failed\n");
978 // Duplicate the write handle to the pipe so it is not inherited.
979 fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr,
980 GetCurrentProcess(), &hChildStdinWrDup,
982 FALSE, // not inherited
983 DUPLICATE_SAME_ACCESS);
985 ErrorExit("DuplicateHandle failed");
989 CloseHandle(hChildStdinWr);
991 // spawn program with redirected handles as appropriate
992 bpipe->worker_pid = (pid_t)
993 CreateChildProcess(prog, // commandline
994 hChildStdinRd, // stdin HANDLE
995 hChildStdoutWr, // stdout HANDLE
996 hChildStdoutWr);// stderr HANDLE
998 if ((HANDLE) bpipe->worker_pid == INVALID_HANDLE_VALUE)
1002 bpipe->worker_stime = time(NULL);
1005 CloseHandle(hChildStdoutWr); // close our write side so when
1006 // process terminates we can
1008 // ugly but convert WIN32 HANDLE to FILE*
1009 int rfd = _open_osfhandle((long)hChildStdoutRdDup, O_RDONLY);
1010 bpipe->rfd = _fdopen(rfd, "r");
1013 CloseHandle(hChildStdinRd); // close our read side so as not
1014 // to interfre with child's copy
1015 // ugly but convert WIN32 HANDLE to FILE*
1016 int wfd = _open_osfhandle((long)hChildStdinWrDup, O_WRONLY);
1017 bpipe->wfd = _fdopen(wfd, "w");
1021 bpipe->timer_id = start_child_timer(bpipe->worker_pid, wait);
1028 CloseIfValid(hChildStdoutRd);
1029 CloseIfValid(hChildStdoutRdDup);
1030 CloseIfValid(hChildStdinWr);
1031 CloseIfValid(hChildStdinWrDup);
1033 free((void *) bpipe);
1041 kill(int pid, int signal)
1044 if (!TerminateProcess((HANDLE)pid, (UINT) signal))
1046 CloseHandle((HANDLE)pid);
1053 close_bpipe(BPIPE *bpipe)
1056 if (bpipe->rfd) fclose(bpipe->rfd);
1057 if (bpipe->wfd) fclose(bpipe->wfd);
1060 int remaining_wait = bpipe->wait;
1064 if (!GetExitCodeProcess((HANDLE)bpipe->worker_pid, &exitCode))
1066 const char *err = errorString();
1067 rval = GetLastError();
1068 d_msg(__FILE__, __LINE__, 0,
1069 "GetExitCode error %s\n", err);
1070 LocalFree((void *)err);
1074 if (exitCode == STILL_ACTIVE) {
1075 bmicrosleep(1, 0); /* wait one second */
1079 } while(remaining_wait);
1082 if (bpipe->timer_id) {
1083 stop_child_timer(bpipe->timer_id);
1085 free((void *)bpipe);
1090 close_wpipe(BPIPE *bpipe)
1096 if (fclose(bpipe->wfd) != 0) {
1104 #include "findlib/find.h"
1107 utime(const char *fname, struct utimbuf *times)
1112 cygwin_conv_to_win32_path(fname, tmpbuf);
1114 cvt_utime_to_ftime(times->actime, acc);
1115 cvt_utime_to_ftime(times->modtime, mod);
1117 HANDLE h = CreateFile(tmpbuf,
1118 FILE_WRITE_ATTRIBUTES,
1125 if (h == INVALID_HANDLE_VALUE) {
1126 const char *err = errorString();
1127 d_msg(__FILE__, __LINE__, 99,
1128 "Cannot open file for utime(%s,...):%s\n", tmpbuf, err);
1129 LocalFree((void *)err);
1133 int rval = SetFileTime(h, NULL, &acc, &mod) ? 0 : -1;
1140 #if USE_WIN32_COMPAT_IO
1143 open(const char *file, int flags, int mode)
1145 return _open(file, flags|_O_BINARY, mode);
1155 #ifndef HAVE_WXCONSOLE
1157 read(int fd, void *buf, size_t len)
1159 return _read(fd, buf, len);
1163 write(int fd, const void *buf, size_t len)
1165 return _write(fd, buf, len);
1170 lseek(int fd, off_t offset, int whence)
1172 return (off_t)_lseeki64(fd, offset, whence);
1176 dup2(int fd1, int fd2)
1178 return _dup2(fd1, fd2);
1182 open(const char *file, int flags, int mode)
1185 DWORD shareMode = 0;
1189 const char *remap = file;
1191 if (flags & O_WRONLY) access = GENERIC_WRITE;
1192 else if (flags & O_RDWR) access = GENERIC_READ|GENERIC_WRITE;
1193 else access = GENERIC_READ;
1195 if (flags & O_CREAT) create = CREATE_NEW;
1196 else create = OPEN_EXISTING;
1198 if (flags & O_TRUNC) create = TRUNCATE_EXISTING;
1200 if (!(flags & O_EXCL))
1201 shareMode = FILE_SHARE_DELETE|FILE_SHARE_READ|FILE_SHARE_WRITE;
1203 if (flags & O_APPEND)
1205 printf("open...APPEND not implemented yet.");
1209 foo = CreateFile(file, access, shareMode, NULL, create, msflags, NULL);
1210 if (INVALID_HANDLE_VALUE == foo)
1221 if (!CloseHandle((HANDLE)fd))
1228 write(int fd, const void *data, size_t len)
1232 status = WriteFile((HANDLE)fd, data, len, &bwrite, NULL);
1233 if (status) return bwrite;
1239 read(int fd, void *data, size_t len)
1244 status = ReadFile((HANDLE)fd, data, len, &bread, NULL);
1245 if (status) return bread;
1250 lseek(int fd, off_t offset, int whence)
1255 method = FILE_BEGIN;
1258 method = FILE_CURRENT;
1267 return SetFilePointer((HANDLE)fd, (DWORD)offset, NULL, method);
1282 /* syslog function, added by Nicolas Boichat */