~ubuntu-branches/ubuntu/quantal/unzip/quantal-proposed : revision 22

1

/*

2

3

4

See the accompanying file LICENSE, version 2009-Jan-02 or later

5

(the contents of which are also included in unzip.h) for terms of use.

6

If, for some reason, all these files are missing, the Info-ZIP license

7

also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html

8

*/

9

/*---------------------------------------------------------------------------

10

11

unix.c

12

13

Unix-specific routines for use with Info-ZIP's UnZip 5.41 and later.

14

15

Contains: readdir()

16

do_wild() <-- generic enough to put in fileio.c?

17

mapattr()

18

mapname()

19

checkdir()

20

mkdir()

21

close_outfile()

22

defer_dir_attribs()

23

set_direc_attribs()

24

stamp_file()

25

version()

26

27

---------------------------------------------------------------------------*/

28

29

30

#define UNZIP_INTERNAL

31

#include "unzip.h"

32

33

#ifdef SCO_XENIX

34

# define SYSNDIR

35

#else /* SCO Unix, AIX, DNIX, TI SysV, Coherent 4.x, ... */

36

# if defined(__convexc__) || defined(SYSV) || defined(CRAY) || defined(BSD4_4)

37

# define DIRENT

38

# endif

39

#endif

40

#if defined(_AIX) || defined(__mpexl)

41

# define DIRENT

42

#endif

43

#ifdef COHERENT

44

# if defined(_I386) || (defined(__COHERENT__) && (__COHERENT__ >= 0x420))

45

# define DIRENT

46

# endif

47

#endif

48

49

#ifdef _POSIX_VERSION

50

# ifndef DIRENT

51

# define DIRENT

52

# endif

53

#endif

54

55

#ifdef DIRENT

56

# include <dirent.h>

57

#else

58

# ifdef SYSV

59

# ifdef SYSNDIR

60

# include <sys/ndir.h>

61

# else

62

# include <ndir.h>

63

# endif

64

# else /* !SYSV */

65

# ifndef NO_SYSDIR

66

# include <sys/dir.h>

67

# endif

68

# endif /* ?SYSV */

69

# ifndef dirent

70

# define dirent direct

71

# endif

72

#endif /* ?DIRENT */

73

74

#ifdef SET_DIR_ATTRIB

75

typedef struct uxdirattr { /* struct for holding unix style directory */

76

struct uxdirattr *next; /* info until can be sorted and set at end */

77

char *fn; /* filename of directory */

78

union {

79

iztimes t3; /* mtime, atime, ctime */

80

ztimbuf t2; /* modtime, actime */

81

} u;

82

unsigned perms; /* same as min_info.file_attr */

83

int have_uidgid; /* flag */

84

ulg uidgid[2];

85

char fnbuf[1]; /* buffer stub for directory name */

86

} uxdirattr;

87

#define UxAtt(d) ((uxdirattr *)d) /* typecast shortcut */

88

#endif /* SET_DIR_ATTRIB */

89

90

#ifdef ACORN_FTYPE_NFS

91

/* Acorn bits for NFS filetyping */

92

typedef struct {

93

uch ID[2];

94

uch size[2];

95

uch ID_2[4];

96

uch loadaddr[4];

97

uch execaddr[4];

98

uch attr[4];

99

} RO_extra_block;

100

101

#endif /* ACORN_FTYPE_NFS */

102

103

/* static int created_dir; */ /* used in mapname(), checkdir() */

104

/* static int renamed_fullpath; */ /* ditto */

105

106

static unsigned filtattr OF((__GPRO__ unsigned perms));

107

108

109

/*****************************/

110

/* Strings used multiple */

111

/* times in unix.c */

112

/*****************************/

113

114

#ifndef MTS

115

/* messages of code for setting file/directory attributes */

116

static ZCONST char CannotSetItemUidGid[] =

117

"warning: cannot set UID %lu and/or GID %lu for %s\n %s\n";

118

static ZCONST char CannotSetUidGid[] =

119

" (warning) cannot set UID %lu and/or GID %lu\n %s";

120

static ZCONST char CannotSetItemTimestamps[] =

121

"warning: cannot set modif./access times for %s\n %s\n";

122

static ZCONST char CannotSetTimestamps[] =

123

" (warning) cannot set modif./access times\n %s";

124

#endif /* !MTS */

125

126

127

#ifndef SFX

128

#ifdef NO_DIR /* for AT&T 3B1 */

129

130

#define opendir(path) fopen(path,"r")

131

#define closedir(dir) fclose(dir)

132

typedef FILE DIR;

133

typedef struct zdir {

134

FILE *dirhandle;

135

struct dirent *entry;

136

} DIR

137

DIR *opendir OF((ZCONST char *dirspec));

138

void closedir OF((DIR *dirp));

139

struct dirent *readdir OF((DIR *dirp));

140

141

DIR *opendir(dirspec)

142

ZCONST char *dirspec;

143

{

144

DIR *dirp;

145

146

if ((dirp = malloc(sizeof(DIR)) != NULL) {

147

if ((dirp->dirhandle = fopen(dirspec, "r")) == NULL) {

148

free(dirp);

149

dirp = NULL;

150

}

151

}

152

return dirp;

153

}

154

155

void closedir(dirp)

156

DIR *dirp;

157

{

158

fclose(dirp->dirhandle);

159

free(dirp);

160

}

161

162

/*

163

* Apparently originally by Rich Salz.

164

* Cleaned up and modified by James W. Birdsall.

165

*/

166

struct dirent *readdir(dirp)

167

DIR *dirp;

168

{

169

170

if (dirp == NULL)

171

return NULL;

172

173

for (;;)

174

if (fread(&(dirp->entry), sizeof (struct dirent), 1,

175

dirp->dirhandle) == 0)

176

return (struct dirent *)NULL;

177

else if ((dirp->entry).d_ino)

178

return &(dirp->entry);

179

180

} /* end function readdir() */

181

182

#endif /* NO_DIR */

183

184

185

/**********************/

186

/* Function do_wild() */ /* for porting: dir separator; match(ignore_case) */

187

/**********************/

188

189

char *do_wild(__G__ wildspec)

190

__GDEF

191

ZCONST char *wildspec; /* only used first time on a given dir */

192

{

193

/* these statics are now declared in SYSTEM_SPECIFIC_GLOBALS in unxcfg.h:

194

static DIR *wild_dir = (DIR *)NULL;

195

static ZCONST char *wildname;

196

static char *dirname, matchname[FILNAMSIZ];

197

static int notfirstcall=FALSE, have_dirname, dirnamelen;

198

*/

199

struct dirent *file;

200

201

/* Even when we're just returning wildspec, we *always* do so in

202

* matchname[]--calling routine is allowed to append four characters

203

* to the returned string, and wildspec may be a pointer to argv[].

204

*/

205

if (!G.notfirstcall) { /* first call: must initialize everything */

206

G.notfirstcall = TRUE;

207

208

if (!iswild(wildspec)) {

209

strncpy(G.matchname, wildspec, FILNAMSIZ);

210

G.matchname[FILNAMSIZ-1] = '\0';

211

G.have_dirname = FALSE;

212

G.wild_dir = NULL;

213

return G.matchname;

214

}

215

216

/* break the wildspec into a directory part and a wildcard filename */

217

if ((G.wildname = (ZCONST char *)strrchr(wildspec, '/')) == NULL) {

218

G.dirname = ".";

219

G.dirnamelen = 1;

220

G.have_dirname = FALSE;

221

G.wildname = wildspec;

222

} else {

223

++G.wildname; /* point at character after '/' */

224

G.dirnamelen = G.wildname - wildspec;

225

if ((G.dirname = (char *)malloc(G.dirnamelen+1)) == (char *)NULL) {

226

Info(slide, 0x201, ((char *)slide,

227

"warning: cannot allocate wildcard buffers\n"));

228

strncpy(G.matchname, wildspec, FILNAMSIZ);

229

G.matchname[FILNAMSIZ-1] = '\0';

230

return G.matchname; /* but maybe filespec was not a wildcard */

231

}

232

strncpy(G.dirname, wildspec, G.dirnamelen);

233

G.dirname[G.dirnamelen] = '\0'; /* terminate for strcpy below */

234

G.have_dirname = TRUE;

235

}

236

237

if ((G.wild_dir = (zvoid *)opendir(G.dirname)) != (zvoid *)NULL) {

238

while ((file = readdir((DIR *)G.wild_dir)) !=

239

(struct dirent *)NULL) {

240

Trace((stderr, "do_wild: readdir returns %s\n",

241

FnFilter1(file->d_name)));

242

if (file->d_name[0] == '.' && G.wildname[0] != '.')

243

continue; /* Unix: '*' and '?' do not match leading dot */

244

if (match(file->d_name, G.wildname, 0 WISEP) &&/*0=case sens.*/

245

/* skip "." and ".." directory entries */

246

strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) {

247

Trace((stderr, "do_wild: match() succeeds\n"));

248

if (G.have_dirname) {

249

strcpy(G.matchname, G.dirname);

250

strcpy(G.matchname+G.dirnamelen, file->d_name);

251

} else

252

strcpy(G.matchname, file->d_name);

253

return G.matchname;

254

}

255

}

256

/* if we get to here directory is exhausted, so close it */

257

closedir((DIR *)G.wild_dir);

258

G.wild_dir = (zvoid *)NULL;

259

}

260

Trace((stderr, "do_wild: opendir(%s) returns NULL\n",

261

FnFilter1(G.dirname)));

262

263

/* return the raw wildspec in case that works (e.g., directory not

264

* searchable, but filespec was not wild and file is readable) */

265

strncpy(G.matchname, wildspec, FILNAMSIZ);

266

G.matchname[FILNAMSIZ-1] = '\0';

267

return G.matchname;

268

}

269

270

/* last time through, might have failed opendir but returned raw wildspec */

271

if ((DIR *)G.wild_dir == (DIR *)NULL) {

272

G.notfirstcall = FALSE; /* nothing left--reset for new wildspec */

273

if (G.have_dirname)

274

free(G.dirname);

275

return (char *)NULL;

276

}

277

278

/* If we've gotten this far, we've read and matched at least one entry

279

* successfully (in a previous call), so dirname has been copied into

280

* matchname already.

281

*/

282

while ((file = readdir((DIR *)G.wild_dir)) != (struct dirent *)NULL) {

283

Trace((stderr, "do_wild: readdir returns %s\n",

284

FnFilter1(file->d_name)));

285

if (file->d_name[0] == '.' && G.wildname[0] != '.')

286

continue; /* Unix: '*' and '?' do not match leading dot */

287

if (match(file->d_name, G.wildname, 0 WISEP)) { /* 0 == case sens. */

288

Trace((stderr, "do_wild: match() succeeds\n"));

289

if (G.have_dirname) {

290

/* strcpy(G.matchname, G.dirname); */

291

strcpy(G.matchname+G.dirnamelen, file->d_name);

292

} else

293

strcpy(G.matchname, file->d_name);

294

return G.matchname;

295

}

296

}

297

298

closedir((DIR *)G.wild_dir); /* at least one entry read; nothing left */

299

G.wild_dir = (zvoid *)NULL;

300

G.notfirstcall = FALSE; /* reset for new wildspec */

301

if (G.have_dirname)

302

free(G.dirname);

303

return (char *)NULL;

304

305

} /* end function do_wild() */

306

307

#endif /* !SFX */

308

309

310

311

312

#ifndef S_ISUID

313

# define S_ISUID 0004000 /* set user id on execution */

314

#endif

315

#ifndef S_ISGID

316

# define S_ISGID 0002000 /* set group id on execution */

317

#endif

318

#ifndef S_ISVTX

319

# define S_ISVTX 0001000 /* save swapped text even after use */

320

#endif

321

322

/************************/

323

/* Function filtattr() */

324

/************************/

325

/* This is used to clear or keep the SUID and SGID bits on file permissions.

326

* It's possible that a file in an archive could have one of these bits set

327

* and, unknown to the person unzipping, could allow others to execute the

328

* file as the user or group. The new option -K bypasses this check.

329

*/

330

331

static unsigned filtattr(__G__ perms)

332

__GDEF

333

unsigned perms;

334

{

335

/* keep setuid/setgid/tacky perms? */

336

if (!uO.K_flag)

337

perms &= ~(S_ISUID | S_ISGID | S_ISVTX);

338

339

return (0xffff & perms);

340

} /* end function filtattr() */

341

342

343

344

345

346

/**********************/

347

/* Function mapattr() */

348

/**********************/

349

350

int mapattr(__G)

351

__GDEF

352

{

353

int r;

354

ulg tmp = G.crec.external_file_attributes;

355

356

G.pInfo->file_attr = 0;

357

/* initialized to 0 for check in "default" branch below... */

358

359

switch (G.pInfo->hostnum) {

360

case AMIGA_:

361

tmp = (unsigned)(tmp>>17 & 7); /* Amiga RWE bits */

362

G.pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp);

363

break;

364

case THEOS_:

365

tmp &= 0xF1FFFFFFL;

366

if ((tmp & 0xF0000000L) != 0x40000000L)

367

tmp &= 0x01FFFFFFL; /* not a dir, mask all ftype bits */

368

else

369

tmp &= 0x41FFFFFFL; /* leave directory bit as set */

370

/* fall through! */

371

case UNIX_:

372

case VMS_:

373

case ACORN_:

374

case ATARI_:

375

case ATHEOS_:

376

case BEOS_:

377

case QDOS_:

378

case TANDEM_:

379

r = FALSE;

380

G.pInfo->file_attr = (unsigned)(tmp >> 16);

381

if (G.pInfo->file_attr == 0 && G.extra_field) {

382

/* Some (non-Info-ZIP) implementations of Zip for Unix and

383

* VMS (and probably others ??) leave 0 in the upper 16-bit

384

* part of the external_file_attributes field. Instead, they

385

* store file permission attributes in some extra field.

386

* As a work-around, we search for the presence of one of

387

* these extra fields and fall back to the MSDOS compatible

388

* part of external_file_attributes if one of the known

389

* e.f. types has been detected.

390

* Later, we might implement extraction of the permission

391

* bits from the VMS extra field. But for now, the work-around

392

* should be sufficient to provide "readable" extracted files.

393

* (For ASI Unix e.f., an experimental remap of the e.f.

394

* mode value IS already provided!)

395

*/

396

ush ebID;

397

unsigned ebLen;

398

uch *ef = G.extra_field;

399

unsigned ef_len = G.crec.extra_field_length;

400

401

while (!r && ef_len >= EB_HEADSIZE) {

402

ebID = makeword(ef);

403

ebLen = (unsigned)makeword(ef+EB_LEN);

404

if (ebLen > (ef_len - EB_HEADSIZE))

405

/* discoverd some e.f. inconsistency! */

406

break;

407

switch (ebID) {

408

case EF_ASIUNIX:

409

if (ebLen >= (EB_ASI_MODE+2)) {

410

G.pInfo->file_attr =

411

(unsigned)makeword(ef+(EB_HEADSIZE+EB_ASI_MODE));

412

/* force stop of loop: */

413

ef_len = (ebLen + EB_HEADSIZE);

414

break;

415

}

416

/* else: fall through! */

417

case EF_PKVMS:

418

/* "found nondecypherable e.f. with perm. attr" */

419

r = TRUE;

420

default:

421

break;

422

}

423

ef_len -= (ebLen + EB_HEADSIZE);

424

ef += (ebLen + EB_HEADSIZE);

425

}

426

}

427

if (!r) {

428

#ifdef SYMLINKS

429

/* Check if the file is a (POSIX-compatible) symbolic link.

430

* We restrict symlink support to those "made-by" hosts that

431

* are known to support symbolic links.

432

*/

433

G.pInfo->symlink = S_ISLNK(G.pInfo->file_attr) &&

434

SYMLINK_HOST(G.pInfo->hostnum);

435

#endif

436

return 0;

437

}

438

/* fall through! */

439

/* all remaining cases: expand MSDOS read-only bit into write perms */

440

case FS_FAT_:

441

/* PKWARE's PKZip for Unix marks entries as FS_FAT_, but stores the

442

* Unix attributes in the upper 16 bits of the external attributes

443

* field, just like Info-ZIP's Zip for Unix. We try to use that

444

* value, after a check for consistency with the MSDOS attribute

445

* bits (see below).

446

*/

447

G.pInfo->file_attr = (unsigned)(tmp >> 16);

448

/* fall through! */

449

case FS_HPFS_:

450

case FS_NTFS_:

451

case MAC_:

452

case TOPS20_:

453

default:

454

/* Ensure that DOS subdir bit is set when the entry's name ends

455

* in a '/'. Some third-party Zip programs fail to set the subdir

456

* bit for directory entries.

457

*/

458

if ((tmp & 0x10) == 0) {

459

extent fnlen = strlen(G.filename);

460

if (fnlen > 0 && G.filename[fnlen-1] == '/')

461

tmp |= 0x10;

462

}

463

/* read-only bit --> write perms; subdir bit --> dir exec bit */

464

tmp = !(tmp & 1) << 1 | (tmp & 0x10) >> 4;

465

if ((G.pInfo->file_attr & 0700) == (unsigned)(0400 | tmp<<6)) {

466

/* keep previous G.pInfo->file_attr setting, when its "owner"

467

* part appears to be consistent with DOS attribute flags!

468

*/

469

#ifdef SYMLINKS

470

/* Entries "made by FS_FAT_" could have been zipped on a

471

* system that supports POSIX-style symbolic links.

472

*/

473

G.pInfo->symlink = S_ISLNK(G.pInfo->file_attr) &&

474

(G.pInfo->hostnum == FS_FAT_);

475

#endif

476

return 0;

477

}

478

G.pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp);

479

break;

480

} /* end switch (host-OS-created-by) */

481

482

/* for originating systems with no concept of "group," "other," "system": */

483

umask( (int)(tmp=umask(0)) ); /* apply mask to expanded r/w(/x) perms */

484

G.pInfo->file_attr &= ~tmp;

485

486

return 0;

487

488

} /* end function mapattr() */

489

490

491

492

493

494

/************************/

495

/* Function mapname() */

496

/************************/

497

498

int mapname(__G__ renamed)

499

__GDEF

500

int renamed;

501

/*

502

* returns:

503

* MPN_OK - no problem detected

504

* MPN_INF_TRUNC - caution (truncated filename)

505

* MPN_INF_SKIP - info "skip entry" (dir doesn't exist)

506

* MPN_ERR_SKIP - error -> skip entry

507

* MPN_ERR_TOOLONG - error -> path is too long

508

* MPN_NOMEM - error (memory allocation failed) -> skip entry

509

* [also MPN_VOL_LABEL, MPN_CREATED_DIR]

510

*/

511

{

512

char pathcomp[FILNAMSIZ]; /* path-component buffer */

513

char *pp, *cp=(char *)NULL; /* character pointers */

514

char *lastsemi=(char *)NULL; /* pointer to last semi-colon in pathcomp */

515

#ifdef ACORN_FTYPE_NFS

516

char *lastcomma=(char *)NULL; /* pointer to last comma in pathcomp */

517

RO_extra_block *ef_spark; /* pointer Acorn FTYPE ef block */

518

#endif

519

int killed_ddot = FALSE; /* is set when skipping "../" pathcomp */

520

int error = MPN_OK;

521

register unsigned workch; /* hold the character being tested */

522

523

524

/*---------------------------------------------------------------------------

525

Initialize various pointers and counters and stuff.

526

---------------------------------------------------------------------------*/

527

528

if (G.pInfo->vollabel)

529

return MPN_VOL_LABEL; /* can't set disk volume labels in Unix */

530

531

/* can create path as long as not just freshening, or if user told us */

532

G.create_dirs = (!uO.fflag || renamed);

533

534

G.created_dir = FALSE; /* not yet */

535

536

/* user gave full pathname: don't prepend rootpath */

537

G.renamed_fullpath = (renamed && (*G.filename == '/'));

538

539

if (checkdir(__G__ (char *)NULL, INIT) == MPN_NOMEM)

540

return MPN_NOMEM; /* initialize path buffer, unless no memory */

541

542

*pathcomp = '\0'; /* initialize translation buffer */

543

pp = pathcomp; /* point to translation buffer */

544

if (uO.jflag) /* junking directories */

545

cp = (char *)strrchr(G.filename, '/');

546

if (cp == (char *)NULL) /* no '/' or not junking dirs */

547

cp = G.filename; /* point to internal zipfile-member pathname */

548

else

549

++cp; /* point to start of last component of path */

550

551

/*---------------------------------------------------------------------------

552

Begin main loop through characters in filename.

553

---------------------------------------------------------------------------*/

554

555

while ((workch = (uch)*cp++) != 0) {

556

557

switch (workch) {

558

case '/': /* can assume -j flag not given */

559

*pp = '\0';

560

if (strcmp(pathcomp, ".") == 0) {

561

/* don't bother appending "./" to the path */

562

*pathcomp = '\0';

563

} else if (!uO.ddotflag && strcmp(pathcomp, "..") == 0) {

564

/* "../" dir traversal detected, skip over it */

565

*pathcomp = '\0';

566

killed_ddot = TRUE; /* set "show message" flag */

567

}

568

/* when path component is not empty, append it now */

569

if (*pathcomp != '\0' &&

570

((error = checkdir(__G__ pathcomp, APPEND_DIR))

571

& MPN_MASK) > MPN_INF_TRUNC)

572

return error;

573

pp = pathcomp; /* reset conversion buffer for next piece */

574

lastsemi = (char *)NULL; /* leave direct. semi-colons alone */

575

break;

576

577

#ifdef __CYGWIN__ /* Cygwin runs on Win32, apply FAT/NTFS filename rules */

578

case ':': /* drive spec not stored, so no colon allowed */

579

case '\\': /* '\\' may come as normal filename char (not */

580

case '<': /* dir sep char!) from unix-like file system */

581

case '>': /* no redirection symbols allowed either */

582

case '|': /* no pipe signs allowed */

583

case '"': /* no double quotes allowed */

584

case '?': /* no wildcards allowed */

585

case '*':

586

*pp++ = '_'; /* these rules apply equally to FAT and NTFS */

587

break;

588

#endif

589

590

case ';': /* VMS version (or DEC-20 attrib?) */

591

lastsemi = pp;

592

*pp++ = ';'; /* keep for now; remove VMS ";##" */

593

break; /* later, if requested */

594

595

#ifdef ACORN_FTYPE_NFS

596

case ',': /* NFS filetype extension */

597

lastcomma = pp;

598

*pp++ = ','; /* keep for now; may need to remove */

599

break; /* later, if requested */

600

#endif

601

602

#ifdef MTS

603

case ' ': /* change spaces to underscore under */

604

*pp++ = '_'; /* MTS; leave as spaces under Unix */

605

break;

606

#endif

607

608

default:

609

/* disable control character filter when requested,

610

* else allow 8-bit characters (e.g. UTF-8) in filenames:

611

*/

612

if (uO.cflxflag ||

613

(isprint(workch) || (128 <= workch && workch <= 254)))

614

*pp++ = (char)workch;

615

} /* end switch */

616

617

} /* end while loop */

618

619

/* Show warning when stripping insecure "parent dir" path components */

620

if (killed_ddot && QCOND2) {

621

Info(slide, 0, ((char *)slide,

622

"warning: skipped \"../\" path component(s) in %s\n",

623

FnFilter1(G.filename)));

624

if (!(error & ~MPN_MASK))

625

error = (error & MPN_MASK) | PK_WARN;

626

}

627

628

/*---------------------------------------------------------------------------

629

Report if directory was created (and no file to create: filename ended

630

in '/'), check name to be sure it exists, and combine path and name be-

631

fore exiting.

632

---------------------------------------------------------------------------*/

633

634

if (G.filename[strlen(G.filename) - 1] == '/') {

635

checkdir(__G__ G.filename, GETPATH);

636

if (G.created_dir) {

637

if (QCOND2) {

638

Info(slide, 0, ((char *)slide, " creating: %s\n",

639

FnFilter1(G.filename)));

640

}

641

#ifndef NO_CHMOD

642

/* Filter out security-relevant attributes bits. */

643

G.pInfo->file_attr = filtattr(__G__ G.pInfo->file_attr);

644

/* When extracting non-UNIX directories or when extracting

645

* without UID/GID restoration or SGID preservation, any

646

* SGID flag inherited from the parent directory should be

647

* maintained to allow files extracted into this new folder

648

* to inherit the GID setting from the parent directory.

649

*/

650

if (G.pInfo->hostnum != UNIX_ || !(uO.X_flag || uO.K_flag)) {

651

/* preserve SGID bit when inherited from parent dir */

652

if (!SSTAT(G.filename, &G.statbuf)) {

653

G.pInfo->file_attr |= G.statbuf.st_mode & S_ISGID;

654

} else {

655

perror("Could not read directory attributes");

656

}

657

}

658

659

/* set approx. dir perms (make sure can still read/write in dir) */

660

if (chmod(G.filename, G.pInfo->file_attr | 0700))

661

perror("chmod (directory attributes) error");

662

#endif

663

/* set dir time (note trailing '/') */

664

return (error & ~MPN_MASK) | MPN_CREATED_DIR;

665

}

666

/* dir existed already; don't look for data to extract */

667

return (error & ~MPN_MASK) | MPN_INF_SKIP;

668

}

669

670

*pp = '\0'; /* done with pathcomp: terminate it */

671

672

/* if not saving them, remove VMS version numbers (appended ";###") */

673

if (!uO.V_flag && lastsemi) {

674

pp = lastsemi + 1;

675

while (isdigit((uch)(*pp)))

676

++pp;

677

if (*pp == '\0') /* only digits between ';' and end: nuke */

678

*lastsemi = '\0';

679

}

680

681

/* On UNIX (and compatible systems), "." and ".." are reserved for

682

* directory navigation and cannot be used as regular file names.

683

* These reserved one-dot and two-dot names are mapped to "_" and "__".

684

*/

685

if (strcmp(pathcomp, ".") == 0)

686

*pathcomp = '_';

687

else if (strcmp(pathcomp, "..") == 0)

688

strcpy(pathcomp, "__");

689

690

#ifdef ACORN_FTYPE_NFS

691

/* translate Acorn filetype information if asked to do so */

692

if (uO.acorn_nfs_ext &&

693

(ef_spark = (RO_extra_block *)

694

getRISCOSexfield(G.extra_field, G.lrec.extra_field_length))

695

!= (RO_extra_block *)NULL)

696

{

697

/* file *must* have a RISC OS extra field */

698

long ft = (long)makelong(ef_spark->loadaddr);

699

/*32-bit*/

700

if (lastcomma) {

701

pp = lastcomma + 1;

702

while (isxdigit((uch)(*pp))) ++pp;

703

if (pp == lastcomma+4 && *pp == '\0') *lastcomma='\0'; /* nuke */

704

}

705

if ((ft & 1<<31)==0) ft=0x000FFD00;

706

sprintf(pathcomp+strlen(pathcomp), ",%03x", (int)(ft>>8) & 0xFFF);

707

}

708

#endif /* ACORN_FTYPE_NFS */

709

710

if (*pathcomp == '\0') {

711

Info(slide, 1, ((char *)slide, "mapname: conversion of %s failed\n",

712

FnFilter1(G.filename)));

713

return (error & ~MPN_MASK) | MPN_ERR_SKIP;

714

}

715

716

checkdir(__G__ pathcomp, APPEND_NAME); /* returns 1 if truncated: care? */

717

checkdir(__G__ G.filename, GETPATH);

718

719

return error;

720

721

} /* end function mapname() */

722

723

724

725

726

#if 0 /*========== NOTES ==========*/

727

728

extract-to dir: a:path/

729

buildpath: path1/path2/ ... (NULL-terminated)

730

pathcomp: filename

731

732

mapname():

733

loop over chars in zipfile member name

734

checkdir(path component, COMPONENT | CREATEDIR) --> map as required?

735

(d:/tmp/unzip/) (disk:[tmp.unzip.)

736

(d:/tmp/unzip/jj/) (disk:[tmp.unzip.jj.)

737

(d:/tmp/unzip/jj/temp/) (disk:[tmp.unzip.jj.temp.)

738

finally add filename itself and check for existence? (could use with rename)

739

(d:/tmp/unzip/jj/temp/msg.outdir) (disk:[tmp.unzip.jj.temp]msg.outdir)

740

checkdir(name, GETPATH) --> copy path to name and free space

741

742

#endif /* 0 */

743

744

745

746

747

/***********************/

748

/* Function checkdir() */

749

/***********************/

750

751

int checkdir(__G__ pathcomp, flag)

752

__GDEF

753

char *pathcomp;

754

int flag;

755

/*

756

* returns:

757

* MPN_OK - no problem detected

758

* MPN_INF_TRUNC - (on APPEND_NAME) truncated filename

759

* MPN_INF_SKIP - path doesn't exist, not allowed to create

760

* MPN_ERR_SKIP - path doesn't exist, tried to create and failed; or path

761

* exists and is not a directory, but is supposed to be

762

* MPN_ERR_TOOLONG - path is too long

763

* MPN_NOMEM - can't allocate memory for filename buffers

764

*/

765

{

766

/* static int rootlen = 0; */ /* length of rootpath */

767

/* static char *rootpath; */ /* user's "extract-to" directory */

768

/* static char *buildpath; */ /* full path (so far) to extracted file */

769

/* static char *end; */ /* pointer to end of buildpath ('\0') */

770

771

# define FN_MASK 7

772

# define FUNCTION (flag & FN_MASK)

773

774

775

776

/*---------------------------------------------------------------------------

777

APPEND_DIR: append the path component to the path being built and check

778

for its existence. If doesn't exist and we are creating directories, do

779

so for this one; else signal success or error as appropriate.

780

---------------------------------------------------------------------------*/

781

782

if (FUNCTION == APPEND_DIR) {

783

int too_long = FALSE;

784

#ifdef SHORT_NAMES

785

char *old_end = end;

786

#endif

787

788

Trace((stderr, "appending dir segment [%s]\n", FnFilter1(pathcomp)));

789

while ((*G.end = *pathcomp++) != '\0')

790

++G.end;

791

#ifdef SHORT_NAMES /* path components restricted to 14 chars, typically */

792

if ((G.end-old_end) > FILENAME_MAX) /* GRR: proper constant? */

793

*(G.end = old_end + FILENAME_MAX) = '\0';

794

#endif

795

796

/* GRR: could do better check, see if overrunning buffer as we go:

797

* check end-buildpath after each append, set warning variable if

798

* within 20 of FILNAMSIZ; then if var set, do careful check when

799

* appending. Clear variable when begin new path. */

800

801

/* next check: need to append '/', at least one-char name, '\0' */

802

if ((G.end-G.buildpath) > FILNAMSIZ-3)

803

too_long = TRUE; /* check if extracting dir? */

804

if (SSTAT(G.buildpath, &G.statbuf)) { /* path doesn't exist */

805

if (!G.create_dirs) { /* told not to create (freshening) */

806

free(G.buildpath);

807

return MPN_INF_SKIP; /* path doesn't exist: nothing to do */

808

}

809

if (too_long) {

810

Info(slide, 1, ((char *)slide,

811

"checkdir error: path too long: %s\n",

812

FnFilter1(G.buildpath)));

813

free(G.buildpath);

814

/* no room for filenames: fatal */

815

return MPN_ERR_TOOLONG;

816

}

817

if (mkdir(G.buildpath, 0777) == -1) { /* create the directory */

818

Info(slide, 1, ((char *)slide,

819

"checkdir error: cannot create %s\n\

820

%s\n\

821

unable to process %s.\n",

822

FnFilter2(G.buildpath),

823

strerror(errno),

824

FnFilter1(G.filename)));

825

free(G.buildpath);

826

/* path didn't exist, tried to create, failed */

827

return MPN_ERR_SKIP;

828

}

829

G.created_dir = TRUE;

830

} else if (!S_ISDIR(G.statbuf.st_mode)) {

831

Info(slide, 1, ((char *)slide,

832

"checkdir error: %s exists but is not directory\n\

833

unable to process %s.\n",

834

FnFilter2(G.buildpath), FnFilter1(G.filename)));

835

free(G.buildpath);

836

/* path existed but wasn't dir */

837

return MPN_ERR_SKIP;

838

}

839

if (too_long) {

840

Info(slide, 1, ((char *)slide,

841

"checkdir error: path too long: %s\n", FnFilter1(G.buildpath)));

842

free(G.buildpath);

843

/* no room for filenames: fatal */

844

return MPN_ERR_TOOLONG;

845

}

846

*G.end++ = '/';

847

*G.end = '\0';

848

Trace((stderr, "buildpath now = [%s]\n", FnFilter1(G.buildpath)));

849

return MPN_OK;

850

851

} /* end if (FUNCTION == APPEND_DIR) */

852

853

/*---------------------------------------------------------------------------

854

GETPATH: copy full path to the string pointed at by pathcomp, and free

855

G.buildpath.

856

---------------------------------------------------------------------------*/

857

858

if (FUNCTION == GETPATH) {

859

strcpy(pathcomp, G.buildpath);

860

Trace((stderr, "getting and freeing path [%s]\n",

861

FnFilter1(pathcomp)));

862

free(G.buildpath);

863

G.buildpath = G.end = (char *)NULL;

864

return MPN_OK;

865

}

866

867

/*---------------------------------------------------------------------------

868

APPEND_NAME: assume the path component is the filename; append it and

869

return without checking for existence.

870

---------------------------------------------------------------------------*/

871

872

if (FUNCTION == APPEND_NAME) {

873

#ifdef SHORT_NAMES

874

char *old_end = end;

875

#endif

876

877

Trace((stderr, "appending filename [%s]\n", FnFilter1(pathcomp)));

878

while ((*G.end = *pathcomp++) != '\0') {

879

++G.end;

880

#ifdef SHORT_NAMES /* truncate name at 14 characters, typically */

881

if ((G.end-old_end) > FILENAME_MAX) /* GRR: proper constant? */

882

*(G.end = old_end + FILENAME_MAX) = '\0';

883

#endif

884

if ((G.end-G.buildpath) >= FILNAMSIZ) {

885

*--G.end = '\0';

886

Info(slide, 0x201, ((char *)slide,

887

"checkdir warning: path too long; truncating\n\

888

%s\n -> %s\n",

889

FnFilter1(G.filename), FnFilter2(G.buildpath)));

890

return MPN_INF_TRUNC; /* filename truncated */

891

}

892

}

893

Trace((stderr, "buildpath now = [%s]\n", FnFilter1(G.buildpath)));

894

/* could check for existence here, prompt for new name... */

895

return MPN_OK;

896

}

897

898

/*---------------------------------------------------------------------------

899

INIT: allocate and initialize buffer space for the file currently being

900

extracted. If file was renamed with an absolute path, don't prepend the

901

extract-to path.

902

---------------------------------------------------------------------------*/

903

904

/* GRR: for VMS and TOPS-20, add up to 13 to strlen */

905

906

if (FUNCTION == INIT) {

907

Trace((stderr, "initializing buildpath to "));

908

#ifdef ACORN_FTYPE_NFS

909

if ((G.buildpath = (char *)malloc(strlen(G.filename)+G.rootlen+

910

(uO.acorn_nfs_ext ? 5 : 1)))

911

#else

912

if ((G.buildpath = (char *)malloc(strlen(G.filename)+G.rootlen+1))

913

#endif

914

== (char *)NULL)

915

return MPN_NOMEM;

916

if ((G.rootlen > 0) && !G.renamed_fullpath) {

917

strcpy(G.buildpath, G.rootpath);

918

G.end = G.buildpath + G.rootlen;

919

} else {

920

*G.buildpath = '\0';

921

G.end = G.buildpath;

922

}

923

Trace((stderr, "[%s]\n", FnFilter1(G.buildpath)));

924

return MPN_OK;

925

}

926

927

/*---------------------------------------------------------------------------

928

ROOT: if appropriate, store the path in rootpath and create it if

929

necessary; else assume it's a zipfile member and return. This path

930

segment gets used in extracting all members from every zipfile specified

931

on the command line.

932

---------------------------------------------------------------------------*/

933

934

#if (!defined(SFX) || defined(SFX_EXDIR))

935

if (FUNCTION == ROOT) {

936

Trace((stderr, "initializing root path to [%s]\n",

937

FnFilter1(pathcomp)));

938

if (pathcomp == (char *)NULL) {

939

G.rootlen = 0;

940

return MPN_OK;

941

}

942

if (G.rootlen > 0) /* rootpath was already set, nothing to do */

943

return MPN_OK;

944

if ((G.rootlen = strlen(pathcomp)) > 0) {

945

char *tmproot;

946

947

if ((tmproot = (char *)malloc(G.rootlen+2)) == (char *)NULL) {

948

G.rootlen = 0;

949

return MPN_NOMEM;

950

}

951

strcpy(tmproot, pathcomp);

952

if (tmproot[G.rootlen-1] == '/') {

953

tmproot[--G.rootlen] = '\0';

954

}

955

if (G.rootlen > 0 && (SSTAT(tmproot, &G.statbuf) ||

956

!S_ISDIR(G.statbuf.st_mode)))

957

{ /* path does not exist */

958

if (!G.create_dirs /* || iswild(tmproot) */ ) {

959

free(tmproot);

960

G.rootlen = 0;

961

/* skip (or treat as stored file) */

962

return MPN_INF_SKIP;

963

}

964

/* create the directory (could add loop here scanning tmproot

965

* to create more than one level, but why really necessary?) */

966

if (mkdir(tmproot, 0777) == -1) {

967

Info(slide, 1, ((char *)slide,

968

"checkdir: cannot create extraction directory: %s\n\

969

%s\n",

970

FnFilter1(tmproot), strerror(errno)));

971

free(tmproot);

972

G.rootlen = 0;

973

/* path didn't exist, tried to create, and failed: */

974

/* file exists, or 2+ subdir levels required */

975

return MPN_ERR_SKIP;

976

}

977

}

978

tmproot[G.rootlen++] = '/';

979

tmproot[G.rootlen] = '\0';

980

if ((G.rootpath = (char *)realloc(tmproot, G.rootlen+1)) == NULL) {

981

free(tmproot);

982

G.rootlen = 0;

983

return MPN_NOMEM;

984

}

985

Trace((stderr, "rootpath now = [%s]\n", FnFilter1(G.rootpath)));

986

}

987

return MPN_OK;

988

}

989

#endif /* !SFX || SFX_EXDIR */

990

991

/*---------------------------------------------------------------------------

992

END: free rootpath, immediately prior to program exit.

993

---------------------------------------------------------------------------*/

994

995

if (FUNCTION == END) {

996

Trace((stderr, "freeing rootpath\n"));

997

if (G.rootlen > 0) {

998

free(G.rootpath);

999

G.rootlen = 0;

1000

}

1001

return MPN_OK;

1002

}

1003

1004

return MPN_INVALID; /* should never reach */

1005

1006

} /* end function checkdir() */

1007

1008

1009

1010

1011

1012

#ifdef NO_MKDIR

1013

1014

/********************/

1015

/* Function mkdir() */

1016

/********************/

1017

1018

int mkdir(path, mode)

1019

ZCONST char *path;

1020

int mode; /* ignored */

1021

/*

1022

* returns: 0 - successful

1023

* -1 - failed (errno not set, however)

1024

*/

1025

{

1026

char command[FILNAMSIZ+40]; /* buffer for system() call */

1027

1028

/* GRR 930416: added single quotes around path to avoid bug with

1029

* creating directories with ampersands in name; not yet tested */

1030

sprintf(command, "IFS=\" \t\n\" /bin/mkdir '%s' 2>/dev/null", path);

1031

if (system(command))

1032

return -1;

1033

return 0;

1034

}

1035

1036

#endif /* NO_MKDIR */

1037

1038

1039

1040

1041

#if (!defined(MTS) || defined(SET_DIR_ATTRIB))

1042

static int get_extattribs OF((__GPRO__ iztimes *pzt, ulg z_uidgid[2]));

1043

1044

static int get_extattribs(__G__ pzt, z_uidgid)

1045

__GDEF

1046

iztimes *pzt;

1047

ulg z_uidgid[2];

1048

{

1049

/*---------------------------------------------------------------------------

1050

Convert from MSDOS-format local time and date to Unix-format 32-bit GMT

1051

time: adjust base year from 1980 to 1970, do usual conversions from

1052

yy/mm/dd hh:mm:ss to elapsed seconds, and account for timezone and day-

1053

light savings time differences. If we have a Unix extra field, however,

1054

we're laughing: both mtime and atime are ours. On the other hand, we

1055

then have to check for restoration of UID/GID.

1056

---------------------------------------------------------------------------*/

1057

int have_uidgid_flg;

1058

unsigned eb_izux_flg;

1059

1060

eb_izux_flg = (G.extra_field ? ef_scan_for_izux(G.extra_field,

1061

G.lrec.extra_field_length, 0, G.lrec.last_mod_dos_datetime,

1062

#ifdef IZ_CHECK_TZ

1063

(G.tz_is_valid ? pzt : NULL),

1064

#else

1065

pzt,

1066

#endif

1067

z_uidgid) : 0);

1068

if (eb_izux_flg & EB_UT_FL_MTIME) {

1069

TTrace((stderr, "\nget_extattribs: Unix e.f. modif. time = %ld\n",

1070

pzt->mtime));

1071

} else {

1072

pzt->mtime = dos_to_unix_time(G.lrec.last_mod_dos_datetime);

1073

}

1074

if (eb_izux_flg & EB_UT_FL_ATIME) {

1075

TTrace((stderr, "get_extattribs: Unix e.f. access time = %ld\n",

1076

pzt->atime));

1077

} else {

1078

pzt->atime = pzt->mtime;

1079

TTrace((stderr, "\nget_extattribs: modification/access times = %ld\n",

1080

pzt->mtime));

1081

}

1082

1083

/* if -X option was specified and we have UID/GID info, restore it */

1084

have_uidgid_flg =

1085

#ifdef RESTORE_UIDGID

1086

(uO.X_flag && (eb_izux_flg & EB_UX2_VALID));

1087

#else

1088

0;

1089

#endif

1090

return have_uidgid_flg;

1091

}

1092

#endif /* !MTS || SET_DIR_ATTRIB */

1093

1094

1095

1096

#ifndef MTS

1097

1098

/****************************/

1099

/* Function close_outfile() */

1100

/****************************/

1101

1102

void close_outfile(__G) /* GRR: change to return PK-style warning level */

1103

__GDEF

1104

{

1105

union {

1106

iztimes t3; /* mtime, atime, ctime */

1107

ztimbuf t2; /* modtime, actime */

1108

} zt;

1109

ulg z_uidgid[2];

1110

int have_uidgid_flg;

1111

1112

have_uidgid_flg = get_extattribs(__G__ &(zt.t3), z_uidgid);

1113

1114

/*---------------------------------------------------------------------------

1115

If symbolic links are supported, allocate storage for a symlink control

1116

structure, put the uncompressed "data" and other required info in it, and

1117

add the structure to the "deferred symlinks" chain. Since we know it's a

1118

symbolic link to start with, we shouldn't have to worry about overflowing

1119

unsigned ints with unsigned longs.

1120

---------------------------------------------------------------------------*/

1121

1122

#ifdef SYMLINKS

1123

if (G.symlnk) {

1124

extent ucsize = (extent)G.lrec.ucsize;

1125

# ifdef SET_SYMLINK_ATTRIBS

1126

extent attribsize = sizeof(unsigned) +

1127

(have_uidgid_flg ? sizeof(z_uidgid) : 0);

1128

# else

1129

extent attribsize = 0;

1130

# endif

1131

/* size of the symlink entry is the sum of

1132

* (struct size (includes 1st '\0') + 1 additional trailing '\0'),

1133

* system specific attribute data size (might be 0),

1134

* and the lengths of name and link target.

1135

*/

1136

extent slnk_entrysize = (sizeof(slinkentry) + 1) + attribsize +

1137

ucsize + strlen(G.filename);

1138

slinkentry *slnk_entry;

1139

1140

if (slnk_entrysize < ucsize) {

1141

Info(slide, 0x201, ((char *)slide,

1142

"warning: symbolic link (%s) failed: mem alloc overflow\n",

1143

FnFilter1(G.filename)));

1144

fclose(G.outfile);

1145

return;

1146

}

1147

1148

if ((slnk_entry = (slinkentry *)malloc(slnk_entrysize)) == NULL) {

1149

Info(slide, 0x201, ((char *)slide,

1150

"warning: symbolic link (%s) failed: no mem\n",

1151

FnFilter1(G.filename)));

1152

fclose(G.outfile);

1153

return;

1154

}

1155

slnk_entry->next = NULL;

1156

slnk_entry->targetlen = ucsize;

1157

slnk_entry->attriblen = attribsize;

1158

# ifdef SET_SYMLINK_ATTRIBS

1159

memcpy(slnk_entry->buf, &(G.pInfo->file_attr),

1160

sizeof(unsigned));

1161

if (have_uidgid_flg)

1162

memcpy(slnk_entry->buf + 4, z_uidgid, sizeof(z_uidgid));

1163

# endif

1164

slnk_entry->target = slnk_entry->buf + slnk_entry->attriblen;

1165

slnk_entry->fname = slnk_entry->target + ucsize + 1;

1166

strcpy(slnk_entry->fname, G.filename);

1167

1168

/* move back to the start of the file to re-read the "link data" */

1169

rewind(G.outfile);

1170

1171

if (fread(slnk_entry->target, 1, ucsize, G.outfile) != ucsize)

1172

{

1173

Info(slide, 0x201, ((char *)slide,

1174

"warning: symbolic link (%s) failed\n",

1175

FnFilter1(G.filename)));

1176

free(slnk_entry);

1177

fclose(G.outfile);

1178

return;

1179

}

1180

fclose(G.outfile); /* close "link" file for good... */

1181

slnk_entry->target[ucsize] = '\0';

1182

if (QCOND2)

1183

Info(slide, 0, ((char *)slide, "-> %s ",

1184

FnFilter1(slnk_entry->target)));

1185

/* add this symlink record to the list of deferred symlinks */

1186

if (G.slink_last != NULL)

1187

G.slink_last->next = slnk_entry;

1188

else

1189

G.slink_head = slnk_entry;

1190

G.slink_last = slnk_entry;

1191

return;

1192

}

1193

#endif /* SYMLINKS */

1194

1195

#ifdef QLZIP

1196

if (G.extra_field) {

1197

static void qlfix OF((__GPRO__ uch *ef_ptr, unsigned ef_len));

1198

1199

qlfix(__G__ G.extra_field, G.lrec.extra_field_length);

1200

}

1201

#endif

1202

1203

#if (defined(NO_FCHOWN))

1204

fclose(G.outfile);

1205

#endif

1206

1207

/* if -X option was specified and we have UID/GID info, restore it */

1208

if (have_uidgid_flg

1209

/* check that both uid and gid values fit into their data sizes */

1210

&& ((ulg)(uid_t)(z_uidgid[0]) == z_uidgid[0])

1211

&& ((ulg)(gid_t)(z_uidgid[1]) == z_uidgid[1])) {

1212

TTrace((stderr, "close_outfile: restoring Unix UID/GID info\n"));

1213

#if (defined(NO_FCHOWN))

1214

if (chown(G.filename, (uid_t)z_uidgid[0], (gid_t)z_uidgid[1]))

1215

#else

1216

if (fchown(fileno(G.outfile), (uid_t)z_uidgid[0], (gid_t)z_uidgid[1]))

1217

#endif

1218

{

1219

if (uO.qflag)

1220

Info(slide, 0x201, ((char *)slide, CannotSetItemUidGid,

1221

z_uidgid[0], z_uidgid[1], FnFilter1(G.filename),

1222

strerror(errno)));

1223

else

1224

Info(slide, 0x201, ((char *)slide, CannotSetUidGid,

1225

z_uidgid[0], z_uidgid[1], strerror(errno)));

1226

}

1227

}

1228

1229

#if (!defined(NO_FCHOWN) && defined(NO_FCHMOD))

1230

fclose(G.outfile);

1231

#endif

1232

1233

#if (!defined(NO_FCHOWN) && !defined(NO_FCHMOD))

1234

/*---------------------------------------------------------------------------

1235

Change the file permissions from default ones to those stored in the

1236

zipfile.

1237

---------------------------------------------------------------------------*/

1238

1239

if (fchmod(fileno(G.outfile), filtattr(__G__ G.pInfo->file_attr)))

1240

perror("fchmod (file attributes) error");

1241

1242

fclose(G.outfile);

1243

#endif /* !NO_FCHOWN && !NO_FCHMOD */

1244

1245

/* skip restoring time stamps on user's request */

1246

if (uO.D_flag <= 1) {

1247

/* set the file's access and modification times */

1248

if (utime(G.filename, &(zt.t2))) {

1249

if (uO.qflag)

1250

Info(slide, 0x201, ((char *)slide, CannotSetItemTimestamps,

1251

FnFilter1(G.filename), strerror(errno)));

1252

else

1253

Info(slide, 0x201, ((char *)slide, CannotSetTimestamps,

1254

strerror(errno)));

1255

}

1256

}

1257

1258

#if (defined(NO_FCHOWN) || defined(NO_FCHMOD))

1259

/*---------------------------------------------------------------------------

1260

Change the file permissions from default ones to those stored in the

1261

zipfile.

1262

---------------------------------------------------------------------------*/

1263

1264

#ifndef NO_CHMOD

1265

if (chmod(G.filename, filtattr(__G__ G.pInfo->file_attr)))

1266

perror("chmod (file attributes) error");

1267

#endif

1268

#endif /* NO_FCHOWN || NO_FCHMOD */

1269

1270

} /* end function close_outfile() */

1271

1272

#endif /* !MTS */

1273

1274

1275

#if (defined(SYMLINKS) && defined(SET_SYMLINK_ATTRIBS))

1276

int set_symlnk_attribs(__G__ slnk_entry)

1277

__GDEF

1278

slinkentry *slnk_entry;

1279

{

1280

if (slnk_entry->attriblen > 0) {

1281

# if (!defined(NO_LCHOWN))

1282

if (slnk_entry->attriblen > sizeof(unsigned)) {

1283

ulg *z_uidgid_p = (zvoid *)(slnk_entry->buf + sizeof(unsigned));

1284

/* check that both uid and gid values fit into their data sizes */

1285

if (((ulg)(uid_t)(z_uidgid_p[0]) == z_uidgid_p[0]) &&

1286

((ulg)(gid_t)(z_uidgid_p[1]) == z_uidgid_p[1])) {

1287

TTrace((stderr,

1288

"set_symlnk_attribs: restoring Unix UID/GID info for\n\

1289

%s\n",

1290

FnFilter1(slnk_entry->fname)));

1291

if (lchown(slnk_entry->fname,

1292

(uid_t)z_uidgid_p[0], (gid_t)z_uidgid_p[1]))

1293

{

1294

Info(slide, 0x201, ((char *)slide, CannotSetItemUidGid,

1295

z_uidgid_p[0], z_uidgid_p[1], FnFilter1(slnk_entry->fname),

1296

strerror(errno)));

1297

}

1298

}

1299

}

1300

# endif /* !NO_LCHOWN */

1301

# if (!defined(NO_LCHMOD))

1302

TTrace((stderr,

1303

"set_symlnk_attribs: restoring Unix attributes for\n %s\n",

1304

FnFilter1(slnk_entry->fname)));

1305

if (lchmod(slnk_entry->fname,

1306

filtattr(__G__ *(unsigned *)(zvoid *)slnk_entry->buf)))

1307

perror("lchmod (file attributes) error");

1308

# endif /* !NO_LCHMOD */

1309

}

1310

/* currently, no error propagation... */

1311

return PK_OK;

1312

} /* end function set_symlnk_attribs() */

1313

#endif /* SYMLINKS && SET_SYMLINK_ATTRIBS */

1314

1315

1316

#ifdef SET_DIR_ATTRIB

1317

/* messages of code for setting directory attributes */

1318

# ifndef NO_CHMOD

1319

static ZCONST char DirlistChmodFailed[] =

1320

"warning: cannot set permissions for %s\n %s\n";

1321

# endif

1322

1323

1324

int defer_dir_attribs(__G__ pd)

1325

__GDEF

1326

direntry **pd;

1327

{

1328

uxdirattr *d_entry;

1329

1330

d_entry = (uxdirattr *)malloc(sizeof(uxdirattr) + strlen(G.filename));

1331

*pd = (direntry *)d_entry;

1332

if (d_entry == (uxdirattr *)NULL) {

1333

return PK_MEM;

1334

}

1335

d_entry->fn = d_entry->fnbuf;

1336

strcpy(d_entry->fn, G.filename);

1337

1338

d_entry->perms = G.pInfo->file_attr;

1339

1340

d_entry->have_uidgid = get_extattribs(__G__ &(d_entry->u.t3),

1341

d_entry->uidgid);

1342

return PK_OK;

1343

} /* end function defer_dir_attribs() */

1344

1345

1346

int set_direc_attribs(__G__ d)

1347

__GDEF

1348

direntry *d;

1349

{

1350

int errval = PK_OK;

1351

1352

if (UxAtt(d)->have_uidgid &&

1353

/* check that both uid and gid values fit into their data sizes */

1354

((ulg)(uid_t)(UxAtt(d)->uidgid[0]) == UxAtt(d)->uidgid[0]) &&

1355

((ulg)(gid_t)(UxAtt(d)->uidgid[1]) == UxAtt(d)->uidgid[1]) &&

1356

chown(UxAtt(d)->fn, (uid_t)UxAtt(d)->uidgid[0],

1357

(gid_t)UxAtt(d)->uidgid[1]))

1358

{

1359

Info(slide, 0x201, ((char *)slide, CannotSetItemUidGid,

1360

UxAtt(d)->uidgid[0], UxAtt(d)->uidgid[1], FnFilter1(d->fn),

1361

strerror(errno)));

1362

if (!errval)

1363

errval = PK_WARN;

1364

}

1365

/* Skip restoring directory time stamps on user' request. */

1366

if (uO.D_flag <= 0) {

1367

/* restore directory timestamps */

1368

if (utime(d->fn, &UxAtt(d)->u.t2)) {

1369

Info(slide, 0x201, ((char *)slide, CannotSetItemTimestamps,

1370

FnFilter1(d->fn), strerror(errno)));

1371

if (!errval)

1372

errval = PK_WARN;

1373

}

1374

}

1375

#ifndef NO_CHMOD

1376

if (chmod(d->fn, UxAtt(d)->perms)) {

1377

Info(slide, 0x201, ((char *)slide, DirlistChmodFailed,

1378

FnFilter1(d->fn), strerror(errno)));

1379

if (!errval)

1380

errval = PK_WARN;

1381

}

1382

#endif /* !NO_CHMOD */

1383

return errval;

1384

} /* end function set_direc_attribs() */

1385

1386

#endif /* SET_DIR_ATTRIB */

1387

1388

1389

1390

1391

#ifdef TIMESTAMP

1392

1393

/***************************/

1394

/* Function stamp_file() */

1395

/***************************/

1396

1397

int stamp_file(fname, modtime)

1398

ZCONST char *fname;

1399

time_t modtime;

1400

{

1401

ztimbuf tp;

1402

1403

tp.modtime = tp.actime = modtime;

1404

return (utime(fname, &tp));

1405

1406

} /* end function stamp_file() */

1407

1408

#endif /* TIMESTAMP */

1409

1410

1411

1412

1413

#ifndef SFX

1414

1415

/************************/

1416

/* Function version() */

1417

/************************/

1418

1419

void version(__G)

1420

__GDEF

1421

{

1422

#if (defined(__GNUC__) && defined(NX_CURRENT_COMPILER_RELEASE))

1423

char cc_namebuf[40];

1424

char cc_versbuf[40];

1425

#else

1426

#if (defined(__SUNPRO_C))

1427

char cc_versbuf[17];

1428

#else

1429

#if (defined(__HP_cc) || defined(__IBMC__))

1430

char cc_versbuf[25];

1431

#else

1432

#if (defined(__DECC_VER))

1433

char cc_versbuf[17];

1434

int cc_verstyp;

1435

#else

1436

#if (defined(CRAY) && defined(_RELEASE))

1437

char cc_versbuf[40];

1438

#endif /* (CRAY && _RELEASE) */

1439

#endif /* __DECC_VER */

1440

#endif /* __HP_cc || __IBMC__ */

1441

#endif /* __SUNPRO_C */

1442

#endif /* (__GNUC__ && NX_CURRENT_COMPILER_RELEASE) */

1443

1444

#if ((defined(CRAY) || defined(cray)) && defined(_UNICOS))

1445

char os_namebuf[40];

1446

#else

1447

#if defined(__NetBSD__)

1448

char os_namebuf[40];

1449

#endif

1450

#endif

1451

1452

/* Pyramid, NeXT have problems with huge macro expansion, too: no Info() */

1453

sprintf((char *)slide, LoadFarString(CompiledWith),

1454

1455

#ifdef __GNUC__

1456

# ifdef NX_CURRENT_COMPILER_RELEASE

1457

(sprintf(cc_namebuf, "NeXT DevKit %d.%02d ",

1458

NX_CURRENT_COMPILER_RELEASE/100, NX_CURRENT_COMPILER_RELEASE%100),

1459

cc_namebuf),

1460

(strlen(__VERSION__) > 8)? "(gcc)" :

1461

(sprintf(cc_versbuf, "(gcc %s)", __VERSION__), cc_versbuf),

1462

# else

1463

"gcc ", __VERSION__,

1464

# endif

1465

#else

1466

#if defined(__SUNPRO_C)

1467

"Sun C ", (sprintf(cc_versbuf, "version %x", __SUNPRO_C), cc_versbuf),

1468

#else

1469

#if (defined(__HP_cc))

1470

"HP C ",

1471

(((__HP_cc% 100) == 0) ?

1472

(sprintf(cc_versbuf, "version A.%02d.%02d",

1473

(__HP_cc/ 10000), ((__HP_cc% 10000)/ 100))) :

1474

(sprintf(cc_versbuf, "version A.%02d.%02d.%02d",

1475

(__HP_cc/ 10000), ((__HP_cc% 10000)/ 100), (__HP_cc% 100))),

1476

cc_versbuf),

1477

#else

1478

#if (defined(__DECC_VER))

1479

"DEC C ",

1480

(sprintf(cc_versbuf, "%c%d.%d-%03d",

1481

((cc_verstyp = (__DECC_VER / 10000) % 10) == 6 ? 'T' :

1482

(cc_verstyp == 8 ? 'S' : 'V')),

1483

__DECC_VER / 10000000,

1484

(__DECC_VER % 10000000) / 100000, __DECC_VER % 1000),

1485

cc_versbuf),

1486

#else

1487

#if defined(CRAY) && defined(_RELEASE)

1488

"cc ", (sprintf(cc_versbuf, "version %d", _RELEASE), cc_versbuf),

1489

#else

1490

#ifdef __IBMC__

1491

"IBM C ",

1492

(sprintf(cc_versbuf, "version %d.%d.%d",

1493

(__IBMC__ / 100), ((__IBMC__ / 10) % 10), (__IBMC__ % 10)),

1494

cc_versbuf),

1495

#else

1496

#ifdef __VERSION__

1497

# ifndef IZ_CC_NAME

1498

# define IZ_CC_NAME "cc "

1499

# endif

1500

IZ_CC_NAME, __VERSION__

1501

#else

1502

# ifndef IZ_CC_NAME

1503

# define IZ_CC_NAME "cc"

1504

# endif

1505

IZ_CC_NAME, "",

1506

#endif /* ?__VERSION__ */

1507

#endif /* ?__IBMC__ */

1508

#endif /* ?(CRAY && _RELEASE) */

1509

#endif /* ?__DECC_VER */

1510

#endif /* ?__HP_cc */

1511

#endif /* ?__SUNPRO_C */

1512

#endif /* ?__GNUC__ */

1513

1514

#ifndef IZ_OS_NAME

1515

# define IZ_OS_NAME "Unix"

1516

#endif

1517

IZ_OS_NAME,

1518

1519

#if defined(sgi) || defined(__sgi)

1520

" (Silicon Graphics IRIX)",

1521

#else

1522

#ifdef sun

1523

# ifdef sparc

1524

# ifdef __SVR4

1525

" (Sun SPARC/Solaris)",

1526

# else /* may or may not be SunOS */

1527

" (Sun SPARC)",

1528

# endif

1529

# else

1530

# if defined(sun386) || defined(i386)

1531

" (Sun 386i)",

1532

# else

1533

# if defined(mc68020) || defined(__mc68020__)

1534

" (Sun 3)",

1535

# else /* mc68010 or mc68000: Sun 2 or earlier */

1536

" (Sun 2)",

1537

# endif

1538

# endif

1539

# endif

1540

#else

1541

#ifdef __hpux

1542

" (HP-UX)",

1543

#else

1544

#ifdef __osf__

1545

" (DEC OSF/1)",

1546

#else

1547

#ifdef _AIX

1548

" (IBM AIX)",

1549

#else

1550

#ifdef aiws

1551

" (IBM RT/AIX)",

1552

#else

1553

#if defined(CRAY) || defined(cray)

1554

# ifdef _UNICOS

1555

(sprintf(os_namebuf, " (Cray UNICOS release %d)", _UNICOS), os_namebuf),

1556

# else

1557

" (Cray UNICOS)",

1558

# endif

1559

#else

1560

#if defined(uts) || defined(UTS)

1561

" (Amdahl UTS)",

1562

#else

1563

#ifdef NeXT

1564

# ifdef mc68000

1565

" (NeXTStep/black)",

1566

# else

1567

" (NeXTStep for Intel)",

1568

# endif

1569

#else /* the next dozen or so are somewhat order-dependent */

1570

#ifdef LINUX

1571

# ifdef __ELF__

1572

" (Linux ELF)",

1573

# else

1574

" (Linux a.out)",

1575

# endif

1576

#else

1577

#ifdef MINIX

1578

" (Minix)",

1579

#else

1580

#ifdef M_UNIX

1581

" (SCO Unix)",

1582

#else

1583

#ifdef M_XENIX

1584

" (SCO Xenix)",

1585

#else

1586

#ifdef __NetBSD__

1587

# ifdef NetBSD0_8

1588

(sprintf(os_namebuf, " (NetBSD 0.8%c)", (char)(NetBSD0_8 - 1 + 'A')),

1589

os_namebuf),

1590

# else

1591

# ifdef NetBSD0_9

1592

(sprintf(os_namebuf, " (NetBSD 0.9%c)", (char)(NetBSD0_9 - 1 + 'A')),

1593

os_namebuf),

1594

# else

1595

# ifdef NetBSD1_0

1596

(sprintf(os_namebuf, " (NetBSD 1.0%c)", (char)(NetBSD1_0 - 1 + 'A')),

1597

os_namebuf),

1598

# else

1599

(BSD4_4 == 0.5)? " (NetBSD before 0.9)" : " (NetBSD 1.1 or later)",

1600

# endif

1601

# endif

1602

# endif

1603

#else

1604

#ifdef __FreeBSD__

1605

(BSD4_4 == 0.5)? " (FreeBSD 1.x)" : " (FreeBSD 2.0 or later)",

1606

#else

1607

#ifdef __bsdi__

1608

(BSD4_4 == 0.5)? " (BSD/386 1.0)" : " (BSD/386 1.1 or later)",

1609

#else

1610

#ifdef __386BSD__

1611

(BSD4_4 == 1)? " (386BSD, post-4.4 release)" : " (386BSD)",

1612

#else

1613

#ifdef __CYGWIN__

1614

" (Cygwin)",

1615

#else

1616

#if defined(i686) || defined(__i686) || defined(__i686__)

1617

" (Intel 686)",

1618

#else

1619

#if defined(i586) || defined(__i586) || defined(__i586__)

1620

" (Intel 586)",

1621

#else

1622

#if defined(i486) || defined(__i486) || defined(__i486__)

1623

" (Intel 486)",

1624

#else

1625

#if defined(i386) || defined(__i386) || defined(__i386__)

1626

" (Intel 386)",

1627

#else

1628

#ifdef pyr

1629

" (Pyramid)",

1630

#else

1631

#ifdef ultrix

1632

# ifdef mips

1633

" (DEC/MIPS)",

1634

# else

1635

# ifdef vax

1636

" (DEC/VAX)",

1637

# else /* __alpha? */

1638

" (DEC/Alpha)",

1639

# endif

1640

# endif

1641

#else

1642

#ifdef gould

1643

" (Gould)",

1644

#else

1645

#ifdef MTS

1646

" (MTS)",

1647

#else

1648

#ifdef __convexc__

1649

" (Convex)",

1650

#else

1651

#ifdef __QNX__

1652

" (QNX 4)",

1653

#else

1654

#ifdef __QNXNTO__

1655

" (QNX Neutrino)",

1656

#else

1657

#ifdef Lynx

1658

" (LynxOS)",

1659

#else

1660

#ifdef __APPLE__

1661

# ifdef __i386__

1662

" Mac OS X Intel i32",

1663

# else

1664

# ifdef __ppc__

1665

" Mac OS X PowerPC",

1666

# else

1667

# ifdef __ppc64__

1668

" Mac OS X PowerPC64",

1669

# else

1670

" Mac OS X",

1671

# endif /* __ppc64__ */

1672

# endif /* __ppc__ */

1673

# endif /* __i386__ */

1674

#else

1675

"",

1676

#endif /* Apple */

1677

#endif /* Lynx */

1678

#endif /* QNX Neutrino */

1679

#endif /* QNX 4 */

1680

#endif /* Convex */

1681

#endif /* MTS */

1682

#endif /* Gould */

1683

#endif /* DEC */

1684

#endif /* Pyramid */

1685

#endif /* 386 */

1686

#endif /* 486 */

1687

#endif /* 586 */

1688

#endif /* 686 */

1689

#endif /* Cygwin */

1690

#endif /* 386BSD */

1691

#endif /* BSDI BSD/386 */

1692

#endif /* NetBSD */

1693

#endif /* FreeBSD */

1694

#endif /* SCO Xenix */

1695

#endif /* SCO Unix */

1696

#endif /* Minix */

1697

#endif /* Linux */

1698

#endif /* NeXT */

1699

#endif /* Amdahl */

1700

#endif /* Cray */

1701

#endif /* RT/AIX */

1702

#endif /* AIX */

1703

#endif /* OSF/1 */

1704

#endif /* HP-UX */

1705

#endif /* Sun */

1706

#endif /* SGI */

1707

1708

#ifdef __DATE__

1709

" on ", __DATE__

1710

#else

1711

"", ""

1712

#endif

1713

);

1714

1715

(*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0);

1716

1717

} /* end function version() */

1718

1719

#endif /* !SFX */

1720

1721

1722

1723

1724

#ifdef QLZIP

1725

1726

struct qdirect {

1727

long d_length __attribute__ ((packed)); /* file length */

1728

unsigned char d_access __attribute__ ((packed)); /* file access type */

1729

unsigned char d_type __attribute__ ((packed)); /* file type */

1730

long d_datalen __attribute__ ((packed)); /* data length */

1731

long d_reserved __attribute__ ((packed));/* Unused */

1732

short d_szname __attribute__ ((packed)); /* size of name */

1733

char d_name[36] __attribute__ ((packed));/* name area */

1734

long d_update __attribute__ ((packed)); /* last update */

1735

long d_refdate __attribute__ ((packed));

1736

long d_backup __attribute__ ((packed)); /* EOD */

1737

};

1738

1739

#define LONGID "QDOS02"

1740

#define EXTRALEN (sizeof(struct qdirect) + 8)

1741

#define JBLONGID "QZHD"

1742

#define JBEXTRALEN (sizeof(jbextra) - 4 * sizeof(char))

1743

1744

typedef struct {

1745

char eb_header[4] __attribute__ ((packed)); /* place_holder */

1746

char longid[8] __attribute__ ((packed));

1747

struct qdirect header __attribute__ ((packed));

1748

} qdosextra;

1749

1750

typedef struct {

1751

char eb_header[4]; /* place_holder */

1752

char longid[4];

1753

struct qdirect header;

1754

} jbextra;

1755

1756

1757

1758

/* The following two functions SH() and LG() convert big-endian short

1759

* and long numbers into native byte order. They are some kind of

1760

* counterpart to the generic UnZip's makeword() and makelong() functions.

1761

*/

1762

static ush SH(ush val)

1763

{

1764

uch swapbuf[2];

1765

1766

swapbuf[1] = (uch)(val & 0xff);

1767

swapbuf[0] = (uch)(val >> 8);

1768

return (*(ush *)swapbuf);

1769

}

1770

1771

1772

1773

static ulg LG(ulg val)

1774

{

1775

/* convert the big-endian unsigned long number `val' to the machine

1776

* dependent representation

1777

*/

1778

ush swapbuf[2];

1779

1780

swapbuf[1] = SH((ush)(val & 0xffff));

1781

swapbuf[0] = SH((ush)(val >> 16));

1782

return (*(ulg *)swapbuf);

1783

}

1784

1785

1786

1787

static void qlfix(__G__ ef_ptr, ef_len)

1788

__GDEF

1789

uch *ef_ptr;

1790

unsigned ef_len;

1791

{

1792

while (ef_len >= EB_HEADSIZE)

1793

{

1794

unsigned eb_id = makeword(EB_ID + ef_ptr);

1795

unsigned eb_len = makeword(EB_LEN + ef_ptr);

1796

1797

if (eb_len > (ef_len - EB_HEADSIZE)) {

1798

/* discovered some extra field inconsistency! */

1799

Trace((stderr,

1800

"qlfix: block length %u > rest ef_size %u\n", eb_len,

1801

ef_len - EB_HEADSIZE));

1802

break;

1803

}

1804

1805

switch (eb_id) {

1806

case EF_QDOS:

1807

{

1808

struct _ntc_

1809

{

1810

long id;

1811

long dlen;

1812

} ntc;

1813

long dlen = 0;

1814

1815

qdosextra *extra = (qdosextra *)ef_ptr;

1816

jbextra *jbp = (jbextra *)ef_ptr;

1817

1818

if (!strncmp(extra->longid, LONGID, strlen(LONGID)))

1819

{

1820

if (eb_len != EXTRALEN)

1821

if (uO.qflag)

1822

Info(slide, 0x201, ((char *)slide,

1823

"warning: invalid length in Qdos field for %s\n",

1824

FnFilter1(G.filename)));

1825

else

1826

Info(slide, 0x201, ((char *)slide,

1827

"warning: invalid length in Qdos field"));

1828

1829

if (extra->header.d_type)

1830

{

1831

dlen = extra->header.d_datalen;

1832

}

1833

}

1834

1835

if (!strncmp(jbp->longid, JBLONGID, strlen(JBLONGID)))

1836

{

1837

if (eb_len != JBEXTRALEN)

1838

if (uO.qflag)

1839

Info(slide, 0x201, ((char *)slide,

1840

"warning: invalid length in QZ field for %s\n",

1841

FnFilter1(G.filename)));

1842

else

1843

Info(slide, 0x201, ((char *)slide,

1844

"warning: invalid length in QZ field"));

1845

if (jbp->header.d_type)

1846

{

1847

dlen = jbp->header.d_datalen;

1848

}

1849

}

1850

1851

if ((long)LG(dlen) > 0)

1852

{

1853

zfseeko(G.outfile, -8, SEEK_END);

1854

fread(&ntc, 8, 1, G.outfile);

1855

if (ntc.id != *(long *)"XTcc")

1856

{

1857

ntc.id = *(long *)"XTcc";

1858

ntc.dlen = dlen;

1859

fwrite (&ntc, 8, 1, G.outfile);

1860

}

1861

Info(slide, 0x201, ((char *)slide, "QData = %d", LG(dlen)));

1862

}

1863

return; /* finished, cancel further extra field scanning */

1864

}

1865

1866

default:

1867

Trace((stderr,"qlfix: unknown extra field block, ID=%d\n",

1868

eb_id));

1869

}

1870

1871

/* Skip this extra field block */

1872

ef_ptr += (eb_len + EB_HEADSIZE);

1873

ef_len -= (eb_len + EB_HEADSIZE);

1874

}

1875

}

1876

#endif /* QLZIP */