fcntl.c

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/coreutils/src/gnulib/lib/fcntl.c

Line

Source

Count

/* Provide file descriptor control.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>. */

/* Written by Eric Blake <ebb9@byu.net>. */

#include <config.h>

/* Specification. */

#include <fcntl.h>

#include <errno.h>

#include <limits.h>

#include <stdarg.h>

#include <unistd.h>

#if !HAVE_FCNTL

# define rpl_fcntl fcntl

#endif

#undef fcntl

#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__

/* Get declarations of the native Windows API functions. */

# define WIN32_LEAN_AND_MEAN

# include <windows.h>

/* Get _get_osfhandle. */

# if GNULIB_MSVC_NOTHROW

# include "msvc-nothrow.h"

# else

# include <io.h>

# endif

/* Upper bound on getdtablesize(). See lib/getdtablesize.c. */

# define OPEN_MAX_MAX 0x10000

/* Duplicate OLDFD into the first available slot of at least NEWFD,

which must be positive, with FLAGS determining whether the duplicate

will be inheritable. */

static int

dupfd (int oldfd, int newfd, int flags)

{

/* Mingw has no way to create an arbitrary fd. Iterate until all

file descriptors less than newfd are filled up. */

HANDLE curr_process = GetCurrentProcess ();

HANDLE old_handle = (HANDLE) _get_osfhandle (oldfd);

unsigned char fds_to_close[OPEN_MAX_MAX / CHAR_BIT];

unsigned int fds_to_close_bound = 0;

int result;

BOOL inherit = flags & O_CLOEXEC ? FALSE : TRUE;

int mode;

if (newfd < 0 || getdtablesize () <= newfd)

{

errno = EINVAL;

return -1;

}

if (old_handle == INVALID_HANDLE_VALUE

|| (mode = setmode (oldfd, O_BINARY)) == -1)

{

/* oldfd is not open, or is an unassigned standard file

descriptor. */

errno = EBADF;

return -1;

}

setmode (oldfd, mode);

flags |= mode;

for (;;)

{

HANDLE new_handle;

int duplicated_fd;

unsigned int index;

if (!DuplicateHandle (curr_process, /* SourceProcessHandle */

old_handle, /* SourceHandle */

curr_process, /* TargetProcessHandle */

(PHANDLE) &new_handle, /* TargetHandle */

(DWORD) 0, /* DesiredAccess */

inherit, /* InheritHandle */

DUPLICATE_SAME_ACCESS)) /* Options */

{

switch (GetLastError ())

{

case ERROR_TOO_MANY_OPEN_FILES:

errno = EMFILE;

100

break;

101

case ERROR_INVALID_HANDLE:

102

case ERROR_INVALID_TARGET_HANDLE:

103

case ERROR_DIRECT_ACCESS_HANDLE:

104

errno = EBADF;

105

break;

106

case ERROR_INVALID_PARAMETER:

107

case ERROR_INVALID_FUNCTION:

108

case ERROR_INVALID_ACCESS:

errno = EINVAL;

break;

default:

errno = EACCES;

break;

}

result = -1;

break;

}

duplicated_fd = _open_osfhandle ((intptr_t) new_handle, flags);

119

if (duplicated_fd < 0)

120

{

121

CloseHandle (new_handle);

result = -1;

break;

}

if (newfd <= duplicated_fd)

126

{

127

result = duplicated_fd;

break;

}

/* Set the bit duplicated_fd in fds_to_close[]. */

132

index = (unsigned int) duplicated_fd / CHAR_BIT;

133

if (fds_to_close_bound <= index)

134

{

135

if (sizeof fds_to_close <= index)

136

/* Need to increase OPEN_MAX_MAX. */

137

abort ();

138

memset (fds_to_close + fds_to_close_bound, '\0',

139

index + 1 - fds_to_close_bound);

140

fds_to_close_bound = index + 1;

141

}

142

fds_to_close[index] |= 1 << ((unsigned int) duplicated_fd % CHAR_BIT);

143

}

144

145

/* Close the previous fds that turned out to be too small. */

146

{

147

int saved_errno = errno;

148

unsigned int duplicated_fd;

149

150

for (duplicated_fd = 0;

151

duplicated_fd < fds_to_close_bound * CHAR_BIT;

152

duplicated_fd++)

153

if ((fds_to_close[duplicated_fd / CHAR_BIT]

154

>> (duplicated_fd % CHAR_BIT))

155

& 1)

156

close (duplicated_fd);

errno = saved_errno;

}

# if REPLACE_FCHDIR

if (0 <= result)

result = _gl_register_dup (oldfd, result);

# endif

return result;

}

#endif /* W32 */

#ifdef __KLIBC__

# define INCL_DOS

# include <os2.h>

static int

klibc_fcntl (int fd, int action, /* arg */...)

{

va_list arg_ptr;

int arg;

struct stat sbuf;

int result = -1;

va_start (arg_ptr, action);

183

arg = va_arg (arg_ptr, int);

184

result = fcntl (fd, action, arg);

185

/* EPERM for F_DUPFD, ENOTSUP for others */

186

if (result == -1 && (errno == EPERM || errno == ENOTSUP)

187

&& !fstat (fd, &sbuf) && S_ISDIR (sbuf.st_mode))

{

ULONG ulMode;

switch (action)

{

case F_DUPFD:

/* Find available fd */

195

while (fcntl (arg, F_GETFL) != -1 || errno != EBADF)

196

arg++;

197

198

result = dup2 (fd, arg);

199

break;

200

201

/* Using underlying APIs is right ? */

202

case F_GETFD:

203

if (DosQueryFHState (fd, &ulMode))

204

break;

205

206

result = (ulMode & OPEN_FLAGS_NOINHERIT) ? FD_CLOEXEC : 0;

break;

case F_SETFD:

if (arg & ~FD_CLOEXEC)

211

break;

212

213

if (DosQueryFHState (fd, &ulMode))

214

break;

215

216

if (arg & FD_CLOEXEC)

217

ulMode |= OPEN_FLAGS_NOINHERIT;

218

else

219

ulMode &= ~OPEN_FLAGS_NOINHERIT;

220

221

/* Filter supported flags. */

222

ulMode &= (OPEN_FLAGS_WRITE_THROUGH | OPEN_FLAGS_FAIL_ON_ERROR

223

| OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_NOINHERIT);

224

225

if (DosSetFHState (fd, ulMode))

break;

result = 0;

break;

case F_GETFL:

result = 0;

break;

case F_SETFL:

if (arg != 0)

break;

result = 0;

break;

default :

errno = EINVAL;

break;

}

}

va_end (arg_ptr);

return result;

}

# define fcntl klibc_fcntl

254

#endif

255

256

/* Perform the specified ACTION on the file descriptor FD, possibly

257

using the argument ARG further described below. This replacement

258

handles the following actions, and forwards all others on to the

259

native fcntl. An unrecognized ACTION returns -1 with errno set to

260

EINVAL.

261

262

F_DUPFD - duplicate FD, with int ARG being the minimum target fd.

263

If successful, return the duplicate, which will be inheritable;

264

otherwise return -1 and set errno.

265

266

F_DUPFD_CLOEXEC - duplicate FD, with int ARG being the minimum

267

target fd. If successful, return the duplicate, which will not be

268

inheritable; otherwise return -1 and set errno.

269

270

F_GETFD - ARG need not be present. If successful, return a

271

non-negative value containing the descriptor flags of FD (only

272

FD_CLOEXEC is portable, but other flags may be present); otherwise

273

return -1 and set errno. */

274

275

int

276

rpl_fcntl (int fd, int action, /* arg */...)

{

va_list arg;

int result = -1;

va_start (arg, action);

switch (action)

{

#if !HAVE_FCNTL

case F_DUPFD:

{

int target = va_arg (arg, int);

288

result = dupfd (fd, target, 0);

289

break;

290

}

291

#elif FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR

292

case F_DUPFD:

293

{

294

int target = va_arg (arg, int);

295

/* Detect invalid target; needed for cygwin 1.5.x. */

296

if (target < 0 || getdtablesize () <= target)

errno = EINVAL;

else

{

/* Haiku alpha 2 loses fd flags on original. */

301

int flags = fcntl (fd, F_GETFD);

if (flags < 0)

{

result = -1;

break;

}

result = fcntl (fd, action, target);

308

if (0 <= result && fcntl (fd, F_SETFD, flags) == -1)

309

{

310

int saved_errno = errno;

close (result);

result = -1;

errno = saved_errno;

}

# if REPLACE_FCHDIR

if (0 <= result)

result = _gl_register_dup (fd, result);

# endif

}

break;

} /* F_DUPFD */

#endif /* FCNTL_DUPFD_BUGGY || REPLACE_FCHDIR */

323

324

case F_DUPFD_CLOEXEC:

executed 61028 times by 6 tests: case 1030 :

Executed by:

chgrp
chmod
chown
du
mv
rm

61028

325

{

326

int target = va_arg (arg, int);

327

328

#if !HAVE_FCNTL

329

result = dupfd (fd, target, O_CLOEXEC);

330

break;

331

#else /* HAVE_FCNTL */

332

/* Try the system call first, if the headers claim it exists

333

(that is, if GNULIB_defined_F_DUPFD_CLOEXEC is 0), since we

334

may be running with a glibc that has the macro but with an

335

older kernel that does not support it. Cache the

336

information on whether the system call really works, but

337

avoid caching failure if the corresponding F_DUPFD fails

338

for any reason. 0 = unknown, 1 = yes, -1 = no. */

339

static int have_dupfd_cloexec = GNULIB_defined_F_DUPFD_CLOEXEC ? -1 : 0;

dead code: -1

340

if (0 <= have_dupfd_cloexec)

0 <= have_dupfd_cloexec	Description
TRUE	evaluated 61028 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-61028

341

{

342

result = fcntl (fd, action, target);

343

if (0 <= result || errno != EINVAL)

0 <= result	Description
TRUE	evaluated 61028 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

(*__errno_location ()) != 22	Description
TRUE	never evaluated
FALSE	never evaluated

0-61028

344

{

345

have_dupfd_cloexec = 1;

346

# if REPLACE_FCHDIR

347

if (0 <= result)

348

result = _gl_register_dup (fd, result);

349

# endif

350

}

executed 61028 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

61028

351

else

352

{

353

result = rpl_fcntl (fd, F_DUPFD, target);

354

if (result < 0)

result < 0	Description
TRUE	never evaluated
FALSE	never evaluated

355

break;

never executed: break;

356

have_dupfd_cloexec = -1;

357

}

never executed: end of block

358

}

359

else

360

result = rpl_fcntl (fd, F_DUPFD, target);

never executed: result = rpl_fcntl (fd, 0 , target);

361

if (0 <= result && have_dupfd_cloexec == -1)

0 <= result	Description
TRUE	evaluated 61028 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

have_dupfd_cloexec == -1	Description
TRUE	never evaluated
FALSE	evaluated 61028 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-61028

362

{

363

int flags = fcntl (result, F_GETFD);

364

if (flags < 0 || fcntl (result, F_SETFD, flags | FD_CLOEXEC) == -1)

flags < 0	Description
TRUE	never evaluated
FALSE	never evaluated

fcntl (result,...gs \| 1 ) == -1	Description
TRUE	never evaluated
FALSE	never evaluated

365

{

366

int saved_errno = errno;

close (result);

errno = saved_errno;

result = -1;

}

never executed: end of block

371

}

never executed: end of block

372

break;

executed 61028 times by 6 tests: break;

Executed by:

chgrp
chmod
chown
du
mv
rm

61028

373

#endif /* HAVE_FCNTL */

374

} /* F_DUPFD_CLOEXEC */

#if !HAVE_FCNTL

case F_GETFD:

{

# if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__

380

HANDLE handle = (HANDLE) _get_osfhandle (fd);

381

DWORD flags;

382

if (handle == INVALID_HANDLE_VALUE

383

|| GetHandleInformation (handle, &flags) == 0)

384

errno = EBADF;

385

else

386

result = (flags & HANDLE_FLAG_INHERIT) ? 0 : FD_CLOEXEC;

387

# else /* !W32 */

388

/* Use dup2 to reject invalid file descriptors. No way to

389

access this information, so punt. */

390

if (0 <= dup2 (fd, fd))

result = 0;

# endif /* !W32 */

break;

} /* F_GETFD */

#endif /* !HAVE_FCNTL */

396

397

/* Implementing F_SETFD on mingw is not trivial - there is no

398

API for changing the O_NOINHERIT bit on an fd, and merely

399

changing the HANDLE_FLAG_INHERIT bit on the underlying handle

400

can lead to odd state. It may be possible by duplicating the

401

handle, using _open_osfhandle with the right flags, then

402

using dup2 to move the duplicate onto the original, but that

403

is not supported for now. */

404

405

default:

executed 115 times by 6 tests: default:

Executed by:

cp
dd
shred
sync
tac
tail

115

406

{

407

#if HAVE_FCNTL

408

void *p = va_arg (arg, void *);

409

result = fcntl (fd, action, p);

#else

errno = EINVAL;

#endif

break;

executed 115 times by 6 tests: break;

Executed by:

cp
dd
shred
sync
tac
tail

115

}

}

va_end (arg);

return result;

executed 61143 times by 12 tests: return result;

Executed by:

chgrp
chmod
chown
cp
dd
du
mv
rm
shred
sync
tac
tail

61143

418

}

Generated by Squish Coco 4.1.2