fts.c

! i_ring_empty (fd_ring)	Description
TRUE	evaluated 17578 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 19594 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

17578-19594

278

{

-

279

int fd = i_ring_pop (fd_ring);

-

280

if (0 <= fd)

0 <= fd	Description
TRUE	evaluated 4845 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 12733 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

4845-12733

281

close (fd);

executed 4845 times by 6 tests: close (fd);

Executed by:

chgrp
chmod
chown
du
mv
rm

4845

282

}

executed 17578 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

17578

283

}

executed 19594 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

19594

284

-

285

/* Overload the fts_statp->st_size member (otherwise unused, when

-

286

fts_info is FTS_NSOK) to indicate whether fts_read should stat

-

287

this entry or not. */

-

288

static void

-

289

fts_set_stat_required (FTSENT *p, bool required)

-

290

{

-

291

fts_assert (p->fts_info == FTS_NSOK);

never executed: abort ();

!(p->fts_info == 11)	Description
TRUE	never evaluated
FALSE	evaluated 801792 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-801792

292

p->fts_statp->st_size = (required

required	Description
TRUE	evaluated 345372 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 456420 times by 5 tests Evaluated by: chgrp chown du mv rm

345372-456420

293

? FTS_STAT_REQUIRED

-

294

: FTS_NO_STAT_REQUIRED);

-

295

}

executed 801792 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

801792

296

-

297

/* file-descriptor-relative opendir. */

-

298

/* FIXME: if others need this function, move it into lib/openat.c */

-

299

static DIR *

-

300

internal_function

-

301

opendirat (int fd, char const *dir, int extra_flags, int *pdir_fd)

-

302

{

-

303

int open_flags = (O_RDONLY | O_CLOEXEC | O_DIRECTORY | O_NOCTTY

-

304

| O_NONBLOCK | extra_flags);

-

305

int new_fd = openat (fd, dir, open_flags);

-

306

DIR *dirp;

-

307

-

308

if (new_fd < 0)

new_fd < 0	Description
TRUE	evaluated 7 times by 2 tests Evaluated by: du rm
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

7-61084

309

return NULL;

executed 7 times by 2 tests: return ((void *)0) ;

Executed by:

du
rm

7

310

dirp = fdopendir (new_fd);

-

311

if (dirp)

dirp	Description
TRUE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-61084

312

*pdir_fd = new_fd;

executed 61084 times by 6 tests: *pdir_fd = new_fd;

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

313

else

-

314

{

-

315

int saved_errno = errno;

-

316

close (new_fd);

-

317

errno = saved_errno;

-

318

}

never executed: end of block

0

319

return dirp;

executed 61084 times by 6 tests: return dirp;

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

320

}

-

321

-

322

/* Virtual fchdir. Advance SP's working directory file descriptor,

-

323

SP->fts_cwd_fd, to FD, and push the previous value onto the fd_ring.

-

324

CHDIR_DOWN_ONE is true if FD corresponds to an entry in the directory

-

325

open on sp->fts_cwd_fd; i.e., to move the working directory one level

-

326

down. */

-

327

static void

-

328

internal_function

-

329

cwd_advance_fd (FTS *sp, int fd, bool chdir_down_one)

-

330

{

-

331

int old = sp->fts_cwd_fd;

-

332

fts_assert (old != fd || old == AT_FDCWD);

never executed: abort ();

old != fd	Description
TRUE	evaluated 122052 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 7905 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

old == -100	Description
TRUE	evaluated 7905 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-122052

333

-

334

if (chdir_down_one)

chdir_down_one	Description
TRUE	evaluated 73778 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 56179 times by 5 tests Evaluated by: chgrp chmod du mv rm

56179-73778

335

{

-

336

/* Push "old" onto the ring.

-

337

If the displaced file descriptor is non-negative, close it. */

-

338

int prev_fd_in_slot = i_ring_push (&sp->fts_fd_ring, old);

-

339

fd_ring_print (sp, stderr, "post-push");

-

340

if (0 <= prev_fd_in_slot)

0 <= prev_fd_in_slot	Description
TRUE	evaluated 14193 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 59585 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

14193-59585

341

close (prev_fd_in_slot); /* ignore any close failure */

executed 14193 times by 3 tests: close (prev_fd_in_slot);

Executed by:

chmod
du
rm

14193

342

}

executed 73778 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

73778

343

else if ( ! ISSET (FTS_NOCHDIR))

! (sp->fts_options & (0x0004))	Description
TRUE	evaluated 56179 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

0-56179

344

{

-

345

if (0 <= old)

0 <= old	Description
TRUE	evaluated 56179 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

0-56179

346

close (old); /* ignore any close failure */

executed 56179 times by 5 tests: close (old);

Executed by:

chgrp
chmod
du
mv
rm

56179

347

}

executed 56179 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

56179

348

-

349

sp->fts_cwd_fd = fd;

-

350

}

executed 129957 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

129957

351

-

352

/* Restore the initial, pre-traversal, "working directory".

-

353

In FTS_CWDFD mode, we merely call cwd_advance_fd, otherwise,

-

354

we may actually change the working directory.

-

355

Return 0 upon success. Upon failure, set errno and return nonzero. */

-

356

static int

-

357

restore_initial_cwd (FTS *sp)

-

358

{

-

359

int fail = FCHDIR (sp, ISSET (FTS_CWDFD) ? AT_FDCWD : sp->fts_rfd);

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 12750 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

!(sp->fts_options & (0x0004))	Description
TRUE	evaluated 12750 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 24 times by 3 tests Evaluated by: chgrp chown du

((sp->fts_opti... sp->fts_rfd))	Description
TRUE	never evaluated
FALSE	evaluated 12750 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-12750

360

fd_ring_clear (&(sp->fts_fd_ring));

-

361

return fail;

executed 12774 times by 6 tests: return fail;

Executed by:

chgrp
chmod
chown
du
mv
rm

12774

362

}

-

363

-

364

/* Open the directory DIR if possible, and return a file

-

365

descriptor. Return -1 and set errno on failure. It doesn't matter

-

366

whether the file descriptor has read or write access. */

-

367

-

368

static int

-

369

internal_function

-

370

diropen (FTS const *sp, char const *dir)

-

371

{

-

372

int open_flags = (O_SEARCH | O_CLOEXEC | O_DIRECTORY | O_NOCTTY | O_NONBLOCK

-

373

| (ISSET (FTS_PHYSICAL) ? O_NOFOLLOW : 0)

-

374

| (ISSET (FTS_NOATIME) ? O_NOATIME : 0));

-

375

-

376

int fd = (ISSET (FTS_CWDFD)

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-14191

377

? openat (sp->fts_cwd_fd, dir, open_flags)

-

378

: open (dir, open_flags));

-

379

return fd;

executed 14191 times by 3 tests: return fd;

Executed by:

chmod
du
rm

14191

380

}

-

381

-

382

FTS *

-

383

fts_open (char * const *argv,

-

384

register int options,

-

385

int (*compar) (FTSENT const **, FTSENT const **))

-

386

{

-

387

register FTS *sp;

-

388

register FTSENT *p, *root;

-

389

register size_t nitems;

-

390

FTSENT *parent = NULL;

-

391

FTSENT *tmp = NULL; /* pacify gcc */

-

392

bool defer_stat;

-

393

-

394

/* Options check. */

-

395

if (options & ~FTS_OPTIONMASK) {

options & ~0x1fff	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

396

__set_errno (EINVAL);

-

397

return (NULL);

never executed: return ( ((void *)0) );

0

398

}

-

399

if ((options & FTS_NOCHDIR) && (options & FTS_CWDFD)) {

(options & 0x0004)	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

(options & 0x0200)	Description
TRUE	never evaluated
FALSE	never evaluated

0-6820

400

__set_errno (EINVAL);

-

401

return (NULL);

never executed: return ( ((void *)0) );

0

402

}

-

403

if ( ! (options & (FTS_LOGICAL | FTS_PHYSICAL))) {

! (options & (...002 \| 0x0010))	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

404

__set_errno (EINVAL);

-

405

return (NULL);

never executed: return ( ((void *)0) );

0

406

}

-

407

-

408

/* Allocate/initialize the stream */

-

409

if ((sp = malloc(sizeof(FTS))) == NULL)

(sp = malloc(s...== ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

410

return (NULL);

never executed: return ( ((void *)0) );

0

411

memset(sp, 0, sizeof(FTS));

-

412

sp->fts_compar = compar;

-

413

sp->fts_options = options;

-

414

-

415

/* Logical walks turn on NOCHDIR; symbolic links are too hard. */

-

416

if (ISSET(FTS_LOGICAL)) {

(sp->fts_options & (0x0002))	Description
TRUE	evaluated 13 times by 3 tests Evaluated by: chgrp chown du
FALSE	evaluated 6807 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

13-6807

417

SET(FTS_NOCHDIR);

-

418

CLR(FTS_CWDFD);

-

419

}

executed 13 times by 3 tests: end of block

Executed by:

chgrp
chown
du

13

420

-

421

/* Initialize fts_cwd_fd. */

-

422

sp->fts_cwd_fd = AT_FDCWD;

-

423

if ( ISSET(FTS_CWDFD) && ! HAVE_OPENAT_SUPPORT)

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 6807 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 13 times by 3 tests Evaluated by: chgrp chown du

! 1	Description
TRUE	never evaluated
FALSE	evaluated 6807 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

-

424

{

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

425

/* While it isn't technically necessary to open "." this

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

426

early, doing it here saves us the trouble of ensuring

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

427

later (where it'd be messier) that "." can in fact

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

428

be opened. If not, revert to FTS_NOCHDIR mode. */

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

429

int fd = open (".",

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

430

O_SEARCH | (ISSET (FTS_NOATIME) ? O_NOATIME : 0));

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

431

if (fd < 0)

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

432

{

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

433

/* Even if "." is unreadable, don't revert to FTS_NOCHDIR mode

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

434

on systems like Linux+PROC_FS, where our openat emulation

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

435

is good enough. Note: on a system that emulates

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

436

openat via /proc, this technique can still fail, but

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

437

only in extreme conditions, e.g., when the working

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

438

directory cannot be saved (i.e. save_cwd fails) --

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

439

and that happens on Linux only when "." is unreadable

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

440

and the CWD would be longer than PATH_MAX.

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

441

FIXME: once Linux kernel openat support is well established,

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

442

replace the above open call and this entire if/else block

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

443

with the body of the if-block below. */

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

444

if ( openat_needs_fchdir ())

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

dead code: { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); }

-

445

{

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

dead code: { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); }

-

446

SET(FTS_NOCHDIR);

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

dead code: { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); }

-

447

CLR(FTS_CWDFD);

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

dead code: { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); }

-

448

}

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

dead code: { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); }

-

449

}

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

450

else

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

451

{

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

452

close (fd);

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

453

}

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

454

}

dead code:

{ int fd = open_safer (".", 00 | ((sp->fts_options & (0x0800)) ? 01000000 : 0)); if (fd < 0) { if ( 0 ) { (sp->fts_options |= (0x0004)); (sp->fts_options &= ~(0x0200)); } } else { close (fd); } }

-

455

-

456

/*

-

457

* Start out with 1K of file name space, and enough, in any case,

-

458

* to hold the user's file names.

-

459

*/

-

460

#ifndef MAXPATHLEN

-

461

# define MAXPATHLEN 1024

-

462

#endif

-

463

{

-

464

size_t maxarglen = fts_maxarglen(argv);

-

465

if (! fts_palloc(sp, MAX(maxarglen, MAXPATHLEN)))

! fts_palloc(s...en ):(4096)) )	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

466

goto mem1;

never executed: goto mem1;

0

467

}

-

468

-

469

/* Allocate/initialize root's parent. */

-

470

if (*argv != NULL) {

argv != ((void )0)	Description
TRUE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-6820

471

if ((parent = fts_alloc(sp, "", 0)) == NULL)

(parent = fts_...== ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

472

goto mem2;

never executed: goto mem2;

0

473

parent->fts_level = FTS_ROOTPARENTLEVEL;

-

474

parent->fts_n_dirs_remaining = -1;

-

475

}

executed 6820 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

6820

476

-

477

/* The classic fts implementation would call fts_stat with

-

478

a new entry for each iteration of the loop below.

-

479

If the comparison function is not specified or if the

-

480

FTS_DEFER_STAT option is in effect, don't stat any entry

-

481

in this loop. This is an attempt to minimize the interval

-

482

between the initial stat/lstat/fstatat and the point at which

-

483

a directory argument is first opened. This matters for any

-

484

directory command line argument that resides on a file system

-

485

without genuine i-nodes. If you specify FTS_DEFER_STAT along

-

486

with a comparison function, that function must not access any

-

487

data via the fts_statp pointer. */

-

488

defer_stat = (compar == NULL || ISSET(FTS_DEFER_STAT));

compar == ((void *)0)	Description
TRUE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

(sp->fts_options & (0x0400))	Description
TRUE	never evaluated
FALSE	never evaluated

0-6820

489

-

490

/* Allocate/initialize root(s). */

-

491

for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {

argv != ((void )0)	Description
TRUE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6820-7918

492

/* *Do* allow zero-length file names. */

-

493

size_t len = strlen(*argv);

-

494

-

495

if ( ! (options & FTS_VERBATIM))

! (options & 0x1000)	Description
TRUE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-7918

496

{

-

497

/* If there are two or more trailing slashes, trim all but one,

-

498

but don't change "//" to "/", and do map "///" to "/". */

-

499

char const *v = *argv;

-

500

if (2 < len && v[len - 1] == '/')

2 < len	Description
TRUE	evaluated 4621 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 3297 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

v[len - 1] == '/'	Description
TRUE	evaluated 7 times by 3 tests Evaluated by: du mv rm
FALSE	evaluated 4614 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

7-4621

501

while (1 < len && v[len - 2] == '/')

1 < len	Description
TRUE	evaluated 12 times by 3 tests Evaluated by: du mv rm
FALSE	never evaluated

v[len - 2] == '/'	Description
TRUE	evaluated 5 times by 1 test Evaluated by: rm
FALSE	evaluated 7 times by 3 tests Evaluated by: du mv rm

0-12

502

--len;

executed 5 times by 1 test: --len;

Executed by:

rm

5

503

}

executed 7918 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

7918

504

-

505

if ((p = fts_alloc(sp, *argv, len)) == NULL)

(p = fts_alloc...== ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-7918

506

goto mem3;

never executed: goto mem3;

0

507

p->fts_level = FTS_ROOTLEVEL;

-

508

p->fts_parent = parent;

-

509

p->fts_accpath = p->fts_name;

-

510

/* Even when defer_stat is true, be sure to stat the first

-

511

command line argument, since fts_read (at least with

-

512

FTS_XDEV) requires that. */

-

513

if (defer_stat && root != NULL) {

defer_stat	Description
TRUE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

root != ((void *)0)	Description
TRUE	evaluated 1098 times by 3 tests Evaluated by: chgrp chmod rm
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-7918

514

p->fts_info = FTS_NSOK;

-

515

fts_set_stat_required(p, true);

-

516

} else {

executed 1098 times by 3 tests: end of block

Executed by:

chgrp
chmod
rm

1098

517

p->fts_info = fts_stat(sp, p, false);

-

518

}

executed 6820 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

6820

519

-

520

/*

-

521

* If comparison routine supplied, traverse in sorted

-

522

* order; otherwise traverse in the order specified.

-

523

*/

-

524

if (compar) {

compar	Description
TRUE	never evaluated
FALSE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-7918

525

p->fts_link = root;

-

526

root = p;

-

527

} else {

never executed: end of block

0

528

p->fts_link = NULL;

-

529

if (root == NULL)

root == ((void *)0)	Description
TRUE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 1098 times by 3 tests Evaluated by: chgrp chmod rm

1098-6820

530

tmp = root = p;

executed 6820 times by 6 tests: tmp = root = p;

Executed by:

chgrp
chmod
chown
du
mv
rm

6820

531

else {

-

532

tmp->fts_link = p;

-

533

tmp = p;

-

534

}

executed 1098 times by 3 tests: end of block

Executed by:

chgrp
chmod
rm

1098

535

}

-

536

}

-

537

if (compar && nitems > 1)

compar	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

nitems > 1	Description
TRUE	never evaluated
FALSE	never evaluated

0-6820

538

root = fts_sort(sp, root, nitems);

never executed: root = fts_sort(sp, root, nitems);

0

539

-

540

/*

-

541

* Allocate a dummy pointer and make fts_read think that we've just

-

542

* finished the node before the root(s); set p->fts_info to FTS_INIT

-

543

* so that everything about the "current" node is ignored.

-

544

*/

-

545

if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)

(sp->fts_cur =...== ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

546

goto mem3;

never executed: goto mem3;

0

547

sp->fts_cur->fts_link = root;

-

548

sp->fts_cur->fts_info = FTS_INIT;

-

549

if (! setup_dir (sp))

! setup_dir (sp)	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

550

goto mem3;

never executed: goto mem3;

0

551

-

552

/*

-

553

* If using chdir(2), grab a file descriptor pointing to dot to ensure

-

554

* that we can get back here; this could be avoided for some file names,

-

555

* but almost certainly not worth the effort. Slashes, symbolic links,

-

556

* and ".." are all fairly nasty problems. Note, if we can't get the

-

557

* descriptor we run anyway, just more slowly.

-

558

*/

-

559

if (!ISSET(FTS_NOCHDIR) && !ISSET(FTS_CWDFD)

!(sp->fts_options & (0x0004))	Description
TRUE	evaluated 6807 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 13 times by 3 tests Evaluated by: chgrp chown du

!(sp->fts_options & (0x0200))	Description
TRUE	never evaluated
FALSE	evaluated 6807 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6807

560

&& (sp->fts_rfd = diropen (sp, ".")) < 0)

(sp->fts_rfd =...(sp, ".")) < 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

561

SET(FTS_NOCHDIR);

never executed: (sp->fts_options |= (0x0004));

0

562

-

563

i_ring_init (&sp->fts_fd_ring, -1);

-

564

return (sp);

executed 6820 times by 6 tests: return (sp);

Executed by:

chgrp
chmod
chown
du
mv
rm

6820

565

-

566

mem3: fts_lfree(root);

-

567

free(parent);

-

568

mem2: free(sp->fts_path);

code before this statement never executed: mem2:

0

569

mem1: free(sp);

code before this statement never executed: mem1:

0

570

return (NULL);

never executed: return ( ((void *)0) );

0

571

}

-

572

-

573

static void

-

574

internal_function

-

575

fts_load (FTS *sp, register FTSENT *p)

-

576

{

-

577

register size_t len;

-

578

register char *cp;

-

579

-

580

/*

-

581

* Load the stream structure for the next traversal. Since we don't

-

582

* actually enter the directory until after the preorder visit, set

-

583

* the fts_accpath field specially so the chdir gets done to the right

-

584

* place and the user can access the first node. From fts_open it's

-

585

* known that the file name will fit.

-

586

*/

-

587

len = p->fts_pathlen = p->fts_namelen;

-

588

memmove(sp->fts_path, p->fts_name, len + 1);

-

589

if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {

(cp = strrchr(...ts_name, '/'))	Description
TRUE	evaluated 721 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 7197 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

cp != p->fts_name	Description
TRUE	evaluated 717 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	evaluated 4 times by 4 tests Evaluated by: chgrp chmod chown du

cp[1]	Description
TRUE	never evaluated
FALSE	evaluated 4 times by 4 tests Evaluated by: chgrp chmod chown du

0-7197

590

len = strlen(++cp);

-

591

memmove(p->fts_name, cp, len + 1);

-

592

p->fts_namelen = len;

-

593

}

executed 717 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

717

594

p->fts_accpath = p->fts_path = sp->fts_path;

-

595

}

executed 7918 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

7918

596

-

597

int

-

598

fts_close (FTS *sp)

-

599

{

-

600

register FTSENT *freep, *p;

-

601

int saved_errno = 0;

-

602

-

603

/*

-

604

* This still works if we haven't read anything -- the dummy structure

-

605

* points to the root list, so we step through to the end of the root

-

606

* list which has a valid parent pointer.

-

607

*/

-

608

if (sp->fts_cur) {

sp->fts_cur	Description
TRUE	evaluated 1 time by 1 test Evaluated by: du
FALSE	evaluated 6819 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

1-6819

609

for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {

p->fts_level >= 0	Description
TRUE	evaluated 4 times by 1 test Evaluated by: du
FALSE	evaluated 1 time by 1 test Evaluated by: du

1-4

610

freep = p;

-

611

p = p->fts_link != NULL ? p->fts_link : p->fts_parent;

p->fts_link != ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 4 times by 1 test Evaluated by: du

0-4

612

free(freep);

-

613

}

executed 4 times by 1 test: end of block

Executed by:

du

4

614

free(p);

-

615

}

executed 1 time by 1 test: end of block

Executed by:

du

1

616

-

617

/* Free up child linked list, sort array, file name buffer. */

-

618

if (sp->fts_child)

sp->fts_child	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

619

fts_lfree(sp->fts_child);

never executed: fts_lfree(sp->fts_child);

0

620

free(sp->fts_array);

-

621

free(sp->fts_path);

-

622

-

623

if (ISSET(FTS_CWDFD))

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 6807 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 13 times by 3 tests Evaluated by: chgrp chown du

13-6807

624

{

-

625

if (0 <= sp->fts_cwd_fd)

0 <= sp->fts_cwd_fd	Description
TRUE	evaluated 1 time by 1 test Evaluated by: du
FALSE	evaluated 6806 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

1-6806

626

if (close (sp->fts_cwd_fd))

close (sp->fts_cwd_fd)	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: du

0-1

627

saved_errno = errno;

never executed: saved_errno = (*__errno_location ()) ;

0

628

}

executed 6807 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

6807

629

else if (!ISSET(FTS_NOCHDIR))

!(sp->fts_options & (0x0004))	Description
TRUE	never evaluated
FALSE	evaluated 13 times by 3 tests Evaluated by: chgrp chown du

0-13

630

{

-

631

/* Return to original directory, save errno if necessary. */

-

632

if (fchdir(sp->fts_rfd))

fchdir(sp->fts_rfd)	Description
TRUE	never evaluated
FALSE	never evaluated

0

633

saved_errno = errno;

never executed: saved_errno = (*__errno_location ()) ;

0

634

-

635

/* If close fails, record errno only if saved_errno is zero,

-

636

so that we report the probably-more-meaningful fchdir errno. */

-

637

if (close (sp->fts_rfd))

close (sp->fts_rfd)	Description
TRUE	never evaluated
FALSE	never evaluated

0

638

if (saved_errno == 0)

saved_errno == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

639

saved_errno = errno;

never executed: saved_errno = (*__errno_location ()) ;

0

640

}

never executed: end of block

0

641

-

642

fd_ring_clear (&sp->fts_fd_ring);

-

643

-

644

if (sp->fts_leaf_optimization_works_ht)

sp->fts_leaf_o...ation_works_ht	Description
TRUE	evaluated 4234 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 2586 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

2586-4234

645

hash_free (sp->fts_leaf_optimization_works_ht);

executed 4234 times by 6 tests: hash_free (sp->fts_leaf_optimization_works_ht);

Executed by:

chgrp
chmod
chown
du
mv
rm

4234

646

-

647

free_dir (sp);

-

648

-

649

/* Free up the stream pointer. */

-

650

free(sp);

-

651

-

652

/* Set errno and return. */

-

653

if (saved_errno) {

saved_errno	Description
TRUE	never evaluated
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6820

654

__set_errno (saved_errno);

-

655

return (-1);

never executed: return (-1);

0

656

}

-

657

-

658

return (0);

executed 6820 times by 6 tests: return (0);

Executed by:

chgrp
chmod
chown
du
mv
rm

6820

659

}

-

660

-

661

/* Minimum link count of a traditional Unix directory. When leaf

-

662

optimization is OK and MIN_DIR_NLINK <= st_nlink, then st_nlink is

-

663

an upper bound on the number of subdirectories (counting "." and

-

664

".."). */

-

665

enum { MIN_DIR_NLINK = 2 };

-

666

-

667

/* Whether leaf optimization is OK for a directory. */

-

668

enum leaf_optimization

-

669

{

-

670

/* st_nlink is not reliable for this directory's subdirectories. */

-

671

NO_LEAF_OPTIMIZATION,

-

672

-

673

/* Leaf optimization is OK, but is not useful for avoiding stat calls. */

-

674

OK_LEAF_OPTIMIZATION,

-

675

-

676

/* Leaf optimization is not only OK: it is useful for avoiding

-

677

stat calls, because dirent.d_type does not work. */

-

678

NOSTAT_LEAF_OPTIMIZATION

-

679

};

-

680

-

681

#if defined __linux__ \

-

682

&& HAVE_SYS_VFS_H && HAVE_FSTATFS && HAVE_STRUCT_STATFS_F_TYPE

-

683

-

684

# include <sys/vfs.h>

-

685

-

686

/* Linux-specific constants from coreutils' src/fs.h */

-

687

# define S_MAGIC_AFS 0x5346414F

-

688

# define S_MAGIC_NFS 0x6969

-

689

# define S_MAGIC_PROC 0x9FA0

-

690

# define S_MAGIC_REISERFS 0x52654973

-

691

# define S_MAGIC_TMPFS 0x1021994

-

692

# define S_MAGIC_XFS 0x58465342

-

693

-

694

# ifdef HAVE___FSWORD_T

-

695

typedef __fsword_t fsword;

-

696

# else

-

697

typedef long int fsword;

-

698

# endif

-

699

-

700

/* Map a stat.st_dev number to a file system type number f_ftype. */

-

701

struct dev_type

-

702

{

-

703

dev_t st_dev;

-

704

fsword f_type;

-

705

};

-

706

-

707

/* Use a tiny initial size. If a traversal encounters more than

-

708

a few devices, the cost of growing/rehashing this table will be

-

709

rendered negligible by the number of inodes processed. */

-

710

enum { DEV_TYPE_HT_INITIAL_SIZE = 13 };

-

711

-

712

static size_t

-

713

dev_type_hash (void const *x, size_t table_size)

-

714

{

-

715

struct dev_type const *ax = x;

-

716

uintmax_t dev = ax->st_dev;

-

717

return dev % table_size;

executed 4707 times by 6 tests: return dev % table_size;

Executed by:

chgrp
chmod
chown
du
mv
rm

4707

718

}

-

719

-

720

static bool

-

721

dev_type_compare (void const *x, void const *y)

-

722

{

-

723

struct dev_type const *ax = x;

-

724

struct dev_type const *ay = y;

-

725

return ax->st_dev == ay->st_dev;

executed 242 times by 4 tests: return ax->st_dev == ay->st_dev;

Executed by:

chmod
du
mv
rm

242

726

}

-

727

-

728

/* Return the file system type of P, or 0 if not known.

-

729

Try to cache known values. */

-

730

-

731

static fsword

-

732

filesystem_type (FTSENT const *p)

-

733

{

-

734

FTS *sp = p->fts_fts;

-

735

Hash_table *h = sp->fts_leaf_optimization_works_ht;

-

736

struct dev_type *ent;

-

737

struct statfs fs_buf;

-

738

-

739

/* If we're not in CWDFD mode, don't bother with this optimization,

-

740

since the caller is not serious about performance. */

-

741

if (!ISSET (FTS_CWDFD))

!(sp->fts_options & (0x0200))	Description
TRUE	never evaluated
FALSE	evaluated 4481 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-4481

742

return 0;

never executed: return 0;

0

743

-

744

if (! h)

! h	Description
TRUE	evaluated 4234 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 247 times by 5 tests Evaluated by: chgrp chmod du mv rm

247-4234

745

h = sp->fts_leaf_optimization_works_ht

executed 4234 times by 6 tests:

h = sp->fts_leaf_optimization_works_ht = hash_initialize (DEV_TYPE_HT_INITIAL_SIZE, ((void *)0) , dev_type_hash, dev_type_compare, free);

Executed by:

chgrp
chmod
chown
du
mv
rm

4234

746

= hash_initialize (DEV_TYPE_HT_INITIAL_SIZE, NULL, dev_type_hash,

executed 4234 times by 6 tests:

h = sp->fts_leaf_optimization_works_ht = hash_initialize (DEV_TYPE_HT_INITIAL_SIZE, ((void *)0) , dev_type_hash, dev_type_compare, free);

Executed by:

chgrp
chmod
chown
du
mv
rm

4234

747

dev_type_compare, free);

executed 4234 times by 6 tests:

h = sp->fts_leaf_optimization_works_ht = hash_initialize (DEV_TYPE_HT_INITIAL_SIZE, ((void *)0) , dev_type_hash, dev_type_compare, free);

Executed by:

chgrp
chmod
chown
du
mv
rm

4234

748

if (h)

h	Description
TRUE	evaluated 4481 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-4481

749

{

-

750

struct dev_type tmp;

-

751

tmp.st_dev = p->fts_statp->st_dev;

-

752

ent = hash_lookup (h, &tmp);

-

753

if (ent)

ent	Description
TRUE	evaluated 242 times by 4 tests Evaluated by: chmod du mv rm
FALSE	evaluated 4239 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

242-4239

754

return ent->f_type;

executed 242 times by 4 tests: return ent->f_type;

Executed by:

chmod
du
mv
rm

242

755

}

executed 4239 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

4239

756

-

757

/* Look-up failed. Query directly and cache the result. */

-

758

if (fstatfs (p->fts_fts->fts_cwd_fd, &fs_buf) != 0)

fstatfs (p->ft... &fs_buf) != 0	Description
TRUE	evaluated 4013 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	evaluated 226 times by 4 tests Evaluated by: chmod du mv rm

226-4013

759

return 0;

executed 4013 times by 5 tests: return 0;

Executed by:

chgrp
chown
du
mv
rm

4013

760

-

761

if (h)

h	Description
TRUE	evaluated 226 times by 4 tests Evaluated by: chmod du mv rm
FALSE	never evaluated

0-226

762

{

-

763

struct dev_type *t2 = malloc (sizeof *t2);

-

764

if (t2)

t2	Description
TRUE	evaluated 226 times by 4 tests Evaluated by: chmod du mv rm
FALSE	never evaluated

0-226

765

{

-

766

t2->st_dev = p->fts_statp->st_dev;

-

767

t2->f_type = fs_buf.f_type;

-

768

-

769

ent = hash_insert (h, t2);

-

770

if (ent)

ent	Description
TRUE	evaluated 226 times by 4 tests Evaluated by: chmod du mv rm
FALSE	never evaluated

0-226

771

fts_assert (ent == t2);

never executed: abort ();

executed 226 times by 4 tests: end of block

Executed by:

chmod
du
mv
rm

!(ent == t2)	Description
TRUE	never evaluated
FALSE	evaluated 226 times by 4 tests Evaluated by: chmod du mv rm

0-226

772

else

-

773

free (t2);

never executed: free (t2);

0

774

}

-

775

}

executed 226 times by 4 tests: end of block

Executed by:

chmod
du
mv
rm

226

776

-

777

return fs_buf.f_type;

executed 226 times by 4 tests: return fs_buf.f_type;

Executed by:

chmod
du
mv
rm

226

778

}

-

779

-

780

/* Return false if it is easy to determine the file system type of the

-

781

directory P, and sorting dirents on inode numbers is known not to

-

782

improve traversal performance with that type of file system.

-

783

Otherwise, return true. */

-

784

static bool

-

785

dirent_inode_sort_may_be_useful (FTSENT const *p)

-

786

{

-

787

/* Skip the sort only if we can determine efficiently

-

788

that skipping it is the right thing to do.

-

789

The cost of performing an unnecessary sort is negligible,

-

790

while the cost of *not* performing it can be O(N^2) with

-

791

a very large constant. */

-

792

-

793

switch (filesystem_type (p))

-

794

{

-

795

case S_MAGIC_TMPFS:

never executed: case 0x1021994:

0

796

case S_MAGIC_NFS:

never executed: case 0x6969:

0

797

/* On a file system of any of these types, sorting

-

798

is unnecessary, and hence wasteful. */

-

799

return false;

never executed: return 0 ;

0

800

-

801

default:

executed 14 times by 3 tests: default:

Executed by:

chmod
du
rm

14

802

return true;

executed 14 times by 3 tests: return 1 ;

Executed by:

chmod
du
rm

14

803

}

-

804

}

-

805

-

806

/* Given an FTS entry P for a directory D,

-

807

return true if it is both useful and valid to apply leaf optimization.

-

808

The optimization is useful only for file systems that lack usable

-

809

dirent.d_type info. The optimization is valid if an st_nlink value

-

810

of at least MIN_DIR_NLINK is an upper bound on the number of

-

811

subdirectories of D, counting "." and ".." as subdirectories. */

-

812

static enum leaf_optimization

-

813

leaf_optimization (FTSENT const *p)

-

814

{

-

815

switch (filesystem_type (p))

-

816

{

-

817

/* List here the file system types that may lack usable dirent.d_type

-

818

info, yet for which the optimization does apply. */

-

819

case S_MAGIC_REISERFS:

never executed: case 0x52654973:

0

820

case S_MAGIC_XFS: /* XFS lacked it until 2013-08-22 commit. */

never executed: case 0x58465342:

0

821

return NOSTAT_LEAF_OPTIMIZATION;

never executed: return NOSTAT_LEAF_OPTIMIZATION;

0

822

-

823

case 0:

executed 4013 times by 5 tests: case 0:

Executed by:

chgrp
chown
du
mv
rm

4013

824

/* Leaf optimization is unsafe if the file system type is unknown. */

-

825

FALLTHROUGH;

-

826

case S_MAGIC_AFS:

code before this statement executed 4013 times by 5 tests: case 0x5346414F:

Executed by:

chgrp
chown
du
mv
rm

never executed: case 0x5346414F:

0-4013

827

/* Although AFS mount points are not counted in st_nlink, they

-

828

act like directories. See <https://bugs.debian.org/143111>. */

-

829

FALLTHROUGH;

-

830

case S_MAGIC_NFS:

code before this statement executed 4013 times by 5 tests: case 0x6969:

Executed by:

chgrp
chown
du
mv
rm

never executed: case 0x6969:

0-4013

831

/* NFS provides usable dirent.d_type but not necessarily for all entries

-

832

of large directories, so as per <https://bugzilla.redhat.com/1252549>

-

833

NFS should return true. However st_nlink values are not accurate on

-

834

all implementations as per <https://bugzilla.redhat.com/1299169>. */

-

835

FALLTHROUGH;

-

836

case S_MAGIC_PROC:

code before this statement executed 4013 times by 5 tests: case 0x9FA0:

Executed by:

chgrp
chown
du
mv
rm

never executed: case 0x9FA0:

0-4013

837

/* Per <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=143111> /proc

-

838

may have bogus stat.st_nlink values. */

-

839

return NO_LEAF_OPTIMIZATION;

executed 4013 times by 5 tests: return NO_LEAF_OPTIMIZATION;

Executed by:

chgrp
chown
du
mv
rm

4013

840

-

841

default:

executed 454 times by 3 tests: default:

Executed by:

du
mv
rm

454

842

return OK_LEAF_OPTIMIZATION;

executed 454 times by 3 tests: return OK_LEAF_OPTIMIZATION;

Executed by:

du
mv
rm

454

843

}

-

844

}

-

845

-

846

#else

-

847

static bool

-

848

dirent_inode_sort_may_be_useful (FTSENT const *p _GL_UNUSED)

-

849

{

-

850

return true;

-

851

}

-

852

static enum leaf_optimization

-

853

leaf_optimization (FTSENT const *p _GL_UNUSED)

-

854

{

-

855

return NO_LEAF_OPTIMIZATION;

-

856

}

-

857

#endif

-

858

-

859

/*

-

860

* Special case of "/" at the end of the file name so that slashes aren't

-

861

* appended which would cause file names to be written as "....//foo".

-

862

*/

-

863

#define NAPPEND(p) \

-

864

(p->fts_path[p->fts_pathlen - 1] == '/' \

-

865

? p->fts_pathlen - 1 : p->fts_pathlen)

-

866

-

867

FTSENT *

-

868

fts_read (register FTS *sp)

-

869

{

-

870

register FTSENT *p, *tmp;

-

871

register unsigned short int instr;

-

872

register char *t;

-

873

-

874

/* If finished or unrecoverable error, return NULL. */

-

875

if (sp->fts_cur == NULL || ISSET(FTS_STOP))

sp->fts_cur == ((void *)0)	Description
TRUE	evaluated 1 time by 1 test Evaluated by: rm
FALSE	evaluated 1124821 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

(sp->fts_options & (0x4000))	Description
TRUE	never evaluated
FALSE	evaluated 1124821 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-1124821

876

return (NULL);

executed 1 time by 1 test: return ( ((void *)0) );

Executed by:

rm

1

877

-

878

/* Set current node pointer. */

-

879

p = sp->fts_cur;

-

880

-

881

/* Save and zero out user instructions. */

-

882

instr = p->fts_instr;

-

883

p->fts_instr = FTS_NOINSTR;

-

884

-

885

/* Any type of file may be re-visited; re-stat and re-turn. */

-

886

if (instr == FTS_AGAIN) {

instr == 1	Description
TRUE	evaluated 207901 times by 4 tests Evaluated by: chgrp chmod chown du
FALSE	evaluated 916920 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

207901-916920

887

p->fts_info = fts_stat(sp, p, false);

-

888

return (p);

executed 207901 times by 4 tests: return (p);

Executed by:

chgrp
chmod
chown
du

207901

889

}

-

890

Dprintf (("fts_read: p=%s\n",

-

891

p->fts_info == FTS_INIT ? "" : p->fts_path));

-

892

-

893

/*

-

894

* Following a symlink -- SLNONE test allows application to see

-

895

* SLNONE and recover. If indirecting through a symlink, have

-

896

* keep a pointer to current location. If unable to get that

-

897

* pointer, follow fails.

-

898

*/

-

899

if (instr == FTS_FOLLOW &&

instr == 2	Description
TRUE	never evaluated
FALSE	evaluated 916920 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-916920

900

(p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {

p->fts_info == 12	Description
TRUE	never evaluated
FALSE	never evaluated

p->fts_info == 13	Description
TRUE	never evaluated
FALSE	never evaluated

0

901

p->fts_info = fts_stat(sp, p, true);

-

902

if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {

p->fts_info == 1	Description
TRUE	never evaluated
FALSE	never evaluated

!(sp->fts_options & (0x0004))	Description
TRUE	never evaluated
FALSE	never evaluated

0

903

if ((p->fts_symfd = diropen (sp, ".")) < 0) {

(p->fts_symfd ...(sp, ".")) < 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

904

p->fts_errno = errno;

-

905

p->fts_info = FTS_ERR;

-

906

} else

never executed: end of block

0

907

p->fts_flags |= FTS_SYMFOLLOW;

never executed: p->fts_flags |= 0x02;

0

908

}

-

909

goto check_for_dir;

never executed: goto check_for_dir;

0

910

}

-

911

-

912

/* Directory in pre-order. */

-

913

if (p->fts_info == FTS_D) {

p->fts_info == 1	Description
TRUE	evaluated 101492 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 815428 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

101492-815428

914

/* If skipped or crossed mount point, do post-order visit. */

-

915

if (instr == FTS_SKIP ||

instr == 4	Description
TRUE	evaluated 40401 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 61091 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

40401-61091

916

(ISSET(FTS_XDEV) && p->fts_statp->st_dev != sp->fts_dev)) {

(sp->fts_options & (0x0040))	Description
TRUE	evaluated 7 times by 2 tests Evaluated by: du rm
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

p->fts_statp->...!= sp->fts_dev	Description
TRUE	never evaluated
FALSE	evaluated 7 times by 2 tests Evaluated by: du rm

0-61084

917

if (p->fts_flags & FTS_SYMFOLLOW)

p->fts_flags & 0x02	Description
TRUE	never evaluated
FALSE	evaluated 40401 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-40401

918

(void)close(p->fts_symfd);

never executed: (void)close(p->fts_symfd);

0

919

if (sp->fts_child) {

sp->fts_child	Description
TRUE	never evaluated
FALSE	evaluated 40401 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-40401

920

fts_lfree(sp->fts_child);

-

921

sp->fts_child = NULL;

-

922

}

never executed: end of block

0

923

p->fts_info = FTS_DP;

-

924

LEAVE_DIR (sp, p, "1");

-

925

return (p);

executed 40401 times by 6 tests: return (p);

Executed by:

chgrp
chmod
chown
du
mv
rm

40401

926

}

-

927

-

928

/* Rebuild if only read the names and now traversing. */

-

929

if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {

sp->fts_child != ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 61091 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

(sp->fts_options & (0x2000))	Description
TRUE	never evaluated
FALSE	never evaluated

0-61091

930

CLR(FTS_NAMEONLY);

-

931

fts_lfree(sp->fts_child);

-

932

sp->fts_child = NULL;

-

933

}

never executed: end of block

0

934

-

935

/*

-

936

* Cd to the subdirectory.

-

937

*

-

938

* If have already read and now fail to chdir, whack the list

-

939

* to make the names come out right, and set the parent errno

-

940

* so the application will eventually get an error condition.

-

941

* Set the FTS_DONTCHDIR flag so that when we logically change

-

942

* directories back to the parent we don't do a chdir.

-

943

*

-

944

* If haven't read do so. If the read fails, fts_build sets

-

945

* FTS_STOP or the fts_info field of the node.

-

946

*/

-

947

if (sp->fts_child != NULL) {

sp->fts_child != ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 61091 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-61091

948

if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {

fts_safe_chang...->fts_accpath)	Description
TRUE	never evaluated
FALSE	never evaluated

0

949

p->fts_errno = errno;

-

950

p->fts_flags |= FTS_DONTCHDIR;

-

951

for (p = sp->fts_child; p != NULL;

p != ((void *)0)	Description
TRUE	never evaluated
FALSE	never evaluated

0

952

p = p->fts_link)

-

953

p->fts_accpath =

never executed: p->fts_accpath = p->fts_parent->fts_accpath;

0

954

p->fts_parent->fts_accpath;

never executed: p->fts_accpath = p->fts_parent->fts_accpath;

0

955

}

never executed: end of block

0

956

} else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {

never executed: end of block

(sp->fts_child...== ((void *)0)	Description
TRUE	evaluated 40636 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 20455 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-40636

957

if (ISSET(FTS_STOP))

(sp->fts_options & (0x4000))	Description
TRUE	never evaluated
FALSE	evaluated 40636 times by 3 tests Evaluated by: chmod du rm

0-40636

958

return (NULL);

never executed: return ( ((void *)0) );

0

959

/* If fts_build's call to fts_safe_changedir failed

-

960

because it was not able to fchdir into a

-

961

subdirectory, tell the caller. */

-

962

if (p->fts_errno && p->fts_info != FTS_DNR)

p->fts_errno	Description
TRUE	evaluated 8 times by 2 tests Evaluated by: du rm
FALSE	evaluated 40628 times by 2 tests Evaluated by: chmod du

p->fts_info != 4	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 2 tests Evaluated by: du rm

0-40628

963

p->fts_info = FTS_ERR;

never executed: p->fts_info = 7;

0

964

LEAVE_DIR (sp, p, "2");

-

965

return (p);

executed 40636 times by 3 tests: return (p);

Executed by:

chmod
du
rm

40636

966

}

-

967

p = sp->fts_child;

-

968

sp->fts_child = NULL;

-

969

goto name;

executed 20455 times by 6 tests: goto name;

Executed by:

chgrp
chmod
chown
du
mv
rm

20455

970

}

-

971

-

972

/* Move to the next node on this level. */

-

973

next: tmp = p;

code before this statement executed 815428 times by 6 tests: next:

Executed by:

chgrp
chmod
chown
du
mv
rm

815428

974

-

975

/* If we have so many directory entries that we're reading them

-

976

in batches, and we've reached the end of the current batch,

-

977

read in a new batch. */

-

978

if (p->fts_link == NULL && p->fts_parent->fts_dirp)

p->fts_link == ((void *)0)	Description
TRUE	evaluated 27274 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 788154 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

p->fts_parent->fts_dirp	Description
TRUE	evaluated 6 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 27268 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6-788154

979

{

-

980

p = tmp->fts_parent;

-

981

sp->fts_cur = p;

-

982

sp->fts_path[p->fts_pathlen] = '\0';

-

983

-

984

if ((p = fts_build (sp, BREAD)) == NULL)

(p = fts_build...== ((void *)0)	Description
TRUE	evaluated 3 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 3 times by 3 tests Evaluated by: chmod du rm

3

985

{

-

986

if (ISSET(FTS_STOP))

(sp->fts_options & (0x4000))	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 3 tests Evaluated by: chmod du rm

0-3

987

return NULL;

never executed: return ((void *)0) ;

0

988

goto cd_dot_dot;

executed 3 times by 3 tests: goto cd_dot_dot;

Executed by:

chmod
du
rm

3

989

}

-

990

-

991

free(tmp);

-

992

goto name;

executed 3 times by 3 tests: goto name;

Executed by:

chmod
du
rm

3

993

}

-

994

-

995

if ((p = p->fts_link) != NULL) {

(p = p->fts_li...!= ((void *)0)	Description
TRUE	evaluated 788154 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 27268 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

27268-788154

996

sp->fts_cur = p;

-

997

free(tmp);

-

998

-

999

/*

-

1000

* If reached the top, return to the original directory (or

-

1001

* the root of the tree), and load the file names for the next

-

1002

* root.

-

1003

*/

-

1004

if (p->fts_level == FTS_ROOTLEVEL) {

p->fts_level == 0	Description
TRUE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 780236 times by 5 tests Evaluated by: chgrp chmod du mv rm

7918-780236

1005

if (restore_initial_cwd(sp)) {

restore_initial_cwd(sp)	Description
TRUE	never evaluated
FALSE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-7918

1006

SET(FTS_STOP);

-

1007

return (NULL);

never executed: return ( ((void *)0) );

0

1008

}

-

1009

free_dir(sp);

-

1010

fts_load(sp, p);

-

1011

setup_dir(sp);

-

1012

goto check_for_dir;

executed 7918 times by 6 tests: goto check_for_dir;

Executed by:

chgrp
chmod
chown
du
mv
rm

7918

1013

}

-

1014

-

1015

/*

-

1016

* User may have called fts_set on the node. If skipped,

-

1017

* ignore. If followed, get a file descriptor so we can

-

1018

* get back if necessary.

-

1019

*/

-

1020

if (p->fts_instr == FTS_SKIP)

p->fts_instr == 4	Description
TRUE	never evaluated
FALSE	evaluated 780236 times by 5 tests Evaluated by: chgrp chmod du mv rm

0-780236

1021

goto next;

never executed: goto next;

0

1022

if (p->fts_instr == FTS_FOLLOW) {

p->fts_instr == 2	Description
TRUE	never evaluated
FALSE	evaluated 780236 times by 5 tests Evaluated by: chgrp chmod du mv rm

0-780236

1023

p->fts_info = fts_stat(sp, p, true);

-

1024

if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {

p->fts_info == 1	Description
TRUE	never evaluated
FALSE	never evaluated

!(sp->fts_options & (0x0004))	Description
TRUE	never evaluated
FALSE	never evaluated

0

1025

if ((p->fts_symfd = diropen (sp, ".")) < 0) {

(p->fts_symfd ...(sp, ".")) < 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

1026

p->fts_errno = errno;

-

1027

p->fts_info = FTS_ERR;

-

1028

} else

never executed: end of block

0

1029

p->fts_flags |= FTS_SYMFOLLOW;

never executed: p->fts_flags |= 0x02;

0

1030

}

-

1031

p->fts_instr = FTS_NOINSTR;

-

1032

}

never executed: end of block

0

1033

-

1034

name: t = sp->fts_path + NAPPEND(p->fts_parent);

p->fts_parent-...en - 1] == '/'	Description
TRUE	evaluated 27 times by 2 tests Evaluated by: du rm
FALSE	evaluated 800667 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

code before this statement executed 780236 times by 5 tests: name:

Executed by:

chgrp
chmod
du
mv
rm

27-800667

1035

*t++ = '/';

-

1036

memmove(t, p->fts_name, p->fts_namelen + 1);

-

1037

check_for_dir:

code before this statement executed 800694 times by 6 tests: check_for_dir:

Executed by:

chgrp
chmod
chown
du
mv
rm

800694

1038

sp->fts_cur = p;

-

1039

if (p->fts_info == FTS_NSOK)

p->fts_info == 11	Description
TRUE	evaluated 801792 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6820-801792

1040

{

-

1041

if (p->fts_statp->st_size == FTS_STAT_REQUIRED)

p->fts_statp->..._STAT_REQUIRED	Description
TRUE	evaluated 345372 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 456420 times by 5 tests Evaluated by: chgrp chown du mv rm

345372-456420

1042

{

-

1043

FTSENT *parent = p->fts_parent;

-

1044

if (parent->fts_n_dirs_remaining == 0

parent->fts_n_...remaining == 0	Description
TRUE	evaluated 4145 times by 3 tests Evaluated by: chgrp chmod du
FALSE	evaluated 341227 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

4145-341227

1045

&& ISSET(FTS_NOSTAT)

(sp->fts_options & (0x0008))	Description
TRUE	evaluated 42 times by 1 test Evaluated by: du
FALSE	evaluated 4103 times by 2 tests Evaluated by: chgrp chmod

42-4103

1046

&& ISSET(FTS_PHYSICAL)

(sp->fts_options & (0x0010))	Description
TRUE	never evaluated
FALSE	evaluated 42 times by 1 test Evaluated by: du

0-42

1047

&& (leaf_optimization (parent)

(leaf_optimiza..._OPTIMIZATION)	Description
TRUE	never evaluated
FALSE	never evaluated

0

1048

== NOSTAT_LEAF_OPTIMIZATION))

(leaf_optimiza..._OPTIMIZATION)	Description
TRUE	never evaluated
FALSE	never evaluated

0

1049

{

-

1050

/* nothing more needed */

-

1051

}

never executed: end of block

0

1052

else

-

1053

{

-

1054

p->fts_info = fts_stat(sp, p, false);

-

1055

if (S_ISDIR(p->fts_statp->st_mode)

(((( p->fts_st... == (0040000))	Description
TRUE	evaluated 96490 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 248882 times by 4 tests Evaluated by: chgrp chmod du rm

96490-248882

1056

&& p->fts_level != FTS_ROOTLEVEL

p->fts_level != 0	Description
TRUE	evaluated 96375 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 115 times by 3 tests Evaluated by: chgrp chmod rm

115-96375

1057

&& 0 < parent->fts_n_dirs_remaining

0 < parent->ft...dirs_remaining	Description
TRUE	evaluated 96334 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 41 times by 1 test Evaluated by: du

41-96334

1058

&& parent->fts_n_dirs_remaining != (nlink_t) -1)

parent->fts_n_...= (nlink_t) -1	Description
TRUE	evaluated 95198 times by 4 tests Evaluated by: chmod du mv rm
FALSE	evaluated 1136 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

1136-95198

1059

parent->fts_n_dirs_remaining--;

executed 95198 times by 4 tests: parent->fts_n_dirs_remaining--;

Executed by:

chmod
du
mv
rm

95198

1060

}

executed 345372 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

345372

1061

}

-

1062

else

-

1063

fts_assert (p->fts_statp->st_size == FTS_NO_STAT_REQUIRED);

never executed: abort ();

executed 456420 times by 5 tests: end of block

Executed by:

chgrp
chown
du
mv
rm

!(p->fts_statp...STAT_REQUIRED)	Description
TRUE	never evaluated
FALSE	evaluated 456420 times by 5 tests Evaluated by: chgrp chown du mv rm

0-456420

1064

}

-

1065

-

1066

if (p->fts_info == FTS_D)

p->fts_info == 1	Description
TRUE	evaluated 101494 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 707118 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

101494-707118

1067

{

-

1068

/* Now that P->fts_statp is guaranteed to be valid,

-

1069

if this is a command-line directory, record its

-

1070

device number, to be used for FTS_XDEV. */

-

1071

if (p->fts_level == FTS_ROOTLEVEL)

p->fts_level == 0	Description
TRUE	evaluated 5119 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 96375 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

5119-96375

1072

sp->fts_dev = p->fts_statp->st_dev;

executed 5119 times by 6 tests: sp->fts_dev = p->fts_statp->st_dev;

Executed by:

chgrp
chmod
chown
du
mv
rm

5119

1073

Dprintf ((" entering: %s\n", p->fts_path));

-

1074

if (! enter_dir (sp, p))

! enter_dir (sp, p)	Description
TRUE	never evaluated
FALSE	evaluated 101494 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-101494

1075

{

-

1076

__set_errno (ENOMEM);

-

1077

return NULL;

never executed: return ((void *)0) ;

0

1078

}

-

1079

}

executed 101494 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

101494

1080

return p;

executed 808612 times by 6 tests: return p;

Executed by:

chgrp
chmod
chown
du
mv
rm

808612

1081

}

-

1082

cd_dot_dot:

code before this statement executed 27268 times by 6 tests: cd_dot_dot:

Executed by:

chgrp
chmod
chown
du
mv
rm

27268

1083

-

1084

/* Move up to the parent node. */

-

1085

p = tmp->fts_parent;

-

1086

sp->fts_cur = p;

-

1087

free(tmp);

-

1088

-

1089

if (p->fts_level == FTS_ROOTPARENTLEVEL) {

p->fts_level == (-1)	Description
TRUE	evaluated 6819 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 20452 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6819-20452

1090

/*

-

1091

* Done; free everything up and set errno to 0 so the user

-

1092

* can distinguish between error and EOF.

-

1093

*/

-

1094

free(p);

-

1095

__set_errno (0);

-

1096

return (sp->fts_cur = NULL);

executed 6819 times by 6 tests: return (sp->fts_cur = ((void *)0) );

Executed by:

chgrp
chmod
chown
du
mv
rm

6819

1097

}

-

1098

-

1099

fts_assert (p->fts_info != FTS_NSOK);

never executed: abort ();

!(p->fts_info != 11)	Description
TRUE	never evaluated
FALSE	evaluated 20452 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-20452

1100

-

1101

/* NUL terminate the file name. */

-

1102

sp->fts_path[p->fts_pathlen] = '\0';

-

1103

-

1104

/*

-

1105

* Return to the parent directory. If at a root node, restore

-

1106

* the initial working directory. If we came through a symlink,

-

1107

* go back through the file descriptor. Otherwise, move up

-

1108

* one level, via "..".

-

1109

*/

-

1110

if (p->fts_level == FTS_ROOTLEVEL) {

p->fts_level == 0	Description
TRUE	evaluated 4704 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 15748 times by 5 tests Evaluated by: chgrp chmod du mv rm

4704-15748

1111

if (restore_initial_cwd(sp)) {

restore_initial_cwd(sp)	Description
TRUE	never evaluated
FALSE	evaluated 4704 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-4704

1112

p->fts_errno = errno;

-

1113

SET(FTS_STOP);

-

1114

}

never executed: end of block

0

1115

} else if (p->fts_flags & FTS_SYMFOLLOW) {

executed 4704 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

p->fts_flags & 0x02	Description
TRUE	never evaluated
FALSE	evaluated 15748 times by 5 tests Evaluated by: chgrp chmod du mv rm

0-15748

1116

if (FCHDIR(sp, p->fts_symfd)) {

(sp->fts_options & (0x0200))	Description
TRUE	never evaluated
FALSE	never evaluated

!(sp->fts_options & (0x0004))	Description
TRUE	never evaluated
FALSE	never evaluated

((sp->fts_opti...p->fts_symfd))	Description
TRUE	never evaluated
FALSE	never evaluated

0

1117

p->fts_errno = errno;

-

1118

SET(FTS_STOP);

-

1119

}

never executed: end of block

0

1120

(void)close(p->fts_symfd);

-

1121

} else if (!(p->fts_flags & FTS_DONTCHDIR) &&

never executed: end of block

!(p->fts_flags & 0x01)	Description
TRUE	evaluated 15748 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

0-15748

1122

fts_safe_changedir(sp, p->fts_parent, -1, "..")) {

fts_safe_chang...ent, -1, "..")	Description
TRUE	evaluated 1 time by 1 test Evaluated by: du
FALSE	evaluated 15747 times by 5 tests Evaluated by: chgrp chmod du mv rm

1-15747

1123

p->fts_errno = errno;

-

1124

SET(FTS_STOP);

-

1125

}

executed 1 time by 1 test: end of block

Executed by:

du

1

1126

-

1127

/* If the directory causes a cycle, preserve the FTS_DC flag and keep

-

1128

the corresponding dev/ino pair in the hash table. It is going to be

-

1129

removed when leaving the original directory. */

-

1130

if (p->fts_info != FTS_DC) {

p->fts_info != 2	Description
TRUE	evaluated 20452 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-20452

1131

p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;

p->fts_errno	Description
TRUE	evaluated 2 times by 2 tests Evaluated by: du rm
FALSE	evaluated 20450 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

2-20450

1132

if (p->fts_errno == 0)

p->fts_errno == 0	Description
TRUE	evaluated 20450 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 2 times by 2 tests Evaluated by: du rm

2-20450

1133

LEAVE_DIR (sp, p, "3");

executed 20450 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

20450

1134

}

executed 20452 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

20452

1135

return ISSET(FTS_STOP) ? NULL : p;

executed 20452 times by 6 tests: return (sp->fts_options & (0x4000)) ? ((void *)0) : p;

Executed by:

chgrp
chmod
chown
du
mv
rm

20452

1136

}

-

1137

-

1138

/*

-

1139

* Fts_set takes the stream as an argument although it's not used in this

-

1140

* implementation; it would be necessary if anyone wanted to add global

-

1141

* semantics to fts using fts_set. An error return is allowed for similar

-

1142

* reasons.

-

1143

*/

-

1144

/* ARGSUSED */

-

1145

int

-

1146

fts_set(FTS *sp _GL_UNUSED, FTSENT *p, int instr)

-

1147

{

-

1148

if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&

instr != 0	Description
TRUE	evaluated 248470 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

instr != 1	Description
TRUE	evaluated 40569 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 207901 times by 4 tests Evaluated by: chgrp chmod chown du

instr != 2	Description
TRUE	evaluated 40569 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-248470

1149

instr != FTS_NOINSTR && instr != FTS_SKIP) {

instr != 3	Description
TRUE	evaluated 40569 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

instr != 4	Description
TRUE	never evaluated
FALSE	evaluated 40569 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-40569

1150

__set_errno (EINVAL);

-

1151

return (1);

never executed: return (1);

0

1152

}

-

1153

p->fts_instr = instr;

-

1154

return (0);

executed 248470 times by 6 tests: return (0);

Executed by:

chgrp
chmod
chown
du
mv
rm

248470

1155

}

-

1156

-

1157

FTSENT *

-

1158

fts_children (register FTS *sp, int instr)

-

1159

{

-

1160

register FTSENT *p;

-

1161

int fd;

-

1162

-

1163

if (instr != 0 && instr != FTS_NAMEONLY) {

instr != 0	Description
TRUE	never evaluated
FALSE	never evaluated

instr != 0x2000	Description
TRUE	never evaluated
FALSE	never evaluated

0

1164

__set_errno (EINVAL);

-

1165

return (NULL);

never executed: return ( ((void *)0) );

0

1166

}

-

1167

-

1168

/* Set current node pointer. */

-

1169

p = sp->fts_cur;

-

1170

-

1171

/*

-

1172

* Errno set to 0 so user can distinguish empty directory from

-

1173

* an error.

-

1174

*/

-

1175

__set_errno (0);

-

1176

-

1177

/* Fatal errors stop here. */

-

1178

if (ISSET(FTS_STOP))

(sp->fts_options & (0x4000))	Description
TRUE	never evaluated
FALSE	never evaluated

0

1179

return (NULL);

never executed: return ( ((void *)0) );

0

1180

-

1181

/* Return logical hierarchy of user's arguments. */

-

1182

if (p->fts_info == FTS_INIT)

p->fts_info == 9	Description
TRUE	never evaluated
FALSE	never evaluated

0

1183

return (p->fts_link);

never executed: return (p->fts_link);

0

1184

-

1185

/*

-

1186

* If not a directory being visited in pre-order, stop here. Could

-

1187

* allow FTS_DNR, assuming the user has fixed the problem, but the

-

1188

* same effect is available with FTS_AGAIN.

-

1189

*/

-

1190

if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)

p->fts_info != 1	Description
TRUE	never evaluated
FALSE	never evaluated

0

1191

return (NULL);

never executed: return ( ((void *)0) );

0

1192

-

1193

/* Free up any previous child list. */

-

1194

if (sp->fts_child != NULL)

sp->fts_child != ((void *)0)	Description
TRUE	never evaluated
FALSE	never evaluated

0

1195

fts_lfree(sp->fts_child);

never executed: fts_lfree(sp->fts_child);

0

1196

-

1197

if (instr == FTS_NAMEONLY) {

instr == 0x2000	Description
TRUE	never evaluated
FALSE	never evaluated

0

1198

SET(FTS_NAMEONLY);

-

1199

instr = BNAMES;

-

1200

} else

never executed: end of block

0

1201

instr = BCHILD;

never executed: instr = 1;

0

1202

-

1203

/*

-

1204

* If using chdir on a relative file name and called BEFORE fts_read

-

1205

* does its chdir to the root of a traversal, we can lose -- we need to

-

1206

* chdir into the subdirectory, and we don't know where the current

-

1207

* directory is, so we can't get back so that the upcoming chdir by

-

1208

* fts_read will work.

-

1209

*/

-

1210

if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||

p->fts_level != 0	Description
TRUE	never evaluated
FALSE	never evaluated

p->fts_accpath[0] == '/'	Description
TRUE	never evaluated
FALSE	never evaluated

0

1211

ISSET(FTS_NOCHDIR))

(sp->fts_options & (0x0004))	Description
TRUE	never evaluated
FALSE	never evaluated

0

1212

return (sp->fts_child = fts_build(sp, instr));

never executed: return (sp->fts_child = fts_build(sp, instr));

0

1213

-

1214

if ((fd = diropen (sp, ".")) < 0)

(fd = diropen (sp, ".")) < 0	Description
TRUE	never evaluated
FALSE	never evaluated

0

1215

return (sp->fts_child = NULL);

never executed: return (sp->fts_child = ((void *)0) );

0

1216

sp->fts_child = fts_build(sp, instr);

-

1217

if (ISSET(FTS_CWDFD))

(sp->fts_options & (0x0200))	Description
TRUE	never evaluated
FALSE	never evaluated

0

1218

{

-

1219

cwd_advance_fd (sp, fd, true);

-

1220

}

never executed: end of block

0

1221

else

-

1222

{

-

1223

if (fchdir(fd))

fchdir(fd)	Description
TRUE	never evaluated
FALSE	never evaluated

0

1224

{

-

1225

int saved_errno = errno;

-

1226

close (fd);

-

1227

__set_errno (saved_errno);

-

1228

return NULL;

never executed: return ((void *)0) ;

0

1229

}

-

1230

close (fd);

-

1231

}

never executed: end of block

0

1232

return (sp->fts_child);

never executed: return (sp->fts_child);

0

1233

}

-

1234

-

1235

/* A comparison function to sort on increasing inode number.

-

1236

For some file system types, sorting either way makes a huge

-

1237

performance difference for a directory with very many entries,

-

1238

but sorting on increasing values is slightly better than sorting

-

1239

on decreasing values. The difference is in the 5% range. */

-

1240

static int

-

1241

fts_compare_ino (struct _ftsent const **a, struct _ftsent const **b)

-

1242

{

-

1243

return (a[0]->fts_statp->st_ino < b[0]->fts_statp->st_ino ? -1

executed 11305644 times by 3 tests:

return (a[0]->fts_statp->st_ino < b[0]->fts_statp->st_ino ? -1 : b[0]->fts_statp->st_ino < a[0]->fts_statp->st_ino ? 1 : 0);

Executed by:

chmod
du
rm

11305644

1244

: b[0]->fts_statp->st_ino < a[0]->fts_statp->st_ino ? 1 : 0);

executed 11305644 times by 3 tests:

return (a[0]->fts_statp->st_ino < b[0]->fts_statp->st_ino ? -1 : b[0]->fts_statp->st_ino < a[0]->fts_statp->st_ino ? 1 : 0);

Executed by:

chmod
du
rm

11305644

1245

}

-

1246

-

1247

/* Map the dirent.d_type value, DTYPE, to the corresponding stat.st_mode

-

1248

S_IF* bit and set ST.st_mode, thus clearing all other bits in that field. */

-

1249

static void

-

1250

set_stat_type (struct stat *st, unsigned int dtype)

-

1251

{

-

1252

mode_t type;

-

1253

switch (dtype)

-

1254

{

-

1255

case DT_BLK:

never executed: case DT_BLK :

0

1256

type = S_IFBLK;

-

1257

break;

never executed: break;

0

1258

case DT_CHR:

never executed: case DT_CHR :

0

1259

type = S_IFCHR;

-

1260

break;

never executed: break;

0

1261

case DT_DIR:

executed 96336 times by 5 tests: case DT_DIR :

Executed by:

chgrp
chmod
du
mv
rm

96336

1262

type = S_IFDIR;

-

1263

break;

executed 96336 times by 5 tests: break;

Executed by:

chgrp
chmod
du
mv
rm

96336

1264

case DT_FIFO:

executed 26 times by 2 tests: case DT_FIFO :

Executed by:

chmod
rm

26

1265

type = S_IFIFO;

-

1266

break;

executed 26 times by 2 tests: break;

Executed by:

chmod
rm

26

1267

case DT_LNK:

executed 645 times by 5 tests: case DT_LNK :

Executed by:

chgrp
chmod
chown
du
rm

645

1268

type = S_IFLNK;

-

1269

break;

executed 645 times by 5 tests: break;

Executed by:

chgrp
chmod
chown
du
rm

645

1270

case DT_REG:

executed 703687 times by 5 tests: case DT_REG :

Executed by:

chgrp
chmod
du
mv
rm

703687

1271

type = S_IFREG;

-

1272

break;

executed 703687 times by 5 tests: break;

Executed by:

chgrp
chmod
du
mv
rm

703687

1273

case DT_SOCK:

never executed: case DT_SOCK :

0

1274

type = S_IFSOCK;

-

1275

break;

never executed: break;

0

1276

default:

never executed: default:

0

1277

type = 0;

-

1278

}

never executed: end of block

0

1279

st->st_mode = type;

-

1280

}

executed 800694 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

800694

1281

-

1282

#define closedir_and_clear(dirp) \

-

1283

do \

-

1284

{ \

-

1285

closedir (dirp); \

-

1286

dirp = NULL; \

-

1287

} \

-

1288

while (0)

-

1289

-

1290

#define fts_opendir(file, Pdir_fd) \

-

1291

opendirat((! ISSET(FTS_NOCHDIR) && ISSET(FTS_CWDFD) \

-

1292

? sp->fts_cwd_fd : AT_FDCWD), \

-

1293

file, \

-

1294

(((ISSET(FTS_PHYSICAL) \

-

1295

&& ! (ISSET(FTS_COMFOLLOW) \

-

1296

&& cur->fts_level == FTS_ROOTLEVEL)) \

-

1297

? O_NOFOLLOW : 0) \

-

1298

| (ISSET (FTS_NOATIME) ? O_NOATIME : 0)), \

-

1299

Pdir_fd)

-

1300

-

1301

/*

-

1302

* This is the tricky part -- do not casually change *anything* in here. The

-

1303

* idea is to build the linked list of entries that are used by fts_children

-

1304

* and fts_read. There are lots of special cases.

-

1305

*

-

1306

* The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is

-

1307

* set and it's a physical walk (so that symbolic links can't be directories),

-

1308

* we can do things quickly. First, if it's a 4.4BSD file system, the type

-

1309

* of the file is in the directory entry. Otherwise, we assume that the number

-

1310

* of subdirectories in a node is equal to the number of links to the parent.

-

1311

* The former skips all stat calls. The latter skips stat calls in any leaf

-

1312

* directories and for any files after the subdirectories in the directory have

-

1313

* been found, cutting the stat calls by about 2/3.

-

1314

*/

-

1315

static FTSENT *

-

1316

internal_function

-

1317

fts_build (register FTS *sp, int type)

-

1318

{

-

1319

register FTSENT *p, *head;

-

1320

register size_t nitems;

-

1321

FTSENT *tail;

-

1322

void *oldaddr;

-

1323

int saved_errno;

-

1324

bool descend;

-

1325

bool doadjust;

-

1326

ptrdiff_t level;

-

1327

size_t len, maxlen, new_len;

-

1328

char *cp;

-

1329

int dir_fd;

-

1330

FTSENT *cur = sp->fts_cur;

-

1331

bool continue_readdir = !!cur->fts_dirp;

-

1332

size_t max_entries;

-

1333

-

1334

/* When cur->fts_dirp is non-NULL, that means we should

-

1335

continue calling readdir on that existing DIR* pointer

-

1336

rather than opening a new one. */

-

1337

if (continue_readdir)

continue_readdir	Description
TRUE	evaluated 6 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 61091 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6-61091

1338

{

-

1339

DIR *dp = cur->fts_dirp;

-

1340

dir_fd = dirfd (dp);

-

1341

if (dir_fd < 0)

dir_fd < 0	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 3 tests Evaluated by: chmod du rm

0-6

1342

{

-

1343

closedir_and_clear (cur->fts_dirp);

-

1344

if (type == BREAD)

type == 3	Description
TRUE	never evaluated
FALSE	never evaluated

0

1345

{

-

1346

cur->fts_info = FTS_DNR;

-

1347

cur->fts_errno = errno;

-

1348

}

never executed: end of block

0

1349

return NULL;

never executed: return ((void *)0) ;

0

1350

}

-

1351

}

executed 6 times by 3 tests: end of block

Executed by:

chmod
du
rm

6

1352

else

-

1353

{

-

1354

/* Open the directory for reading. If this fails, we're done.

-

1355

If being called from fts_read, set the fts_info field. */

-

1356

if ((cur->fts_dirp = fts_opendir(cur->fts_accpath, &dir_fd)) == NULL)

(cur->fts_dirp...== ((void *)0)	Description
TRUE	evaluated 7 times by 2 tests Evaluated by: du rm
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

7-61084

1357

{

-

1358

if (type == BREAD)

type == 3	Description
TRUE	evaluated 7 times by 2 tests Evaluated by: du rm
FALSE	never evaluated

0-7

1359

{

-

1360

cur->fts_info = FTS_DNR;

-

1361

cur->fts_errno = errno;

-

1362

}

executed 7 times by 2 tests: end of block

Executed by:

du
rm

7

1363

return NULL;

executed 7 times by 2 tests: return ((void *)0) ;

Executed by:

du
rm

7

1364

}

-

1365

/* Rather than calling fts_stat for each and every entry encountered

-

1366

in the readdir loop (below), stat each directory only right after

-

1367

opening it. */

-

1368

if (cur->fts_info == FTS_NSOK)

cur->fts_info == 11	Description
TRUE	never evaluated
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-61084

1369

cur->fts_info = fts_stat(sp, cur, false);

never executed: cur->fts_info = fts_stat(sp, cur, 0 );

0

1370

else if (sp->fts_options & FTS_TIGHT_CYCLE_CHECK)

sp->fts_options & 0x0100	Description
TRUE	evaluated 650 times by 1 test Evaluated by: du
FALSE	evaluated 60434 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

650-60434

1371

{

-

1372

/* Now read the stat info again after opening a directory to

-

1373

reveal eventual changes caused by a submount triggered by

-

1374

the traversal. But do it only for utilities which use

-

1375

FTS_TIGHT_CYCLE_CHECK. Therefore, only find and du

-

1376

benefit/suffer from this feature for now. */

-

1377

LEAVE_DIR (sp, cur, "4");

-

1378

fts_stat (sp, cur, false);

-

1379

if (! enter_dir (sp, cur))

! enter_dir (sp, cur)	Description
TRUE	never evaluated
FALSE	evaluated 650 times by 1 test Evaluated by: du

0-650

1380

{

-

1381

__set_errno (ENOMEM);

-

1382

return NULL;

never executed: return ((void *)0) ;

0

1383

}

-

1384

}

executed 650 times by 1 test: end of block

Executed by:

du

650

1385

}

executed 61084 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

1386

-

1387

/* Maximum number of readdir entries to read at one time. This

-

1388

limitation is to avoid reading millions of entries into memory

-

1389

at once. When an fts_compar function is specified, we have no

-

1390

choice: we must read all entries into memory before calling that

-

1391

function. But when no such function is specified, we can read

-

1392

entries in batches that are large enough to help us with inode-

-

1393

sorting, yet not so large that we risk exhausting memory. */

-

1394

max_entries = sp->fts_compar ? SIZE_MAX : FTS_MAX_READDIR_ENTRIES;

sp->fts_compar	Description
TRUE	never evaluated
FALSE	evaluated 61090 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-61090

1395

-

1396

/*

-

1397

* If we're going to need to stat anything or we want to descend

-

1398

* and stay in the directory, chdir. If this fails we keep going,

-

1399

* but set a flag so we don't chdir after the post-order visit.

-

1400

* We won't be able to stat anything, but we can still return the

-

1401

* names themselves. Note, that since fts_read won't be able to

-

1402

* chdir into the directory, it will have to return different file

-

1403

* names than before, i.e. "a/b" instead of "b". Since the node

-

1404

* has already been visited in pre-order, have to wait until the

-

1405

* post-order visit to return the error. There is a special case

-

1406

* here, if there was nothing to stat then it's not an error to

-

1407

* not be able to stat. This is all fairly nasty. If a program

-

1408

* needed sorted entries or stat information, they had better be

-

1409

* checking FTS_NS on the returned nodes.

-

1410

*/

-

1411

if (continue_readdir)

continue_readdir	Description
TRUE	evaluated 6 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6-61084

1412

{

-

1413

/* When resuming a short readdir run, we already have

-

1414

the required dirp and dir_fd. */

-

1415

descend = true;

-

1416

}

executed 6 times by 3 tests: end of block

Executed by:

chmod
du
rm

6

1417

else

-

1418

{

-

1419

/* Try to descend unless it is a names-only fts_children,

-

1420

or the directory is known to lack subdirectories. */

-

1421

descend = (type != BNAMES

type != 2	Description
TRUE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-61084

1422

&& ! (ISSET (FTS_NOSTAT) && ISSET (FTS_PHYSICAL)

(sp->fts_options & (0x0008))	Description
TRUE	evaluated 18182 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	evaluated 42902 times by 2 tests Evaluated by: chgrp chmod

(sp->fts_options & (0x0010))	Description
TRUE	evaluated 18128 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	evaluated 54 times by 3 tests Evaluated by: chgrp chown du

54-42902

1423

&& ! ISSET (FTS_SEEDOT)

! (sp->fts_options & (0x0020))	Description
TRUE	evaluated 18128 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	never evaluated

0-18128

1424

&& cur->fts_statp->st_nlink == MIN_DIR_NLINK

cur->fts_statp... MIN_DIR_NLINK	Description
TRUE	evaluated 4467 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	evaluated 13661 times by 4 tests Evaluated by: chgrp du mv rm

4467-13661

1425

&& (leaf_optimization (cur)

(leaf_optimiza..._OPTIMIZATION)	Description
TRUE	evaluated 454 times by 3 tests Evaluated by: du mv rm
FALSE	evaluated 4013 times by 5 tests Evaluated by: chgrp chown du mv rm

454-4013

1426

!= NO_LEAF_OPTIMIZATION)));

(leaf_optimiza..._OPTIMIZATION)	Description
TRUE	evaluated 454 times by 3 tests Evaluated by: du mv rm
FALSE	evaluated 4013 times by 5 tests Evaluated by: chgrp chown du mv rm

454-4013

1427

if (descend || type == BREAD)

descend	Description
TRUE	evaluated 60630 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 454 times by 3 tests Evaluated by: du mv rm

type == 3	Description
TRUE	evaluated 454 times by 3 tests Evaluated by: du mv rm
FALSE	never evaluated

0-60630

1428

{

-

1429

if (ISSET(FTS_CWDFD))

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 61028 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 56 times by 3 tests Evaluated by: chgrp chown du

56-61028

1430

dir_fd = fcntl (dir_fd, F_DUPFD_CLOEXEC, STDERR_FILENO + 1);

executed 61028 times by 6 tests: dir_fd = rpl_fcntl (dir_fd, 1030 , 2 + 1);

Executed by:

chgrp
chmod
chown
du
mv
rm

61028

1431

if (dir_fd < 0 || fts_safe_changedir(sp, cur, dir_fd, NULL)) {

dir_fd < 0	Description
TRUE	never evaluated
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

fts_safe_chang... ((void *)0) )	Description
TRUE	never evaluated
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-61084

1432

if (descend && type == BREAD)

descend	Description
TRUE	never evaluated
FALSE	never evaluated

type == 3	Description
TRUE	never evaluated
FALSE	never evaluated

0

1433

cur->fts_errno = errno;

never executed: cur->fts_errno = (*__errno_location ()) ;

0

1434

cur->fts_flags |= FTS_DONTCHDIR;

-

1435

descend = false;

-

1436

closedir_and_clear(cur->fts_dirp);

-

1437

if (ISSET(FTS_CWDFD) && 0 <= dir_fd)

(sp->fts_options & (0x0200))	Description
TRUE	never evaluated
FALSE	never evaluated

0 <= dir_fd	Description
TRUE	never evaluated
FALSE	never evaluated

0

1438

close (dir_fd);

never executed: close (dir_fd);

0

1439

cur->fts_dirp = NULL;

-

1440

} else

never executed: end of block

0

1441

descend = true;

executed 61084 times by 6 tests: descend = 1 ;

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

1442

}

-

1443

}

executed 61084 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

1444

-

1445

/*

-

1446

* Figure out the max file name length that can be stored in the

-

1447

* current buffer -- the inner loop allocates more space as necessary.

-

1448

* We really wouldn't have to do the maxlen calculations here, we

-

1449

* could do them in fts_read before returning the name, but it's a

-

1450

* lot easier here since the length is part of the dirent structure.

-

1451

*

-

1452

* If not changing directories set a pointer so that can just append

-

1453

* each new component into the file name.

-

1454

*/

-

1455

len = NAPPEND(cur);

cur->fts_path[...en - 1] == '/'	Description
TRUE	evaluated 4 times by 2 tests Evaluated by: du rm
FALSE	evaluated 61086 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

4-61086

1456

if (ISSET(FTS_NOCHDIR)) {

(sp->fts_options & (0x0004))	Description
TRUE	evaluated 56 times by 3 tests Evaluated by: chgrp chown du
FALSE	evaluated 61034 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

56-61034

1457

cp = sp->fts_path + len;

-

1458

*cp++ = '/';

-

1459

} else {

executed 56 times by 3 tests: end of block

Executed by:

chgrp
chown
du

56

1460

/* GCC, you're too verbose. */

-

1461

cp = NULL;

-

1462

}

executed 61034 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

61034

1463

len++;

-

1464

maxlen = sp->fts_pathlen - len;

-

1465

-

1466

level = cur->fts_level + 1;

-

1467

-

1468

/* Read the directory, attaching each entry to the "link" pointer. */

-

1469

doadjust = false;

-

1470

head = NULL;

-

1471

tail = NULL;

-

1472

nitems = 0;

-

1473

while (cur->fts_dirp) {

cur->fts_dirp	Description
TRUE	evaluated 983942 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-983942

1474

size_t d_namelen;

-

1475

__set_errno (0);

-

1476

struct dirent *dp = readdir(cur->fts_dirp);

-

1477

if (dp == NULL) {

dp == ((void *)0)	Description
TRUE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 922858 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

61084-922858

1478

if (errno) {

(*__errno_location ())	Description
TRUE	evaluated 2 times by 1 test Evaluated by: rm
FALSE	evaluated 61082 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

2-61082

1479

cur->fts_errno = errno;

-

1480

/* If we've not read any items yet, treat

-

1481

the error as if we can't access the dir. */

-

1482

cur->fts_info = (continue_readdir || nitems)

continue_readdir	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: rm

nitems	Description
TRUE	evaluated 1 time by 1 test Evaluated by: rm
FALSE	evaluated 1 time by 1 test Evaluated by: rm

0-2

1483

? FTS_ERR : FTS_DNR;

-

1484

}

executed 2 times by 1 test: end of block

Executed by:

rm

2

1485

break;

executed 61084 times by 6 tests: break;

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

1486

}

-

1487

if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))

!(sp->fts_options & (0x0020))	Description
TRUE	evaluated 922858 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

dp->d_name[0] == '.'	Description
TRUE	evaluated 122165 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 800693 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

!dp->d_name[1]	Description
TRUE	evaluated 61082 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 61083 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

dp->d_name[1] == '.'	Description
TRUE	evaluated 61082 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 1 time by 1 test Evaluated by: chmod

!dp->d_name[2]	Description
TRUE	evaluated 61082 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-922858

1488

continue;

executed 122164 times by 6 tests: continue;

Executed by:

chgrp
chmod
chown
du
mv
rm

122164

1489

-

1490

d_namelen = _D_EXACT_NAMLEN (dp);

-

1491

p = fts_alloc (sp, dp->d_name, d_namelen);

-

1492

if (!p)

!p	Description
TRUE	never evaluated
FALSE	evaluated 800694 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-800694

1493

goto mem1;

never executed: goto mem1;

0

1494

if (d_namelen >= maxlen) {

d_namelen >= maxlen	Description
TRUE	evaluated 7 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 800687 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

7-800687

1495

/* include space for NUL */

-

1496

oldaddr = sp->fts_path;

-

1497

if (! fts_palloc(sp, d_namelen + len + 1)) {

! fts_palloc(s...len + len + 1)	Description
TRUE	never evaluated
FALSE	evaluated 7 times by 3 tests Evaluated by: chmod du rm

0-7

1498

/*

-

1499

* No more memory. Save

-

1500

* errno, free up the current structure and the

-

1501

* structures already allocated.

-

1502

*/

-

1503

mem1: saved_errno = errno;

-

1504

free(p);

-

1505

fts_lfree(head);

-

1506

closedir_and_clear(cur->fts_dirp);

-

1507

cur->fts_info = FTS_ERR;

-

1508

SET(FTS_STOP);

-

1509

__set_errno (saved_errno);

-

1510

return (NULL);

never executed: return ( ((void *)0) );

0

1511

}

-

1512

/* Did realloc() change the pointer? */

-

1513

if (oldaddr != sp->fts_path) {

oldaddr != sp->fts_path	Description
TRUE	evaluated 7 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-7

1514

doadjust = true;

-

1515

if (ISSET(FTS_NOCHDIR))

(sp->fts_options & (0x0004))	Description
TRUE	never evaluated
FALSE	evaluated 7 times by 3 tests Evaluated by: chmod du rm

0-7

1516

cp = sp->fts_path + len;

never executed: cp = sp->fts_path + len;

0

1517

}

executed 7 times by 3 tests: end of block

Executed by:

chmod
du
rm

7

1518

maxlen = sp->fts_pathlen - len;

-

1519

}

executed 7 times by 3 tests: end of block

Executed by:

chmod
du
rm

7

1520

-

1521

new_len = len + d_namelen;

-

1522

if (new_len < len) {

new_len < len	Description
TRUE	never evaluated
FALSE	evaluated 800694 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-800694

1523

/*

-

1524

* In the unlikely event that we would end up

-

1525

* with a file name longer than SIZE_MAX, free up

-

1526

* the current structure and the structures already

-

1527

* allocated, then error out with ENAMETOOLONG.

-

1528

*/

-

1529

free(p);

-

1530

fts_lfree(head);

-

1531

closedir_and_clear(cur->fts_dirp);

-

1532

cur->fts_info = FTS_ERR;

-

1533

SET(FTS_STOP);

-

1534

__set_errno (ENAMETOOLONG);

-

1535

return (NULL);

never executed: return ( ((void *)0) );

0

1536

}

-

1537

p->fts_level = level;

-

1538

p->fts_parent = sp->fts_cur;

-

1539

p->fts_pathlen = new_len;

-

1540

-

1541

/* Store dirent.d_ino, in case we need to sort

-

1542

entries before processing them. */

-

1543

p->fts_statp->st_ino = D_INO (dp);

-

1544

-

1545

/* Build a file name for fts_stat to stat. */

-

1546

if (ISSET(FTS_NOCHDIR)) {

(sp->fts_options & (0x0004))	Description
TRUE	evaluated 65 times by 3 tests Evaluated by: chgrp chown du
FALSE	evaluated 800629 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

65-800629

1547

p->fts_accpath = p->fts_path;

-

1548

memmove(cp, p->fts_name, p->fts_namelen + 1);

-

1549

} else

executed 65 times by 3 tests: end of block

Executed by:

chgrp
chown
du

65

1550

p->fts_accpath = p->fts_name;

executed 800629 times by 6 tests: p->fts_accpath = p->fts_name;

Executed by:

chgrp
chmod
chown
du
mv
rm

800629

1551

-

1552

if (sp->fts_compar == NULL || ISSET(FTS_DEFER_STAT)) {

sp->fts_compar == ((void *)0)	Description
TRUE	evaluated 800694 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

(sp->fts_options & (0x0400))	Description
TRUE	never evaluated
FALSE	never evaluated

0-800694

1553

/* Record what fts_read will have to do with this

-

1554

entry. In many cases, it will simply fts_stat it,

-

1555

but we can take advantage of any d_type information

-

1556

to optimize away the unnecessary stat calls. I.e.,

-

1557

if FTS_NOSTAT is in effect and we're not following

-

1558

symlinks (FTS_PHYSICAL) and d_type indicates this

-

1559

is *not* a directory, then we won't have to stat it

-

1560

at all. If it *is* a directory, then (currently)

-

1561

we stat it regardless, in order to get device and

-

1562

inode numbers. Some day we might optimize that

-

1563

away, too, for directories where d_ino is known to

-

1564

be valid. */

-

1565

bool skip_stat = (ISSET(FTS_PHYSICAL)

(sp->fts_options & (0x0010))	Description
TRUE	evaluated 800629 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 65 times by 3 tests Evaluated by: chgrp chown du

65-800629

1566

&& ISSET(FTS_NOSTAT)

(sp->fts_options & (0x0008))	Description
TRUE	evaluated 510421 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	evaluated 290208 times by 2 tests Evaluated by: chgrp chmod

290208-510421

1567

&& DT_IS_KNOWN(dp)

((dp)->d_type != DT_UNKNOWN )	Description
TRUE	evaluated 510421 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	never evaluated

0-510421

1568

&& ! DT_MUST_BE(dp, DT_DIR));

! ((dp)->d_type == ( DT_DIR ))	Description
TRUE	evaluated 456420 times by 5 tests Evaluated by: chgrp chown du mv rm
FALSE	evaluated 54001 times by 4 tests Evaluated by: chgrp du mv rm

54001-456420

1569

p->fts_info = FTS_NSOK;

-

1570

/* Propagate dirent.d_type information back

-

1571

to caller, when possible. */

-

1572

set_stat_type (p->fts_statp, D_TYPE (dp));

-

1573

fts_set_stat_required(p, !skip_stat);

-

1574

} else {

executed 800694 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

800694

1575

p->fts_info = fts_stat(sp, p, false);

-

1576

}

never executed: end of block

0

1577

-

1578

/* We walk in directory order so "ls -f" doesn't get upset. */

-

1579

p->fts_link = NULL;

-

1580

if (head == NULL)

head == ((void *)0)	Description
TRUE	evaluated 20458 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 780236 times by 5 tests Evaluated by: chgrp chmod du mv rm

20458-780236

1581

head = tail = p;

executed 20458 times by 6 tests: head = tail = p;

Executed by:

chgrp
chmod
chown
du
mv
rm

20458

1582

else {

-

1583

tail->fts_link = p;

-

1584

tail = p;

-

1585

}

executed 780236 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

780236

1586

++nitems;

-

1587

if (max_entries <= nitems) {

max_entries <= nitems	Description
TRUE	evaluated 6 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 800688 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6-800688

1588

/* When there are too many dir entries, leave

-

1589

fts_dirp open, so that a subsequent fts_read

-

1590

can take up where we leave off. */

-

1591

goto break_without_closedir;

executed 6 times by 3 tests: goto break_without_closedir;

Executed by:

chmod
du
rm

6

1592

}

-

1593

}

executed 800688 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

800688

1594

-

1595

if (cur->fts_dirp)

cur->fts_dirp	Description
TRUE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-61084

1596

closedir_and_clear(cur->fts_dirp);

executed 61084 times by 6 tests: end of block

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

1597

-

1598

break_without_closedir:

code before this statement executed 61084 times by 6 tests: break_without_closedir:

Executed by:

chgrp
chmod
chown
du
mv
rm

61084

1599

-

1600

/*

-

1601

* If realloc() changed the address of the file name, adjust the

-

1602

* addresses for the rest of the tree and the dir list.

-

1603

*/

-

1604

if (doadjust)

doadjust	Description
TRUE	evaluated 7 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 61083 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

7-61083

1605

fts_padjust(sp, head);

executed 7 times by 3 tests: fts_padjust(sp, head);

Executed by:

chmod
du
rm

7

1606

-

1607

/*

-

1608

* If not changing directories, reset the file name back to original

-

1609

* state.

-

1610

*/

-

1611

if (ISSET(FTS_NOCHDIR)) {

(sp->fts_options & (0x0004))	Description
TRUE	evaluated 56 times by 3 tests Evaluated by: chgrp chown du
FALSE	evaluated 61034 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

56-61034

1612

if (len == sp->fts_pathlen || nitems == 0)

len == sp->fts_pathlen	Description
TRUE	never evaluated
FALSE	evaluated 56 times by 3 tests Evaluated by: chgrp chown du

nitems == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: du
FALSE	evaluated 55 times by 3 tests Evaluated by: chgrp chown du

0-56

1613

--cp;

executed 1 time by 1 test: --cp;

Executed by:

du

1

1614

*cp = '\0';

-

1615

}

executed 56 times by 3 tests: end of block

Executed by:

chgrp
chown
du

56

1616

-

1617

/*

-

1618

* If descended after called from fts_children or after called from

-

1619

* fts_read and nothing found, get back. At the root level we use

-

1620

* the saved fd; if one of fts_open()'s arguments is a relative name

-

1621

* to an empty directory, we wind up here with no other way back. If

-

1622

* can't get back, we're done.

-

1623

*/

-

1624

if (!continue_readdir && descend && (type == BCHILD || !nitems) &&

!continue_readdir	Description
TRUE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 6 times by 3 tests Evaluated by: chmod du rm

descend	Description
TRUE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

type == 1	Description
TRUE	never evaluated
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

!nitems	Description
TRUE	evaluated 40629 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 20455 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-61084

1625

(cur->fts_level == FTS_ROOTLEVEL

cur->fts_level == 0	Description
TRUE	evaluated 152 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 40477 times by 2 tests Evaluated by: chmod du

(cur->fts_leve...nt, -1, ".."))	Description
TRUE	never evaluated
FALSE	evaluated 40629 times by 3 tests Evaluated by: chmod du rm

0-40629

1626

? restore_initial_cwd(sp)

(cur->fts_leve...nt, -1, ".."))	Description
TRUE	never evaluated
FALSE	evaluated 40629 times by 3 tests Evaluated by: chmod du rm

0-40629

1627

: fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {

(cur->fts_leve...nt, -1, ".."))	Description
TRUE	never evaluated
FALSE	evaluated 40629 times by 3 tests Evaluated by: chmod du rm

0-40629

1628

cur->fts_info = FTS_ERR;

-

1629

SET(FTS_STOP);

-

1630

fts_lfree(head);

-

1631

return (NULL);

never executed: return ( ((void *)0) );

0

1632

}

-

1633

-

1634

/* If didn't find anything, return NULL. */

-

1635

if (!nitems) {

!nitems	Description
TRUE	evaluated 40632 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 20458 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

20458-40632

1636

if (type == BREAD

type == 3	Description
TRUE	evaluated 40632 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-40632

1637

&& cur->fts_info != FTS_DNR && cur->fts_info != FTS_ERR)

cur->fts_info != 4	Description
TRUE	evaluated 40631 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 1 time by 1 test Evaluated by: rm

cur->fts_info != 7	Description
TRUE	evaluated 40631 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-40631

1638

cur->fts_info = FTS_DP;

executed 40631 times by 3 tests: cur->fts_info = 6;

Executed by:

chmod
du
rm

40631

1639

fts_lfree(head);

-

1640

return (NULL);

executed 40632 times by 3 tests: return ( ((void *)0) );

Executed by:

chmod
du
rm

40632

1641

}

-

1642

-

1643

/* If there are many entries, no sorting function has been specified,

-

1644

and this file system is of a type that may be slow with a large

-

1645

number of entries, then sort the directory entries on increasing

-

1646

inode numbers. */

-

1647

if (nitems > _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD

nitems > _FTS_...RIES_THRESHOLD	Description
TRUE	evaluated 14 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 20444 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

14-20444

1648

&& !sp->fts_compar

!sp->fts_compar	Description
TRUE	evaluated 14 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-14

1649

&& dirent_inode_sort_may_be_useful (cur)) {

dirent_inode_s...e_useful (cur)	Description
TRUE	evaluated 14 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-14

1650

sp->fts_compar = fts_compare_ino;

-

1651

head = fts_sort (sp, head, nitems);

-

1652

sp->fts_compar = NULL;

-

1653

}

executed 14 times by 3 tests: end of block

Executed by:

chmod
du
rm

14

1654

-

1655

/* Sort the entries. */

-

1656

if (sp->fts_compar && nitems > 1)

sp->fts_compar	Description
TRUE	never evaluated
FALSE	evaluated 20458 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

nitems > 1	Description
TRUE	never evaluated
FALSE	never evaluated

0-20458

1657

head = fts_sort(sp, head, nitems);

never executed: head = fts_sort(sp, head, nitems);

0

1658

return (head);

executed 20458 times by 6 tests: return (head);

Executed by:

chgrp
chmod
chown
du
mv
rm

20458

1659

}

-

1660

-

1661

#if FTS_DEBUG

-

1662

-

1663

/* Walk ->fts_parent links starting at E_CURR, until the root of the

-

1664

current hierarchy. There should be a directory with dev/inode

-

1665

matching those of AD. If not, print a lot of diagnostics. */

-

1666

static void

-

1667

find_matching_ancestor (FTSENT const *e_curr, struct Active_dir const *ad)

-

1668

{

-

1669

FTSENT const *ent;

-

1670

for (ent = e_curr; ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)

-

1671

{

-

1672

if (ad->ino == ent->fts_statp->st_ino

-

1673

&& ad->dev == ent->fts_statp->st_dev)

-

1674

return;

-

1675

}

-

1676

printf ("ERROR: tree dir, %s, not active\n", ad->fts_ent->fts_accpath);

-

1677

printf ("active dirs:\n");

-

1678

for (ent = e_curr;

-

1679

ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)

-

1680

printf (" %s(%"PRIuMAX"/%"PRIuMAX") to %s(%"PRIuMAX"/%"PRIuMAX")...\n",

-

1681

ad->fts_ent->fts_accpath,

-

1682

(uintmax_t) ad->dev,

-

1683

(uintmax_t) ad->ino,

-

1684

ent->fts_accpath,

-

1685

(uintmax_t) ent->fts_statp->st_dev,

-

1686

(uintmax_t) ent->fts_statp->st_ino);

-

1687

}

-

1688

-

1689

void

-

1690

fts_cross_check (FTS const *sp)

-

1691

{

-

1692

FTSENT const *ent = sp->fts_cur;

-

1693

FTSENT const *t;

-

1694

if ( ! ISSET (FTS_TIGHT_CYCLE_CHECK))

-

1695

return;

-

1696

-

1697

Dprintf (("fts-cross-check cur=%s\n", ent->fts_path));

-

1698

/* Make sure every parent dir is in the tree. */

-

1699

for (t = ent->fts_parent; t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)

-

1700

{

-

1701

struct Active_dir ad;

-

1702

ad.ino = t->fts_statp->st_ino;

-

1703

ad.dev = t->fts_statp->st_dev;

-

1704

if ( ! hash_lookup (sp->fts_cycle.ht, &ad))

-

1705

printf ("ERROR: active dir, %s, not in tree\n", t->fts_path);

-

1706

}

-

1707

-

1708

/* Make sure every dir in the tree is an active dir.

-

1709

But ENT is not necessarily a directory. If so, just skip this part. */

-

1710

if (ent->fts_parent->fts_level >= FTS_ROOTLEVEL

-

1711

&& (ent->fts_info == FTS_DP

-

1712

|| ent->fts_info == FTS_D))

-

1713

{

-

1714

struct Active_dir *ad;

-

1715

for (ad = hash_get_first (sp->fts_cycle.ht); ad != NULL;

-

1716

ad = hash_get_next (sp->fts_cycle.ht, ad))

-

1717

{

-

1718

find_matching_ancestor (ent, ad);

-

1719

}

-

1720

}

-

1721

}

-

1722

-

1723

static bool

-

1724

same_fd (int fd1, int fd2)

-

1725

{

-

1726

struct stat sb1, sb2;

-

1727

return (fstat (fd1, &sb1) == 0

-

1728

&& fstat (fd2, &sb2) == 0

-

1729

&& SAME_INODE (sb1, sb2));

-

1730

}

-

1731

-

1732

static void

-

1733

fd_ring_print (FTS const *sp, FILE *stream, char const *msg)

-

1734

{

-

1735

I_ring const *fd_ring = &sp->fts_fd_ring;

-

1736

unsigned int i = fd_ring->fts_front;

-

1737

char *cwd = getcwdat (sp->fts_cwd_fd, NULL, 0);

-

1738

fprintf (stream, "=== %s ========== %s\n", msg, cwd);

-

1739

free (cwd);

-

1740

if (i_ring_empty (fd_ring))

-

1741

return;

-

1742

-

1743

while (true)

-

1744

{

-

1745

int fd = fd_ring->fts_fd_ring[i];

-

1746

if (fd < 0)

-

1747

fprintf (stream, "%d: %d:\n", i, fd);

-

1748

else

-

1749

{

-

1750

char *wd = getcwdat (fd, NULL, 0);

-

1751

fprintf (stream, "%d: %d: %s\n", i, fd, wd);

-

1752

free (wd);

-

1753

}

-

1754

if (i == fd_ring->fts_back)

-

1755

break;

-

1756

i = (i + I_RING_SIZE - 1) % I_RING_SIZE;

-

1757

}

-

1758

}

-

1759

-

1760

/* Ensure that each file descriptor on the fd_ring matches a

-

1761

parent, grandparent, etc. of the current working directory. */

-

1762

static void

-

1763

fd_ring_check (FTS const *sp)

-

1764

{

-

1765

if (!fts_debug)

-

1766

return;

-

1767

-

1768

/* Make a writable copy. */

-

1769

I_ring fd_w = sp->fts_fd_ring;

-

1770

-

1771

int cwd_fd = sp->fts_cwd_fd;

-

1772

cwd_fd = fcntl (cwd_fd, F_DUPFD_CLOEXEC, STDERR_FILENO + 1);

-

1773

char *dot = getcwdat (cwd_fd, NULL, 0);

-

1774

error (0, 0, "===== check ===== cwd: %s", dot);

-

1775

free (dot);

-

1776

while ( ! i_ring_empty (&fd_w))

-

1777

{

-

1778

int fd = i_ring_pop (&fd_w);

-

1779

if (0 <= fd)

-

1780

{

-

1781

int open_flags = O_SEARCH | O_CLOEXEC | O_NOATIME;

-

1782

int parent_fd = openat (cwd_fd, "..", open_flags);

-

1783

if (parent_fd < 0)

-

1784

{

-

1785

// Warn?

-

1786

break;

-

1787

}

-

1788

if (!same_fd (fd, parent_fd))

-

1789

{

-

1790

char *cwd = getcwdat (fd, NULL, 0);

-

1791

error (0, errno, "ring : %s", cwd);

-

1792

char *c2 = getcwdat (parent_fd, NULL, 0);

-

1793

error (0, errno, "parent: %s", c2);

-

1794

free (cwd);

-

1795

free (c2);

-

1796

fts_assert (0);

-

1797

}

-

1798

close (cwd_fd);

-

1799

cwd_fd = parent_fd;

-

1800

}

-

1801

}

-

1802

close (cwd_fd);

-

1803

}

-

1804

#endif

-

1805

-

1806

static unsigned short int

-

1807

internal_function

-

1808

fts_stat(FTS *sp, register FTSENT *p, bool follow)

-

1809

{

-

1810

struct stat *sbp = p->fts_statp;

-

1811

-

1812

if (p->fts_level == FTS_ROOTLEVEL && ISSET(FTS_COMFOLLOW))

p->fts_level == 0	Description
TRUE	evaluated 8159 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 552584 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

(sp->fts_options & (0x0001))	Description
TRUE	evaluated 827 times by 4 tests Evaluated by: chgrp chmod chown du
FALSE	evaluated 7332 times by 5 tests Evaluated by: chgrp chown du mv rm

827-552584

1813

follow = true;

executed 827 times by 4 tests: follow = 1 ;

Executed by:

chgrp
chmod
chown
du

827

1814

-

1815

/*

-

1816

* If doing a logical walk, or application requested FTS_FOLLOW, do

-

1817

* a stat(2). If that fails, check for a non-existent symlink. If

-

1818

* fail, set the errno from the stat call.

-

1819

*/

-

1820

if (ISSET(FTS_LOGICAL) || follow) {

(sp->fts_options & (0x0002))	Description
TRUE	evaluated 81 times by 3 tests Evaluated by: chgrp chown du
FALSE	evaluated 560662 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

follow	Description
TRUE	evaluated 827 times by 4 tests Evaluated by: chgrp chmod chown du
FALSE	evaluated 559835 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

81-560662

1821

if (stat(p->fts_accpath, sbp)) {

stat(p->fts_accpath, sbp)	Description
TRUE	evaluated 47 times by 2 tests Evaluated by: chmod du
FALSE	evaluated 861 times by 4 tests Evaluated by: chgrp chmod chown du

47-861

1822

if (errno == ENOENT

(*__errno_location ()) == 2	Description
TRUE	evaluated 44 times by 2 tests Evaluated by: chmod du
FALSE	evaluated 3 times by 2 tests Evaluated by: chmod du

3-44

1823

&& lstat(p->fts_accpath, sbp) == 0) {

lstat(p->fts_a...ath, sbp) == 0	Description
TRUE	evaluated 2 times by 2 tests Evaluated by: chmod du
FALSE	evaluated 42 times by 1 test Evaluated by: chmod

2-42

1824

__set_errno (0);

-

1825

return (FTS_SLNONE);

executed 2 times by 2 tests: return (13);

Executed by:

chmod
du

2

1826

}

-

1827

p->fts_errno = errno;

-

1828

goto err;

executed 45 times by 2 tests: goto err;

Executed by:

chmod
du

45

1829

}

-

1830

} else if (fstatat(sp->fts_cwd_fd, p->fts_accpath, sbp,

executed 861 times by 4 tests: end of block

Executed by:

chgrp
chmod
chown
du

fstatat(sp->ft..., sbp, 0x100 )	Description
TRUE	evaluated 508 times by 5 tests Evaluated by: chgrp chmod chown du rm
FALSE	evaluated 559327 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

508-559327

1831

AT_SYMLINK_NOFOLLOW)) {

fstatat(sp->ft..., sbp, 0x100 )	Description
TRUE	evaluated 508 times by 5 tests Evaluated by: chgrp chmod chown du rm
FALSE	evaluated 559327 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

508-559327

1832

p->fts_errno = errno;

-

1833

err: memset(sbp, 0, sizeof(struct stat));

code before this statement executed 508 times by 5 tests: err:

Executed by:

chgrp
chmod
chown
du
rm

508

1834

return (FTS_NS);

executed 553 times by 5 tests: return (10);

Executed by:

chgrp
chmod
chown
du
rm

553

1835

}

-

1836

-

1837

if (S_ISDIR(sbp->st_mode)) {

(((( sbp->st_m... == (0040000))	Description
TRUE	evaluated 102144 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 458044 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

102144-458044

1838

p->fts_n_dirs_remaining

-

1839

= ((sbp->st_nlink < MIN_DIR_NLINK

sbp->st_nlink < MIN_DIR_NLINK	Description
TRUE	never evaluated
FALSE	evaluated 102144 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-102144

1840

|| p->fts_level <= FTS_ROOTLEVEL)

p->fts_level <= 0	Description
TRUE	evaluated 5336 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 96808 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

5336-96808

1841

? -1

-

1842

: sbp->st_nlink - (ISSET (FTS_SEEDOT) ? 0 : MIN_DIR_NLINK));

(sp->fts_options & (0x0020))	Description
TRUE	never evaluated
FALSE	evaluated 96808 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-96808

1843

if (ISDOT(p->fts_name)) {

p->fts_name[0] == '.'	Description
TRUE	evaluated 38 times by 3 tests Evaluated by: chmod chown du
FALSE	evaluated 102106 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

!p->fts_name[1]	Description
TRUE	evaluated 35 times by 3 tests Evaluated by: chmod chown du
FALSE	evaluated 3 times by 2 tests Evaluated by: chmod du

p->fts_name[1] == '.'	Description
TRUE	evaluated 3 times by 2 tests Evaluated by: chmod du
FALSE	never evaluated

!p->fts_name[2]	Description
TRUE	evaluated 3 times by 2 tests Evaluated by: chmod du
FALSE	never evaluated

0-102106

1844

/* Command-line "." and ".." are real directories. */

-

1845

return (p->fts_level == FTS_ROOTLEVEL ? FTS_D : FTS_DOT);

executed 38 times by 3 tests: return (p->fts_level == 0 ? 1 : 5);

Executed by:

chmod
chown
du

38

1846

}

-

1847

-

1848

return (FTS_D);

executed 102106 times by 6 tests: return (1);

Executed by:

chgrp
chmod
chown
du
mv
rm

102106

1849

}

-

1850

if (S_ISLNK(sbp->st_mode))

(((( sbp->st_m... == (0120000))	Description
TRUE	evaluated 583 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 457461 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

583-457461

1851

return (FTS_SL);

executed 583 times by 6 tests: return (12);

Executed by:

chgrp
chmod
chown
du
mv
rm

583

1852

if (S_ISREG(sbp->st_mode))

(((( sbp->st_m... == (0100000))	Description
TRUE	evaluated 457434 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 27 times by 3 tests Evaluated by: chgrp chmod mv

27-457434

1853

return (FTS_F);

executed 457434 times by 6 tests: return (8);

Executed by:

chgrp
chmod
chown
du
mv
rm

457434

1854

return (FTS_DEFAULT);

executed 27 times by 3 tests: return (3);

Executed by:

chgrp
chmod
mv

27

1855

}

-

1856

-

1857

static int

-

1858

fts_compar (void const *a, void const *b)

-

1859

{

-

1860

/* Convert A and B to the correct types, to pacify the compiler, and

-

1861

for portability to bizarre hosts where "void const *" and "FTSENT

-

1862

const **" differ in runtime representation. The comparison

-

1863

function cannot modify *a and *b, but there is no compile-time

-

1864

check for this. */

-

1865

FTSENT const **pa = (FTSENT const **) a;

-

1866

FTSENT const **pb = (FTSENT const **) b;

-

1867

return pa[0]->fts_fts->fts_compar (pa, pb);

never executed: return pa[0]->fts_fts->fts_compar (pa, pb);

0

1868

}

-

1869

-

1870

static FTSENT *

-

1871

internal_function

-

1872

fts_sort (FTS *sp, FTSENT *head, register size_t nitems)

-

1873

{

-

1874

register FTSENT **ap, *p;

-

1875

-

1876

/* On most modern hosts, void * and FTSENT ** have the same

-

1877

run-time representation, and one can convert sp->fts_compar to

-

1878

the type qsort expects without problem. Use the heuristic that

-

1879

this is OK if the two pointer types are the same size, and if

-

1880

converting FTSENT ** to long int is the same as converting

-

1881

FTSENT ** to void * and then to long int. This heuristic isn't

-

1882

valid in general but we don't know of any counterexamples. */

-

1883

FTSENT *dummy;

-

1884

int (*compare) (void const *, void const *) =

-

1885

((sizeof &dummy == sizeof (void *)

sizeof &dummy ...izeof (void *)	Description
TRUE	evaluated 14 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-14

1886

&& (long int) &dummy == (long int) (void *) &dummy)

(long int) &du...void *) &dummy	Description
TRUE	evaluated 14 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

0-14

1887

? (int (*) (void const *, void const *)) sp->fts_compar

-

1888

: fts_compar);

-

1889

-

1890

/*

-

1891

* Construct an array of pointers to the structures and call qsort(3).

-

1892

* Reassemble the array in the order returned by qsort. If unable to

-

1893

* sort for memory reasons, return the directory entries in their

-

1894

* current order. Allocate enough space for the current needs plus

-

1895

* 40 so don't realloc one entry at a time.

-

1896

*/

-

1897

if (nitems > sp->fts_nitems) {

nitems > sp->fts_nitems	Description
TRUE	evaluated 5 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 9 times by 3 tests Evaluated by: chmod du rm

5-9

1898

FTSENT **a;

-

1899

-

1900

sp->fts_nitems = nitems + 40;

-

1901

if (SIZE_MAX / sizeof *a < sp->fts_nitems

(1844674407370...sp->fts_nitems	Description
TRUE	never evaluated
FALSE	evaluated 5 times by 3 tests Evaluated by: chmod du rm

0-5

1902

|| ! (a = realloc (sp->fts_array,

! (a = realloc... * sizeof *a))	Description
TRUE	never evaluated
FALSE	evaluated 5 times by 3 tests Evaluated by: chmod du rm

0-5

1903

sp->fts_nitems * sizeof *a))) {

! (a = realloc... * sizeof *a))	Description
TRUE	never evaluated
FALSE	evaluated 5 times by 3 tests Evaluated by: chmod du rm

0-5

1904

free(sp->fts_array);

-

1905

sp->fts_array = NULL;

-

1906

sp->fts_nitems = 0;

-

1907

return (head);

never executed: return (head);

0

1908

}

-

1909

sp->fts_array = a;

-

1910

}

executed 5 times by 3 tests: end of block

Executed by:

chmod
du
rm

5

1911

for (ap = sp->fts_array, p = head; p; p = p->fts_link)

p	Description
TRUE	evaluated 760000 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 14 times by 3 tests Evaluated by: chmod du rm

14-760000

1912

*ap++ = p;

executed 760000 times by 3 tests: *ap++ = p;

Executed by:

chmod
du
rm

760000

1913

qsort((void *)sp->fts_array, nitems, sizeof(FTSENT *), compare);

-

1914

for (head = *(ap = sp->fts_array); --nitems; ++ap)

--nitems	Description
TRUE	evaluated 759986 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 14 times by 3 tests Evaluated by: chmod du rm

14-759986

1915

ap[0]->fts_link = ap[1];

executed 759986 times by 3 tests: ap[0]->fts_link = ap[1];

Executed by:

chmod
du
rm

759986

1916

ap[0]->fts_link = NULL;

-

1917

return (head);

executed 14 times by 3 tests: return (head);

Executed by:

chmod
du
rm

14

1918

}

-

1919

-

1920

static FTSENT *

-

1921

internal_function

-

1922

fts_alloc (FTS *sp, const char *name, register size_t namelen)

-

1923

{

-

1924

register FTSENT *p;

-

1925

size_t len;

-

1926

-

1927

/*

-

1928

* The file name is a variable length array. Allocate the FTSENT

-

1929

* structure and the file name in one chunk.

-

1930

*/

-

1931

len = FLEXSIZEOF(FTSENT, fts_name, namelen + 1);

-

1932

if ((p = malloc(len)) == NULL)

(p = malloc(le...== ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 822252 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-822252

1933

return (NULL);

never executed: return ( ((void *)0) );

0

1934

-

1935

/* Copy the name and guarantee NUL termination. */

-

1936

memcpy(p->fts_name, name, namelen);

-

1937

p->fts_name[namelen] = '\0';

-

1938

-

1939

p->fts_namelen = namelen;

-

1940

p->fts_fts = sp;

-

1941

p->fts_path = sp->fts_path;

-

1942

p->fts_errno = 0;

-

1943

p->fts_dirp = NULL;

-

1944

p->fts_flags = 0;

-

1945

p->fts_instr = FTS_NOINSTR;

-

1946

p->fts_number = 0;

-

1947

p->fts_pointer = NULL;

-

1948

return (p);

executed 822252 times by 6 tests: return (p);

Executed by:

chgrp
chmod
chown
du
mv
rm

822252

1949

}

-

1950

-

1951

static void

-

1952

internal_function

-

1953

fts_lfree (register FTSENT *head)

-

1954

{

-

1955

register FTSENT *p;

-

1956

-

1957

/* Free a linked list of structures. */

-

1958

while ((p = head)) {

(p = head)	Description
TRUE	never evaluated
FALSE	evaluated 40632 times by 3 tests Evaluated by: chmod du rm

0-40632

1959

head = head->fts_link;

-

1960

if (p->fts_dirp)

p->fts_dirp	Description
TRUE	never evaluated
FALSE	never evaluated

0

1961

closedir (p->fts_dirp);

never executed: closedir (p->fts_dirp);

0

1962

free(p);

-

1963

}

never executed: end of block

0

1964

}

executed 40632 times by 3 tests: end of block

Executed by:

chmod
du
rm

40632

1965

-

1966

/*

-

1967

* Allow essentially unlimited file name lengths; find, rm, ls should

-

1968

* all work on any tree. Most systems will allow creation of file

-

1969

* names much longer than MAXPATHLEN, even though the kernel won't

-

1970

* resolve them. Add the size (not just what's needed) plus 256 bytes

-

1971

* so don't realloc the file name 2 bytes at a time.

-

1972

*/

-

1973

static bool

-

1974

internal_function

-

1975

fts_palloc (FTS *sp, size_t more)

-

1976

{

-

1977

char *p;

-

1978

size_t new_len = sp->fts_pathlen + more + 256;

-

1979

-

1980

/*

-

1981

* See if fts_pathlen would overflow.

-

1982

*/

-

1983

if (new_len < sp->fts_pathlen) {

new_len < sp->fts_pathlen	Description
TRUE	never evaluated
FALSE	evaluated 6827 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6827

1984

free(sp->fts_path);

-

1985

sp->fts_path = NULL;

-

1986

__set_errno (ENAMETOOLONG);

-

1987

return false;

never executed: return 0 ;

0

1988

}

-

1989

sp->fts_pathlen = new_len;

-

1990

p = realloc(sp->fts_path, sp->fts_pathlen);

-

1991

if (p == NULL) {

p == ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 6827 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-6827

1992

free(sp->fts_path);

-

1993

sp->fts_path = NULL;

-

1994

return false;

never executed: return 0 ;

0

1995

}

-

1996

sp->fts_path = p;

-

1997

return true;

executed 6827 times by 6 tests: return 1 ;

Executed by:

chgrp
chmod
chown
du
mv
rm

6827

1998

}

-

1999

-

2000

/*

-

2001

* When the file name is realloc'd, have to fix all of the pointers in

-

2002

* structures already returned.

-

2003

*/

-

2004

static void

-

2005

internal_function

-

2006

fts_padjust (FTS *sp, FTSENT *head)

-

2007

{

-

2008

FTSENT *p;

-

2009

char *addr = sp->fts_path;

-

2010

-

2011

#define ADJUST(p) do { \

-

2012

if ((p)->fts_accpath != (p)->fts_name) { \

-

2013

(p)->fts_accpath = \

-

2014

(char *)addr + ((p)->fts_accpath - (p)->fts_path); \

-

2015

} \

-

2016

(p)->fts_path = addr; \

-

2017

} while (0)

-

2018

/* Adjust the current set of children. */

-

2019

for (p = sp->fts_child; p; p = p->fts_link)

p	Description
TRUE	never evaluated
FALSE	evaluated 7 times by 3 tests Evaluated by: chmod du rm

0-7

2020

ADJUST(p);

never executed: end of block

(p)->fts_accpa... (p)->fts_name	Description
TRUE	never evaluated
FALSE	never evaluated

0

2021

-

2022

/* Adjust the rest of the tree, including the current level. */

-

2023

for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {

p->fts_level >= 0	Description
TRUE	evaluated 340 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 7 times by 3 tests Evaluated by: chmod du rm

7-340

2024

ADJUST(p);

executed 7 times by 3 tests: end of block

Executed by:

chmod
du
rm

(p)->fts_accpa... (p)->fts_name	Description
TRUE	evaluated 7 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 333 times by 3 tests Evaluated by: chmod du rm

7-333

2025

p = p->fts_link ? p->fts_link : p->fts_parent;

p->fts_link	Description
TRUE	never evaluated
FALSE	evaluated 340 times by 3 tests Evaluated by: chmod du rm

0-340

2026

}

executed 340 times by 3 tests: end of block

Executed by:

chmod
du
rm

340

2027

}

executed 7 times by 3 tests: end of block

Executed by:

chmod
du
rm

7

2028

-

2029

static size_t

-

2030

internal_function _GL_ATTRIBUTE_PURE

-

2031

fts_maxarglen (char * const *argv)

-

2032

{

-

2033

size_t len, max;

-

2034

-

2035

for (max = 0; *argv; ++argv)

*argv	Description
TRUE	evaluated 7918 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 6820 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

6820-7918

2036

if ((len = strlen(*argv)) > max)

(len = strlen(*argv)) > max	Description
TRUE	evaluated 7193 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	evaluated 725 times by 3 tests Evaluated by: chgrp chmod rm

725-7193

2037

max = len;

executed 7193 times by 6 tests: max = len;

Executed by:

chgrp
chmod
chown
du
mv
rm

7193

2038

return (max + 1);

executed 6820 times by 6 tests: return (max + 1);

Executed by:

chgrp
chmod
chown
du
mv
rm

6820

2039

}

-

2040

-

2041

/*

-

2042

* Change to dir specified by fd or file name without getting

-

2043

* tricked by someone changing the world out from underneath us.

-

2044

* Assumes p->fts_statp->st_dev and p->fts_statp->st_ino are filled in.

-

2045

* If FD is non-negative, expect it to be used after this function returns,

-

2046

* and to be closed eventually. So don't pass e.g., 'dirfd(dirp)' and then

-

2047

* do closedir(dirp), because that would invalidate the saved FD.

-

2048

* Upon failure, close FD immediately and return nonzero.

-

2049

*/

-

2050

static int

-

2051

internal_function

-

2052

fts_safe_changedir (FTS *sp, FTSENT *p, int fd, char const *dir)

-

2053

{

-

2054

int ret;

-

2055

bool is_dotdot = dir && STREQ (dir, "..");

never executed: __result = (((const unsigned char *) (const char *) ( dir ))[3] - __s2[3]);

never executed: end of block

never executed: __result = (((const unsigned char *) (const char *) ( ".." ))[3] - __s2[3]);

executed 56225 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

executed 56225 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

dir	Description
TRUE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	evaluated 61084 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

( __extension_...)))); }) == 0)	Description
TRUE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

__s1_len > 0	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s1_len > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s1_len > 2	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s2_len > 0	Description
TRUE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

__result == 0	Description
TRUE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

__s2_len > 1	Description
TRUE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

__result == 0	Description
TRUE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

__s2_len > 2	Description
TRUE	never evaluated
FALSE	evaluated 56225 times by 5 tests Evaluated by: chgrp chmod du mv rm

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0-61084

2056

int newfd;

-

2057

-

2058

/* This clause handles the unusual case in which FTS_NOCHDIR

-

2059

is specified, along with FTS_CWDFD. In that case, there is

-

2060

no need to change even the virtual cwd file descriptor.

-

2061

However, if FD is non-negative, we do close it here. */

-

2062

if (ISSET (FTS_NOCHDIR))

(sp->fts_options & (0x0004))	Description
TRUE	evaluated 101 times by 3 tests Evaluated by: chgrp chown du
FALSE	evaluated 117208 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

101-117208

2063

{

-

2064

if (ISSET (FTS_CWDFD) && 0 <= fd)

(sp->fts_options & (0x0200))	Description
TRUE	never evaluated
FALSE	evaluated 101 times by 3 tests Evaluated by: chgrp chown du

0 <= fd	Description
TRUE	never evaluated
FALSE	never evaluated

0-101

2065

close (fd);

never executed: close (fd);

0

2066

return 0;

executed 101 times by 3 tests: return 0;

Executed by:

chgrp
chown
du

101

2067

}

-

2068

-

2069

if (fd < 0 && is_dotdot && ISSET (FTS_CWDFD))

fd < 0	Description
TRUE	evaluated 56180 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	evaluated 61028 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

is_dotdot	Description
TRUE	evaluated 56180 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 56180 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

0-61028

2070

{

-

2071

/* When possible, skip the diropen and subsequent fstat+dev/ino

-

2072

comparison. I.e., when changing to parent directory

-

2073

(chdir ("..")), use a file descriptor from the ring and

-

2074

save the overhead of diropen+fstat, as well as avoiding

-

2075

failure when we lack "x" access to the virtual cwd. */

-

2076

if ( ! i_ring_empty (&sp->fts_fd_ring))

! i_ring_empty...->fts_fd_ring)	Description
TRUE	evaluated 41989 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm

14191-41989

2077

{

-

2078

int parent_fd;

-

2079

fd_ring_print (sp, stderr, "pre-pop");

-

2080

parent_fd = i_ring_pop (&sp->fts_fd_ring);

-

2081

is_dotdot = true;

-

2082

if (0 <= parent_fd)

0 <= parent_fd	Description
TRUE	evaluated 41989 times by 5 tests Evaluated by: chgrp chmod du mv rm
FALSE	never evaluated

0-41989

2083

{

-

2084

fd = parent_fd;

-

2085

dir = NULL;

-

2086

}

executed 41989 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

41989

2087

}

executed 41989 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

41989

2088

}

executed 56180 times by 5 tests: end of block

Executed by:

chgrp
chmod
du
mv
rm

56180

2089

-

2090

newfd = fd;

-

2091

if (fd < 0 && (newfd = diropen (sp, dir)) < 0)

fd < 0	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 103017 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

(newfd = dirop...(sp, dir)) < 0	Description
TRUE	never evaluated
FALSE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm

0-103017

2092

return -1;

never executed: return -1;

0

2093

-

2094

/* The following dev/inode check is necessary if we're doing a

-

2095

"logical" traversal (through symlinks, a la chown -L), if the

-

2096

system lacks O_NOFOLLOW support, or if we're changing to ".."

-

2097

(but not via a popped file descriptor). When changing to the

-

2098

name "..", O_NOFOLLOW can't help. In general, when the target is

-

2099

not "..", diropen's use of O_NOFOLLOW ensures we don't mistakenly

-

2100

follow a symlink, so we can avoid the expense of this fstat. */

-

2101

if (ISSET(FTS_LOGICAL) || ! HAVE_WORKING_O_NOFOLLOW

(sp->fts_options & (0x0002))	Description
TRUE	never evaluated
FALSE	evaluated 117208 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

0-117208

2102

|| (dir && STREQ (dir, "..")))

never executed: __result = (((const unsigned char *) (const char *) ( dir ))[3] - __s2[3]);

never executed: end of block

never executed: __result = (((const unsigned char *) (const char *) ( ".." ))[3] - __s2[3]);

executed 14191 times by 3 tests: end of block

Executed by:

chmod
du
rm

executed 14191 times by 3 tests: end of block

Executed by:

chmod
du
rm

dir	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	evaluated 103017 times by 6 tests Evaluated by: chgrp chmod chown du mv rm

( __extension_...)))); }) == 0)	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

__s1_len > 0	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s1_len > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s1_len > 2	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s2_len > 0	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

__result == 0	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

__s2_len > 1	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

__result == 0	Description
TRUE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm
FALSE	never evaluated

__s2_len > 2	Description
TRUE	never evaluated
FALSE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0-103017

2103

{

-

2104

struct stat sb;

-

2105

if (fstat(newfd, &sb))

fstat(newfd, &sb)	Description
TRUE	never evaluated
FALSE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm

0-14191

2106

{

-

2107

ret = -1;

-

2108

goto bail;

never executed: goto bail;

0

2109

}

-

2110

if (p->fts_statp->st_dev != sb.st_dev

p->fts_statp->...v != sb.st_dev	Description
TRUE	never evaluated
FALSE	evaluated 14191 times by 3 tests Evaluated by: chmod du rm

0-14191

2111

|| p->fts_statp->st_ino != sb.st_ino)

p->fts_statp->...o != sb.st_ino	Description
TRUE	evaluated 1 time by 1 test Evaluated by: du
FALSE	evaluated 14190 times by 3 tests Evaluated by: chmod du rm

1-14190

2112

{

-

2113

__set_errno (ENOENT); /* disinformation */

-

2114

ret = -1;

-

2115

goto bail;

executed 1 time by 1 test: goto bail;

Executed by:

du

1

2116

}

-

2117

}

executed 14190 times by 3 tests: end of block

Executed by:

chmod
du
rm

14190

2118

-

2119

if (ISSET(FTS_CWDFD))

(sp->fts_options & (0x0200))	Description
TRUE	evaluated 117207 times by 6 tests Evaluated by: chgrp chmod chown du mv rm
FALSE	never evaluated

0-117207

2120

{

-

2121

cwd_advance_fd (sp, newfd, ! is_dotdot);

-

2122

return 0;

executed 117207 times by 6 tests: return 0;

Executed by:

chgrp
chmod
chown
du
mv
rm

117207

2123

}

-

2124

-

2125

ret = fchdir(newfd);

-

2126

bail:

code before this statement never executed: bail:

0

2127

if (fd < 0)

fd < 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: du
FALSE	never evaluated

0-1

2128

{

-

2129

int oerrno = errno;

-

2130

(void)close(newfd);

-

2131

__set_errno (oerrno);

-

2132

}

executed 1 time by 1 test: end of block

Executed by:

du

1

2133

return ret;

executed 1 time by 1 test: return ret;

Executed by:

du

1

2134

}

-