[370] | 1 | /* $Id: mscfakes.c 3387 2020-06-26 16:51:19Z bird $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * Fake Unix stuff for MSC.
|
---|
[2019] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[2756] | 7 | * Copyright (c) 2005-2015 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
|
---|
[370] | 8 | *
|
---|
[2019] | 9 | * This file is part of kBuild.
|
---|
[370] | 10 | *
|
---|
[2019] | 11 | * kBuild is free software; you can redistribute it and/or modify
|
---|
[370] | 12 | * it under the terms of the GNU General Public License as published by
|
---|
[2019] | 13 | * the Free Software Foundation; either version 3 of the License, or
|
---|
[370] | 14 | * (at your option) any later version.
|
---|
| 15 | *
|
---|
[2019] | 16 | * kBuild is distributed in the hope that it will be useful,
|
---|
[370] | 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 19 | * GNU General Public License for more details.
|
---|
| 20 | *
|
---|
| 21 | * You should have received a copy of the GNU General Public License
|
---|
[2019] | 22 | * along with kBuild. If not, see <http://www.gnu.org/licenses/>
|
---|
[370] | 23 | *
|
---|
| 24 | */
|
---|
| 25 |
|
---|
[2019] | 26 | /*******************************************************************************
|
---|
| 27 | * Header Files *
|
---|
| 28 | *******************************************************************************/
|
---|
[2113] | 29 | #include "config.h"
|
---|
[2756] | 30 | #include <assert.h>
|
---|
[370] | 31 | #include <stdarg.h>
|
---|
| 32 | #include <stdio.h>
|
---|
| 33 | #include <stdlib.h>
|
---|
| 34 | #include <string.h>
|
---|
| 35 | #include <errno.h>
|
---|
| 36 | #include <io.h>
|
---|
| 37 | #include <fcntl.h>
|
---|
[1108] | 38 | #include <sys/stat.h>
|
---|
[3060] | 39 | #include <sys/timeb.h>
|
---|
[370] | 40 | #include "err.h"
|
---|
| 41 | #include "mscfakes.h"
|
---|
| 42 |
|
---|
[3060] | 43 | #include "nt/ntutimes.h"
|
---|
| 44 | #undef utimes
|
---|
| 45 | #undef lutimes
|
---|
| 46 |
|
---|
[3188] | 47 | #include "console.h"
|
---|
[3060] | 48 |
|
---|
[3117] | 49 |
|
---|
[3188] | 50 |
|
---|
[2756] | 51 | /*******************************************************************************
|
---|
| 52 | * Internal Functions *
|
---|
| 53 | *******************************************************************************/
|
---|
| 54 | static BOOL isPipeFd(int fd);
|
---|
[1108] | 55 |
|
---|
[2756] | 56 |
|
---|
[1710] | 57 | /**
|
---|
| 58 | * Makes corrections to a directory path that ends with a trailing slash.
|
---|
| 59 | *
|
---|
| 60 | * @returns temporary buffer to free.
|
---|
| 61 | * @param ppszPath The path pointer. This is updated when necessary.
|
---|
| 62 | * @param pfMustBeDir This is set if it must be a directory, otherwise it's cleared.
|
---|
| 63 | */
|
---|
| 64 | static char *
|
---|
| 65 | msc_fix_path(const char **ppszPath, int *pfMustBeDir)
|
---|
| 66 | {
|
---|
| 67 | const char *pszPath = *ppszPath;
|
---|
| 68 | const char *psz;
|
---|
| 69 | char *pszNew;
|
---|
| 70 | *pfMustBeDir = 0;
|
---|
| 71 |
|
---|
| 72 | /*
|
---|
| 73 | * Skip any compusory trailing slashes
|
---|
| 74 | */
|
---|
| 75 | if (pszPath[0] == '/' || pszPath[0] == '\\')
|
---|
| 76 | {
|
---|
| 77 | if ( (pszPath[1] == '/' || pszPath[1] == '\\')
|
---|
| 78 | && pszPath[2] != '/'
|
---|
| 79 | && pszPath[2] != '\\')
|
---|
| 80 | /* unc */
|
---|
| 81 | pszPath += 2;
|
---|
| 82 | else
|
---|
| 83 | /* root slash(es) */
|
---|
| 84 | pszPath++;
|
---|
| 85 | }
|
---|
| 86 | else if ( isalpha(pszPath[0])
|
---|
| 87 | && pszPath[1] == ':')
|
---|
| 88 | {
|
---|
| 89 | if (pszPath[2] == '/' || pszPath[2] == '\\')
|
---|
| 90 | /* drive w/ slash */
|
---|
| 91 | pszPath += 3;
|
---|
| 92 | else
|
---|
| 93 | /* drive relative path. */
|
---|
| 94 | pszPath += 2;
|
---|
| 95 | }
|
---|
| 96 | /* else: relative path, no skipping necessary. */
|
---|
| 97 |
|
---|
| 98 | /*
|
---|
| 99 | * Any trailing slashes to drop off?
|
---|
| 100 | */
|
---|
| 101 | psz = strchr(pszPath, '\0');
|
---|
| 102 | if (pszPath <= psz)
|
---|
| 103 | return NULL;
|
---|
| 104 | if ( psz[-1] != '/'
|
---|
| 105 | || psz[-1] != '\\')
|
---|
| 106 | return NULL;
|
---|
| 107 |
|
---|
| 108 | /* figure how many, make a copy and strip them off. */
|
---|
| 109 | while ( psz > pszPath
|
---|
| 110 | && ( psz[-1] == '/'
|
---|
| 111 | || psz[-1] == '\\'))
|
---|
| 112 | psz--;
|
---|
| 113 | pszNew = strdup(pszPath);
|
---|
| 114 | pszNew[psz - pszPath] = '\0';
|
---|
| 115 |
|
---|
| 116 | *pfMustBeDir = 1;
|
---|
| 117 | *ppszPath = pszNew; /* use this one */
|
---|
| 118 | return pszNew;
|
---|
| 119 | }
|
---|
| 120 |
|
---|
| 121 |
|
---|
[2702] | 122 | int
|
---|
[2733] | 123 | birdSetErrno(unsigned dwErr)
|
---|
[1710] | 124 | {
|
---|
| 125 | switch (dwErr)
|
---|
| 126 | {
|
---|
| 127 | default:
|
---|
| 128 | case ERROR_INVALID_FUNCTION: errno = EINVAL; break;
|
---|
| 129 | case ERROR_FILE_NOT_FOUND: errno = ENOENT; break;
|
---|
| 130 | case ERROR_PATH_NOT_FOUND: errno = ENOENT; break;
|
---|
| 131 | case ERROR_TOO_MANY_OPEN_FILES: errno = EMFILE; break;
|
---|
| 132 | case ERROR_ACCESS_DENIED: errno = EACCES; break;
|
---|
| 133 | case ERROR_INVALID_HANDLE: errno = EBADF; break;
|
---|
| 134 | case ERROR_ARENA_TRASHED: errno = ENOMEM; break;
|
---|
| 135 | case ERROR_NOT_ENOUGH_MEMORY: errno = ENOMEM; break;
|
---|
| 136 | case ERROR_INVALID_BLOCK: errno = ENOMEM; break;
|
---|
| 137 | case ERROR_BAD_ENVIRONMENT: errno = E2BIG; break;
|
---|
| 138 | case ERROR_BAD_FORMAT: errno = ENOEXEC; break;
|
---|
| 139 | case ERROR_INVALID_ACCESS: errno = EINVAL; break;
|
---|
| 140 | case ERROR_INVALID_DATA: errno = EINVAL; break;
|
---|
| 141 | case ERROR_INVALID_DRIVE: errno = ENOENT; break;
|
---|
| 142 | case ERROR_CURRENT_DIRECTORY: errno = EACCES; break;
|
---|
| 143 | case ERROR_NOT_SAME_DEVICE: errno = EXDEV; break;
|
---|
| 144 | case ERROR_NO_MORE_FILES: errno = ENOENT; break;
|
---|
| 145 | case ERROR_LOCK_VIOLATION: errno = EACCES; break;
|
---|
| 146 | case ERROR_BAD_NETPATH: errno = ENOENT; break;
|
---|
| 147 | case ERROR_NETWORK_ACCESS_DENIED: errno = EACCES; break;
|
---|
| 148 | case ERROR_BAD_NET_NAME: errno = ENOENT; break;
|
---|
| 149 | case ERROR_FILE_EXISTS: errno = EEXIST; break;
|
---|
| 150 | case ERROR_CANNOT_MAKE: errno = EACCES; break;
|
---|
| 151 | case ERROR_FAIL_I24: errno = EACCES; break;
|
---|
| 152 | case ERROR_INVALID_PARAMETER: errno = EINVAL; break;
|
---|
| 153 | case ERROR_NO_PROC_SLOTS: errno = EAGAIN; break;
|
---|
| 154 | case ERROR_DRIVE_LOCKED: errno = EACCES; break;
|
---|
| 155 | case ERROR_BROKEN_PIPE: errno = EPIPE; break;
|
---|
| 156 | case ERROR_DISK_FULL: errno = ENOSPC; break;
|
---|
| 157 | case ERROR_INVALID_TARGET_HANDLE: errno = EBADF; break;
|
---|
| 158 | case ERROR_WAIT_NO_CHILDREN: errno = ECHILD; break;
|
---|
| 159 | case ERROR_CHILD_NOT_COMPLETE: errno = ECHILD; break;
|
---|
| 160 | case ERROR_DIRECT_ACCESS_HANDLE: errno = EBADF; break;
|
---|
| 161 | case ERROR_NEGATIVE_SEEK: errno = EINVAL; break;
|
---|
| 162 | case ERROR_SEEK_ON_DEVICE: errno = EACCES; break;
|
---|
| 163 | case ERROR_DIR_NOT_EMPTY: errno = ENOTEMPTY; break;
|
---|
| 164 | case ERROR_NOT_LOCKED: errno = EACCES; break;
|
---|
| 165 | case ERROR_BAD_PATHNAME: errno = ENOENT; break;
|
---|
| 166 | case ERROR_MAX_THRDS_REACHED: errno = EAGAIN; break;
|
---|
| 167 | case ERROR_LOCK_FAILED: errno = EACCES; break;
|
---|
| 168 | case ERROR_ALREADY_EXISTS: errno = EEXIST; break;
|
---|
| 169 | case ERROR_FILENAME_EXCED_RANGE: errno = ENOENT; break;
|
---|
| 170 | case ERROR_NESTING_NOT_ALLOWED: errno = EAGAIN; break;
|
---|
[2476] | 171 | #ifdef EMLINK
|
---|
| 172 | case ERROR_TOO_MANY_LINKS: errno = EMLINK; break;
|
---|
| 173 | #endif
|
---|
[1710] | 174 | }
|
---|
| 175 |
|
---|
| 176 | return -1;
|
---|
| 177 | }
|
---|
| 178 |
|
---|
[370] | 179 | char *dirname(char *path)
|
---|
[775] | 180 | {
|
---|
[370] | 181 | /** @todo later */
|
---|
| 182 | return path;
|
---|
| 183 | }
|
---|
| 184 |
|
---|
| 185 |
|
---|
[1710] | 186 | int lchmod(const char *pszPath, mode_t mode)
|
---|
| 187 | {
|
---|
| 188 | int rc = 0;
|
---|
| 189 | int fMustBeDir;
|
---|
| 190 | char *pszPathFree = msc_fix_path(&pszPath, &fMustBeDir);
|
---|
| 191 |
|
---|
| 192 | /*
|
---|
| 193 | * Get the current attributes
|
---|
| 194 | */
|
---|
| 195 | DWORD fAttr = GetFileAttributes(pszPath);
|
---|
| 196 | if (fAttr == INVALID_FILE_ATTRIBUTES)
|
---|
[2702] | 197 | rc = birdSetErrno(GetLastError());
|
---|
[1710] | 198 | else if (fMustBeDir & !(fAttr & FILE_ATTRIBUTE_DIRECTORY))
|
---|
| 199 | {
|
---|
| 200 | errno = ENOTDIR;
|
---|
| 201 | rc = -1;
|
---|
| 202 | }
|
---|
| 203 | else
|
---|
| 204 | {
|
---|
| 205 | /*
|
---|
| 206 | * Modify the attributes and try set them.
|
---|
| 207 | */
|
---|
| 208 | if (mode & _S_IWRITE)
|
---|
[3387] | 209 | {
|
---|
[1710] | 210 | fAttr &= ~FILE_ATTRIBUTE_READONLY;
|
---|
[3387] | 211 | if (fAttr == 0)
|
---|
| 212 | fAttr = FILE_ATTRIBUTE_NORMAL;
|
---|
| 213 | }
|
---|
[1710] | 214 | else
|
---|
[3387] | 215 | {
|
---|
| 216 | fAttr &= ~FILE_ATTRIBUTE_NORMAL;
|
---|
[1710] | 217 | fAttr |= FILE_ATTRIBUTE_READONLY;
|
---|
[3387] | 218 | }
|
---|
[1710] | 219 | if (!SetFileAttributes(pszPath, fAttr))
|
---|
[2702] | 220 | rc = birdSetErrno(GetLastError());
|
---|
[1710] | 221 | }
|
---|
| 222 |
|
---|
| 223 | if (pszPathFree)
|
---|
| 224 | {
|
---|
| 225 | int saved_errno = errno;
|
---|
| 226 | free(pszPathFree);
|
---|
| 227 | errno = saved_errno;
|
---|
| 228 | }
|
---|
| 229 | return rc;
|
---|
| 230 | }
|
---|
| 231 |
|
---|
| 232 |
|
---|
| 233 | int msc_chmod(const char *pszPath, mode_t mode)
|
---|
| 234 | {
|
---|
| 235 | int rc = 0;
|
---|
| 236 | int fMustBeDir;
|
---|
| 237 | char *pszPathFree = msc_fix_path(&pszPath, &fMustBeDir);
|
---|
| 238 |
|
---|
| 239 | /*
|
---|
| 240 | * Get the current attributes.
|
---|
| 241 | */
|
---|
| 242 | DWORD fAttr = GetFileAttributes(pszPath);
|
---|
| 243 | if (fAttr == INVALID_FILE_ATTRIBUTES)
|
---|
[2702] | 244 | rc = birdSetErrno(GetLastError());
|
---|
[1710] | 245 | else if (fMustBeDir & !(fAttr & FILE_ATTRIBUTE_DIRECTORY))
|
---|
| 246 | {
|
---|
| 247 | errno = ENOTDIR;
|
---|
| 248 | rc = -1;
|
---|
| 249 | }
|
---|
| 250 | else if (fAttr & FILE_ATTRIBUTE_REPARSE_POINT)
|
---|
| 251 | {
|
---|
| 252 | errno = ENOSYS; /** @todo resolve symbolic link / rewrite to NtSetInformationFile. */
|
---|
| 253 | rc = -1;
|
---|
| 254 | }
|
---|
| 255 | else
|
---|
| 256 | {
|
---|
| 257 | /*
|
---|
| 258 | * Modify the attributes and try set them.
|
---|
| 259 | */
|
---|
| 260 | if (mode & _S_IWRITE)
|
---|
[3387] | 261 | {
|
---|
[1710] | 262 | fAttr &= ~FILE_ATTRIBUTE_READONLY;
|
---|
[3387] | 263 | if (fAttr == 0)
|
---|
| 264 | fAttr = FILE_ATTRIBUTE_NORMAL;
|
---|
| 265 | }
|
---|
[1710] | 266 | else
|
---|
[3387] | 267 | {
|
---|
| 268 | fAttr &= ~FILE_ATTRIBUTE_NORMAL;
|
---|
[1710] | 269 | fAttr |= FILE_ATTRIBUTE_READONLY;
|
---|
[3387] | 270 | }
|
---|
[1710] | 271 | if (!SetFileAttributes(pszPath, fAttr))
|
---|
[2702] | 272 | rc = birdSetErrno(GetLastError());
|
---|
[1710] | 273 | }
|
---|
| 274 |
|
---|
| 275 | if (pszPathFree)
|
---|
| 276 | {
|
---|
| 277 | int saved_errno = errno;
|
---|
| 278 | free(pszPathFree);
|
---|
| 279 | errno = saved_errno;
|
---|
| 280 | }
|
---|
| 281 | return rc;
|
---|
| 282 | }
|
---|
| 283 |
|
---|
| 284 |
|
---|
[2484] | 285 | typedef BOOL (WINAPI *PFNCREATEHARDLINKA)(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
|
---|
[370] | 286 | int link(const char *pszDst, const char *pszLink)
|
---|
| 287 | {
|
---|
[2484] | 288 | static PFNCREATEHARDLINKA s_pfnCreateHardLinkA = NULL;
|
---|
| 289 | static int s_fTried = FALSE;
|
---|
| 290 |
|
---|
| 291 | /* The API was introduced in Windows 2000, so resolve it dynamically. */
|
---|
| 292 | if (!s_pfnCreateHardLinkA)
|
---|
| 293 | {
|
---|
| 294 | if (!s_fTried)
|
---|
| 295 | {
|
---|
| 296 | HMODULE hmod = LoadLibrary("KERNEL32.DLL");
|
---|
| 297 | if (hmod)
|
---|
| 298 | *(FARPROC *)&s_pfnCreateHardLinkA = GetProcAddress(hmod, "CreateHardLinkA");
|
---|
| 299 | s_fTried = TRUE;
|
---|
| 300 | }
|
---|
| 301 | if (!s_pfnCreateHardLinkA)
|
---|
| 302 | {
|
---|
| 303 | errno = ENOSYS;
|
---|
| 304 | return -1;
|
---|
| 305 | }
|
---|
| 306 | }
|
---|
| 307 |
|
---|
| 308 | if (s_pfnCreateHardLinkA(pszLink, pszDst, NULL))
|
---|
[2476] | 309 | return 0;
|
---|
[2702] | 310 | return birdSetErrno(GetLastError());
|
---|
[370] | 311 | }
|
---|
| 312 |
|
---|
| 313 |
|
---|
| 314 | int mkdir_msc(const char *path, mode_t mode)
|
---|
| 315 | {
|
---|
[936] | 316 | int rc = (mkdir)(path);
|
---|
[370] | 317 | if (rc)
|
---|
| 318 | {
|
---|
[1108] | 319 | size_t len = strlen(path);
|
---|
[370] | 320 | if (len > 0 && (path[len - 1] == '/' || path[len - 1] == '\\'))
|
---|
| 321 | {
|
---|
| 322 | char *str = strdup(path);
|
---|
| 323 | while (len > 0 && (str[len - 1] == '/' || str[len - 1] == '\\'))
|
---|
| 324 | str[--len] = '\0';
|
---|
[936] | 325 | rc = (mkdir)(str);
|
---|
[370] | 326 | free(str);
|
---|
| 327 | }
|
---|
| 328 | }
|
---|
| 329 | return rc;
|
---|
| 330 | }
|
---|
| 331 |
|
---|
[936] | 332 | int rmdir_msc(const char *path)
|
---|
| 333 | {
|
---|
| 334 | int rc = (rmdir)(path);
|
---|
| 335 | if (rc)
|
---|
| 336 | {
|
---|
[1108] | 337 | size_t len = strlen(path);
|
---|
[936] | 338 | if (len > 0 && (path[len - 1] == '/' || path[len - 1] == '\\'))
|
---|
| 339 | {
|
---|
| 340 | char *str = strdup(path);
|
---|
| 341 | while (len > 0 && (str[len - 1] == '/' || str[len - 1] == '\\'))
|
---|
| 342 | str[--len] = '\0';
|
---|
| 343 | rc = (rmdir)(str);
|
---|
| 344 | free(str);
|
---|
| 345 | }
|
---|
| 346 | }
|
---|
| 347 | return rc;
|
---|
| 348 | }
|
---|
[370] | 349 |
|
---|
[936] | 350 |
|
---|
[370] | 351 | static int doname(char *pszX, char *pszEnd)
|
---|
| 352 | {
|
---|
| 353 | static char s_szChars[] = "Xabcdefghijklmnopqrstuwvxyz1234567890";
|
---|
| 354 | int rc = 0;
|
---|
| 355 | do
|
---|
| 356 | {
|
---|
| 357 | char ch;
|
---|
| 358 |
|
---|
| 359 | pszEnd++;
|
---|
| 360 | ch = *(strchr(s_szChars, *pszEnd) + 1);
|
---|
| 361 | if (ch)
|
---|
| 362 | {
|
---|
| 363 | *pszEnd = ch;
|
---|
| 364 | return 0;
|
---|
| 365 | }
|
---|
| 366 | *pszEnd = 'a';
|
---|
| 367 | } while (pszEnd != pszX);
|
---|
| 368 | return 1;
|
---|
| 369 | }
|
---|
| 370 |
|
---|
| 371 |
|
---|
| 372 | int mkstemp(char *temp)
|
---|
| 373 | {
|
---|
| 374 | char *pszX = strchr(temp, 'X');
|
---|
| 375 | char *pszEnd = strchr(pszX, '\0');
|
---|
| 376 | int cTries = 1000;
|
---|
| 377 | while (--cTries > 0)
|
---|
| 378 | {
|
---|
| 379 | int fd;
|
---|
| 380 | if (doname(pszX, pszEnd))
|
---|
| 381 | return -1;
|
---|
[3219] | 382 | fd = open(temp, _O_EXCL | _O_CREAT | _O_BINARY | _O_RDWR | KMK_OPEN_NO_INHERIT, 0777);
|
---|
[370] | 383 | if (fd >= 0)
|
---|
| 384 | return fd;
|
---|
| 385 | }
|
---|
| 386 | return -1;
|
---|
| 387 | }
|
---|
| 388 |
|
---|
| 389 |
|
---|
[1108] | 390 | /** Unix to DOS. */
|
---|
| 391 | static char *fix_slashes(char *psz)
|
---|
| 392 | {
|
---|
| 393 | char *pszRet = psz;
|
---|
| 394 | for (; *psz; psz++)
|
---|
| 395 | if (*psz == '/')
|
---|
| 396 | *psz = '\\';
|
---|
| 397 | return pszRet;
|
---|
| 398 | }
|
---|
| 399 |
|
---|
| 400 |
|
---|
| 401 | /** Calcs the SYMBOLIC_LINK_FLAG_DIRECTORY flag for CreatesymbolcLink. */
|
---|
| 402 | static DWORD is_directory(const char *pszPath, const char *pszRelativeTo)
|
---|
| 403 | {
|
---|
| 404 | size_t cchPath = strlen(pszPath);
|
---|
| 405 | struct stat st;
|
---|
| 406 | if (cchPath > 0 && pszPath[cchPath - 1] == '\\' || pszPath[cchPath - 1] == '/')
|
---|
| 407 | return 1; /* SYMBOLIC_LINK_FLAG_DIRECTORY */
|
---|
| 408 |
|
---|
| 409 | if (stat(pszPath, &st))
|
---|
| 410 | {
|
---|
| 411 | size_t cchRelativeTo = strlen(pszRelativeTo);
|
---|
| 412 | char *psz = malloc(cchPath + cchRelativeTo + 4);
|
---|
| 413 | memcpy(psz, pszRelativeTo, cchRelativeTo);
|
---|
| 414 | memcpy(psz + cchRelativeTo, "\\", 1);
|
---|
| 415 | memcpy(psz + cchRelativeTo + 1, pszPath, cchPath + 1);
|
---|
| 416 | if (stat(pszPath, &st))
|
---|
| 417 | st.st_mode = _S_IFREG;
|
---|
| 418 | free(psz);
|
---|
| 419 | }
|
---|
| 420 |
|
---|
| 421 | return (st.st_mode & _S_IFMT) == _S_IFDIR ? 1 : 0;
|
---|
| 422 | }
|
---|
| 423 |
|
---|
| 424 |
|
---|
[370] | 425 | int symlink(const char *pszDst, const char *pszLink)
|
---|
| 426 | {
|
---|
[1717] | 427 | static BOOLEAN (WINAPI *s_pfnCreateSymbolicLinkA)(LPCSTR, LPCSTR, DWORD) = 0;
|
---|
[1108] | 428 | static BOOL s_fTried = FALSE;
|
---|
| 429 |
|
---|
| 430 | if (!s_fTried)
|
---|
| 431 | {
|
---|
| 432 | HMODULE hmod = LoadLibrary("KERNEL32.DLL");
|
---|
| 433 | if (hmod)
|
---|
| 434 | *(FARPROC *)&s_pfnCreateSymbolicLinkA = GetProcAddress(hmod, "CreateSymbolicLinkA");
|
---|
| 435 | s_fTried = TRUE;
|
---|
| 436 | }
|
---|
| 437 |
|
---|
| 438 | if (s_pfnCreateSymbolicLinkA)
|
---|
| 439 | {
|
---|
| 440 | char *pszDstCopy = fix_slashes(strdup(pszDst));
|
---|
| 441 | char *pszLinkCopy = fix_slashes(strdup(pszLink));
|
---|
[1717] | 442 | BOOLEAN fRc = s_pfnCreateSymbolicLinkA(pszLinkCopy, pszDstCopy,
|
---|
| 443 | is_directory(pszDstCopy, pszLinkCopy));
|
---|
[1108] | 444 | DWORD err = GetLastError();
|
---|
| 445 | free(pszDstCopy);
|
---|
| 446 | free(pszLinkCopy);
|
---|
| 447 | if (fRc)
|
---|
| 448 | return 0;
|
---|
| 449 | switch (err)
|
---|
| 450 | {
|
---|
| 451 | case ERROR_NOT_SUPPORTED: errno = ENOSYS; break;
|
---|
| 452 | case ERROR_ALREADY_EXISTS:
|
---|
| 453 | case ERROR_FILE_EXISTS: errno = EEXIST; break;
|
---|
| 454 | case ERROR_DIRECTORY: errno = ENOTDIR; break;
|
---|
| 455 | case ERROR_ACCESS_DENIED:
|
---|
| 456 | case ERROR_PRIVILEGE_NOT_HELD: errno = EPERM; break;
|
---|
| 457 | default: errno = EINVAL; break;
|
---|
| 458 | }
|
---|
| 459 | return -1;
|
---|
| 460 | }
|
---|
| 461 |
|
---|
[3192] | 462 | fprintf(stderr, "warning: symlink() is available on this version of Windows!\n");
|
---|
[370] | 463 | errno = ENOSYS;
|
---|
| 464 | return -1;
|
---|
| 465 | }
|
---|
| 466 |
|
---|
| 467 |
|
---|
| 468 | #if _MSC_VER < 1400
|
---|
| 469 | int snprintf(char *buf, size_t size, const char *fmt, ...)
|
---|
| 470 | {
|
---|
| 471 | int cch;
|
---|
| 472 | va_list args;
|
---|
| 473 | va_start(args, fmt);
|
---|
| 474 | cch = vsprintf(buf, fmt, args);
|
---|
| 475 | va_end(args);
|
---|
| 476 | return cch;
|
---|
| 477 | }
|
---|
[775] | 478 | #endif
|
---|
[370] | 479 |
|
---|
| 480 |
|
---|
[2759] | 481 | /* We override the libc write function (in our modules only, unfortunately) so
|
---|
| 482 | we can kludge our way around a ENOSPC problem observed on build servers
|
---|
| 483 | capturing STDOUT and STDERR via pipes. Apparently this may happen when the
|
---|
| 484 | pipe buffer is full, even with the mscfake_init hack in place.
|
---|
| 485 |
|
---|
| 486 | XXX: Probably need to hook into fwrite as well. */
|
---|
| 487 | ssize_t msc_write(int fd, const void *pvSrc, size_t cbSrc)
|
---|
[370] | 488 | {
|
---|
[3117] | 489 | #define MSC_WRITE_MAX_CHUNK (UINT_MAX / 32)
|
---|
[2759] | 490 | ssize_t cbRet;
|
---|
[3117] | 491 | if (cbSrc <= MSC_WRITE_MAX_CHUNK)
|
---|
[370] | 492 | {
|
---|
[3117] | 493 | /* Console output optimization: */
|
---|
[3188] | 494 | if (cbSrc > 0 && is_console(fd))
|
---|
[3117] | 495 | return maybe_con_write(fd, pvSrc, cbSrc);
|
---|
| 496 |
|
---|
[2759] | 497 | #ifndef MSC_WRITE_TEST
|
---|
| 498 | cbRet = _write(fd, pvSrc, (unsigned int)cbSrc);
|
---|
| 499 | #else
|
---|
| 500 | cbRet = -1; errno = ENOSPC;
|
---|
| 501 | #endif
|
---|
| 502 | if (cbRet < 0)
|
---|
[2756] | 503 | {
|
---|
| 504 | /* ENOSPC on pipe kludge. */
|
---|
[3117] | 505 | unsigned int cbLimit;
|
---|
[2759] | 506 | int cSinceLastSuccess;
|
---|
[2756] | 507 |
|
---|
[2759] | 508 | if (cbSrc == 0)
|
---|
| 509 | return 0;
|
---|
[2756] | 510 | if (errno != ENOSPC)
|
---|
| 511 | return -1;
|
---|
[2759] | 512 | #ifndef MSC_WRITE_TEST
|
---|
[2756] | 513 | if (!isPipeFd(fd))
|
---|
| 514 | {
|
---|
| 515 | errno = ENOSPC;
|
---|
| 516 | return -1;
|
---|
| 517 | }
|
---|
[2759] | 518 | #endif
|
---|
[2756] | 519 |
|
---|
| 520 | /* Likely a full pipe buffer, try write smaller amounts and do some
|
---|
| 521 | sleeping inbetween each unsuccessful one. */
|
---|
[3117] | 522 | cbLimit = (unsigned)(cbSrc / 4);
|
---|
[2756] | 523 | if (cbLimit < 4)
|
---|
| 524 | cbLimit = 4;
|
---|
| 525 | else if (cbLimit > 512)
|
---|
| 526 | cbLimit = 512;
|
---|
| 527 | cSinceLastSuccess = 0;
|
---|
[2759] | 528 | cbRet = 0;
|
---|
| 529 | #ifdef MSC_WRITE_TEST
|
---|
| 530 | cbLimit = 4;
|
---|
| 531 | #endif
|
---|
[2756] | 532 |
|
---|
[3117] | 533 | while ((ssize_t)cbSrc > 0)
|
---|
[2756] | 534 | {
|
---|
[3117] | 535 | unsigned int cbAttempt = cbSrc > cbLimit ? cbLimit : (unsigned int)cbSrc;
|
---|
[2759] | 536 | ssize_t cbActual = _write(fd, pvSrc, cbAttempt);
|
---|
| 537 | if (cbActual > 0)
|
---|
[2756] | 538 | {
|
---|
[3117] | 539 | /* For some reason, it seems like we cannot trust _write to return
|
---|
| 540 | a number that's less or equal to the number of bytes we passed
|
---|
| 541 | in to the call. (Also reason for signed check in loop.) */
|
---|
| 542 | if (cbActual > cbAttempt)
|
---|
| 543 | cbActual = cbAttempt;
|
---|
| 544 |
|
---|
[2759] | 545 | pvSrc = (char *)pvSrc + cbActual;
|
---|
| 546 | cbSrc -= cbActual;
|
---|
| 547 | cbRet += cbActual;
|
---|
| 548 | #ifndef MSC_WRITE_TEST
|
---|
[2756] | 549 | if (cbLimit < 32)
|
---|
| 550 | cbLimit = 32;
|
---|
[2759] | 551 | #endif
|
---|
[2756] | 552 | cSinceLastSuccess = 0;
|
---|
| 553 | }
|
---|
| 554 | else if (errno != ENOSPC)
|
---|
| 555 | return -1;
|
---|
| 556 | else
|
---|
| 557 | {
|
---|
| 558 | /* Delay for about 30 seconds, then just give up. */
|
---|
| 559 | cSinceLastSuccess++;
|
---|
| 560 | if (cSinceLastSuccess > 1860)
|
---|
| 561 | return -1;
|
---|
| 562 | if (cSinceLastSuccess <= 2)
|
---|
| 563 | Sleep(0);
|
---|
| 564 | else if (cSinceLastSuccess <= 66)
|
---|
| 565 | {
|
---|
| 566 | if (cbLimit >= 8)
|
---|
| 567 | cbLimit /= 2; /* Just in case the pipe buffer is very very small. */
|
---|
| 568 | Sleep(1);
|
---|
| 569 | }
|
---|
| 570 | else
|
---|
| 571 | Sleep(16);
|
---|
| 572 | }
|
---|
| 573 | }
|
---|
| 574 | }
|
---|
[2759] | 575 | }
|
---|
| 576 | else
|
---|
| 577 | {
|
---|
| 578 | /*
|
---|
| 579 | * Type limit exceeded. Split the job up.
|
---|
| 580 | */
|
---|
| 581 | cbRet = 0;
|
---|
| 582 | while (cbSrc > 0)
|
---|
| 583 | {
|
---|
[3117] | 584 | size_t cbToWrite = cbSrc > MSC_WRITE_MAX_CHUNK ? MSC_WRITE_MAX_CHUNK : cbSrc;
|
---|
[2759] | 585 | ssize_t cbWritten = msc_write(fd, pvSrc, cbToWrite);
|
---|
| 586 | if (cbWritten > 0)
|
---|
| 587 | {
|
---|
| 588 | pvSrc = (char *)pvSrc + (size_t)cbWritten;
|
---|
| 589 | cbSrc -= (size_t)cbWritten;
|
---|
| 590 | cbRet += (size_t)cbWritten;
|
---|
| 591 | }
|
---|
| 592 | else if (cbWritten == 0 || cbRet > 0)
|
---|
| 593 | break;
|
---|
| 594 | else
|
---|
| 595 | return -1;
|
---|
| 596 | }
|
---|
| 597 | }
|
---|
| 598 | return cbRet;
|
---|
| 599 | }
|
---|
| 600 |
|
---|
| 601 | ssize_t writev(int fd, const struct iovec *vector, int count)
|
---|
| 602 | {
|
---|
[3188] | 603 | ssize_t size = 0;
|
---|
| 604 | if (count > 0)
|
---|
[2759] | 605 | {
|
---|
[3188] | 606 | int i;
|
---|
| 607 |
|
---|
| 608 | /* To get consistent console output, we must try combine the segments
|
---|
| 609 | when outputing to the console. */
|
---|
| 610 | if (count > 1 && is_console(fd))
|
---|
| 611 | {
|
---|
| 612 | char *pbTmp;
|
---|
| 613 | ssize_t cbTotal;
|
---|
| 614 | if (count == 1)
|
---|
| 615 | return maybe_con_write(fd, vector[0].iov_base, (int)vector[0].iov_len);
|
---|
| 616 |
|
---|
| 617 | cbTotal = 0;
|
---|
| 618 | for (i = 0; i < count; i++)
|
---|
| 619 | cbTotal += vector[i].iov_len;
|
---|
| 620 | pbTmp = malloc(cbTotal);
|
---|
| 621 | if (pbTmp)
|
---|
| 622 | {
|
---|
| 623 | char *pbCur = pbTmp;
|
---|
| 624 | for (i = 0; i < count; i++)
|
---|
| 625 | {
|
---|
| 626 | memcpy(pbCur, vector[i].iov_base, vector[i].iov_len);
|
---|
| 627 | pbCur += vector[i].iov_len;
|
---|
| 628 | }
|
---|
| 629 | size = maybe_con_write(fd, pbTmp, cbTotal);
|
---|
| 630 | free(pbTmp);
|
---|
| 631 | return size;
|
---|
| 632 | }
|
---|
| 633 |
|
---|
| 634 | /* fall back on segment by segment output. */
|
---|
| 635 | }
|
---|
| 636 |
|
---|
| 637 | for (i = 0; i < count; i++)
|
---|
| 638 | {
|
---|
| 639 | int cb = msc_write(fd, vector[i].iov_base, (int)vector[i].iov_len);
|
---|
| 640 | if (cb < 0)
|
---|
| 641 | return cb;
|
---|
| 642 | size += cb;
|
---|
| 643 | }
|
---|
[370] | 644 | }
|
---|
| 645 | return size;
|
---|
| 646 | }
|
---|
| 647 |
|
---|
[775] | 648 |
|
---|
| 649 | intmax_t strtoimax(const char *nptr, char **endptr, int base)
|
---|
| 650 | {
|
---|
[2645] | 651 | if (*nptr != '-')
|
---|
| 652 | return _strtoui64(nptr, endptr, base);
|
---|
| 653 | return -(intmax_t)_strtoui64(nptr + 1, endptr, base);
|
---|
[775] | 654 | }
|
---|
| 655 |
|
---|
| 656 |
|
---|
| 657 | uintmax_t strtoumax(const char *nptr, char **endptr, int base)
|
---|
| 658 | {
|
---|
[2645] | 659 | return _strtoui64(nptr, endptr, base);
|
---|
[775] | 660 | }
|
---|
| 661 |
|
---|
| 662 |
|
---|
| 663 | int asprintf(char **strp, const char *fmt, ...)
|
---|
| 664 | {
|
---|
| 665 | int rc;
|
---|
| 666 | va_list va;
|
---|
| 667 | va_start(va, fmt);
|
---|
| 668 | rc = vasprintf(strp, fmt, va);
|
---|
| 669 | va_end(va);
|
---|
| 670 | return rc;
|
---|
| 671 | }
|
---|
| 672 |
|
---|
| 673 |
|
---|
| 674 | int vasprintf(char **strp, const char *fmt, va_list va)
|
---|
| 675 | {
|
---|
| 676 | int rc;
|
---|
| 677 | char *psz;
|
---|
| 678 | size_t cb = 1024;
|
---|
| 679 |
|
---|
| 680 | *strp = NULL;
|
---|
| 681 | for (;;)
|
---|
| 682 | {
|
---|
| 683 | va_list va2;
|
---|
| 684 |
|
---|
| 685 | psz = malloc(cb);
|
---|
| 686 | if (!psz)
|
---|
| 687 | return -1;
|
---|
| 688 |
|
---|
| 689 | #ifdef va_copy
|
---|
| 690 | va_copy(va2, va);
|
---|
[2901] | 691 | rc = vsnprintf(psz, cb, fmt, va2);
|
---|
[775] | 692 | va_end(vaCopy);
|
---|
| 693 | #else
|
---|
| 694 | va2 = va;
|
---|
[2901] | 695 | rc = vsnprintf(psz, cb, fmt, va2);
|
---|
[775] | 696 | #endif
|
---|
| 697 | if (rc < 0 || (size_t)rc < cb)
|
---|
| 698 | break;
|
---|
| 699 | cb *= 2;
|
---|
| 700 | free(psz);
|
---|
| 701 | }
|
---|
| 702 |
|
---|
| 703 | *strp = psz;
|
---|
| 704 | return rc;
|
---|
| 705 | }
|
---|
| 706 |
|
---|
[1321] | 707 |
|
---|
[3140] | 708 | int utimes(const char *pszPath, const struct msc_timeval *paTimes)
|
---|
[3060] | 709 | {
|
---|
[3094] | 710 | if (paTimes)
|
---|
| 711 | {
|
---|
| 712 | BirdTimeVal_T aTimes[2];
|
---|
| 713 | aTimes[0].tv_sec = paTimes[0].tv_sec;
|
---|
| 714 | aTimes[0].tv_usec = paTimes[0].tv_usec;
|
---|
| 715 | aTimes[1].tv_sec = paTimes[1].tv_sec;
|
---|
| 716 | aTimes[1].tv_usec = paTimes[1].tv_usec;
|
---|
| 717 | return birdUtimes(pszPath, aTimes);
|
---|
| 718 | }
|
---|
| 719 | return birdUtimes(pszPath, NULL);
|
---|
[3060] | 720 | }
|
---|
| 721 |
|
---|
| 722 |
|
---|
[3140] | 723 | int lutimes(const char *pszPath, const struct msc_timeval *paTimes)
|
---|
[3060] | 724 | {
|
---|
[3094] | 725 | if (paTimes)
|
---|
| 726 | {
|
---|
| 727 | BirdTimeVal_T aTimes[2];
|
---|
| 728 | aTimes[0].tv_sec = paTimes[0].tv_sec;
|
---|
| 729 | aTimes[0].tv_usec = paTimes[0].tv_usec;
|
---|
| 730 | aTimes[1].tv_sec = paTimes[1].tv_sec;
|
---|
| 731 | aTimes[1].tv_usec = paTimes[1].tv_usec;
|
---|
| 732 | return birdUtimes(pszPath, aTimes);
|
---|
| 733 | }
|
---|
| 734 | return birdUtimes(pszPath, NULL);
|
---|
[3060] | 735 | }
|
---|
| 736 |
|
---|
| 737 |
|
---|
[3140] | 738 | int gettimeofday(struct msc_timeval *pNow, void *pvIgnored)
|
---|
[3060] | 739 | {
|
---|
| 740 | struct __timeb64 Now;
|
---|
| 741 | int rc = _ftime64_s(&Now);
|
---|
| 742 | if (rc == 0)
|
---|
| 743 | {
|
---|
| 744 | pNow->tv_sec = Now.time;
|
---|
| 745 | pNow->tv_usec = Now.millitm * 1000;
|
---|
| 746 | return 0;
|
---|
| 747 | }
|
---|
| 748 | errno = rc;
|
---|
| 749 | return -1;
|
---|
| 750 | }
|
---|
| 751 |
|
---|
| 752 |
|
---|
| 753 | struct tm *localtime_r(const __time64_t *pNow, struct tm *pResult)
|
---|
| 754 | {
|
---|
| 755 | int rc = _localtime64_s(pResult, pNow);
|
---|
| 756 | if (rc == 0)
|
---|
| 757 | return pResult;
|
---|
| 758 | errno = rc;
|
---|
| 759 | return NULL;
|
---|
| 760 | }
|
---|
| 761 |
|
---|
| 762 |
|
---|
| 763 | __time64_t timegm(struct tm *pNow)
|
---|
| 764 | {
|
---|
| 765 | return _mkgmtime64(pNow);
|
---|
| 766 | }
|
---|
| 767 |
|
---|
| 768 |
|
---|
[2733] | 769 | /**
|
---|
[2756] | 770 | * Checks if the given file descriptor is a pipe or not.
|
---|
[2733] | 771 | *
|
---|
[2756] | 772 | * @returns TRUE if pipe, FALSE if not.
|
---|
[2733] | 773 | * @param fd The libc file descriptor number.
|
---|
| 774 | */
|
---|
[2756] | 775 | static BOOL isPipeFd(int fd)
|
---|
[2733] | 776 | {
|
---|
| 777 | /* Is pipe? */
|
---|
| 778 | HANDLE hFile = (HANDLE)_get_osfhandle(fd);
|
---|
| 779 | if (hFile != INVALID_HANDLE_VALUE)
|
---|
| 780 | {
|
---|
| 781 | DWORD fType = GetFileType(hFile);
|
---|
| 782 | fType &= ~FILE_TYPE_REMOTE;
|
---|
| 783 | if (fType == FILE_TYPE_PIPE)
|
---|
[2756] | 784 | return TRUE;
|
---|
| 785 | }
|
---|
| 786 | return FALSE;
|
---|
| 787 | }
|
---|
| 788 |
|
---|
| 789 |
|
---|
| 790 | /**
|
---|
| 791 | * This is a kludge to make pipe handles blocking.
|
---|
| 792 | *
|
---|
| 793 | * @returns TRUE if it's now blocking, FALSE if not a pipe or we failed to fix
|
---|
| 794 | * the blocking mode.
|
---|
| 795 | * @param fd The libc file descriptor number.
|
---|
| 796 | */
|
---|
| 797 | static BOOL makePipeBlocking(int fd)
|
---|
| 798 | {
|
---|
| 799 | if (isPipeFd(fd))
|
---|
| 800 | {
|
---|
| 801 | /* Try fix it. */
|
---|
| 802 | HANDLE hFile = (HANDLE)_get_osfhandle(fd);
|
---|
| 803 | DWORD fState = 0;
|
---|
| 804 | if (GetNamedPipeHandleState(hFile, &fState, NULL, NULL, NULL, NULL, 0))
|
---|
[2733] | 805 | {
|
---|
[2756] | 806 | fState &= ~PIPE_NOWAIT;
|
---|
| 807 | fState |= PIPE_WAIT;
|
---|
| 808 | if (SetNamedPipeHandleState(hFile, &fState, NULL, NULL))
|
---|
| 809 | return TRUE;
|
---|
[2733] | 810 | }
|
---|
| 811 | }
|
---|
| 812 | return FALSE;
|
---|
| 813 | }
|
---|
| 814 |
|
---|
| 815 |
|
---|
| 816 | /**
|
---|
| 817 | * Initializes the msc fake stuff.
|
---|
| 818 | * @returns 0 on success (non-zero would indicate failure, see rterr.h).
|
---|
| 819 | */
|
---|
| 820 | int mscfake_init(void)
|
---|
| 821 | {
|
---|
| 822 | /*
|
---|
| 823 | * Kludge against _write returning ENOSPC on non-blocking pipes.
|
---|
| 824 | */
|
---|
| 825 | makePipeBlocking(STDOUT_FILENO);
|
---|
| 826 | makePipeBlocking(STDERR_FILENO);
|
---|
| 827 |
|
---|
| 828 | return 0;
|
---|
| 829 | }
|
---|
| 830 |
|
---|
| 831 | /*
|
---|
| 832 | * Do this before main is called.
|
---|
| 833 | */
|
---|
| 834 | #pragma section(".CRT$XIA", read)
|
---|
| 835 | #pragma section(".CRT$XIU", read)
|
---|
| 836 | #pragma section(".CRT$XIZ", read)
|
---|
| 837 | typedef int (__cdecl *PFNCRTINIT)(void);
|
---|
| 838 | static __declspec(allocate(".CRT$XIU")) PFNCRTINIT g_MscFakeInitVectorEntry = mscfake_init;
|
---|
| 839 |
|
---|