~psiphon-inc/psiphon/trunk

Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).

Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G

should only read the compressed/uncompressed size from the Zip64 format if

the size from normal header was 0xFFFFFFFF

Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant

Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)

Patch created by Daniel Borca

Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifndef NOUNCRYPT

#define NOUNCRYPT

#endif

#include "zlib.h"

#include "unzip.h"

#ifdef STDC

# include <stddef.h>

# include <string.h>

# include <stdlib.h>

#endif

#ifdef NO_ERRNO_H

extern int errno;

#else

# include <errno.h>

#endif

#ifndef local

# define local static

#endif

/* compile with -Dlocal if your debugger can't find static symbols */

#ifndef CASESENSITIVITYDEFAULT_NO

# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)

# define CASESENSITIVITYDEFAULT_NO

# endif

100

#endif

101

102

103

#ifndef UNZ_BUFSIZE

104

#define UNZ_BUFSIZE (16384)

105

#endif

106

107

#ifndef UNZ_MAXFILENAMEINZIP

108

#define UNZ_MAXFILENAMEINZIP (256)

109

#endif

110

111

#ifndef ALLOC

112

# define ALLOC(size) (malloc(size))

113

#endif

114

#ifndef TRYFREE

115

# define TRYFREE(p) {if (p) free(p);}

116

#endif

117

118

#define SIZECENTRALDIRITEM (0x2e)

119

#define SIZEZIPLOCALHEADER (0x1e)

120

121

122

const char unz_copyright[] =

123

124

125

/* unz_file_info_interntal contain internal info about a file in zipfile*/

126

typedef struct unz_file_info64_internal_s

127

{

128

ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */

129

} unz_file_info64_internal;

130

131

132

/* file_in_zip_read_info_s contain internal information about a file in zipfile,

133

when reading and decompress it */

134

typedef struct

135

{

136

char *read_buffer; /* internal buffer for compressed data */

137

z_stream stream; /* zLib stream structure for inflate */

138

139

#ifdef HAVE_BZIP2

140

bz_stream bstream; /* bzLib stream structure for bziped */

141

#endif

142

143

ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek*/

144

uLong stream_initialised; /* flag set if stream structure is initialised*/

145

146

ZPOS64_T offset_local_extrafield;/* offset of the local extra field */

147

uInt size_local_extrafield;/* size of the local extra field */

148

ZPOS64_T pos_local_extrafield; /* position in the local extra field in read*/

149

ZPOS64_T total_out_64;

150

151

uLong crc32; /* crc32 of all data uncompressed */

152

uLong crc32_wait; /* crc32 we must obtain after decompress all */

153

ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */

154

ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/

155

zlib_filefunc64_32_def z_filefunc;

156

voidpf filestream; /* io structore of the zipfile */

157

uLong compression_method; /* compression method (0==store) */

158

ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/

159

int raw;

160

} file_in_zip64_read_info_s;

161

162

163

/* unz64_s contain internal information about the zipfile

164

165

typedef struct

166

{

167

zlib_filefunc64_32_def z_filefunc;

168

int is64bitOpenFunction;

169

voidpf filestream; /* io structore of the zipfile */

170

unz_global_info64 gi; /* public global information */

171

ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/

172

ZPOS64_T num_file; /* number of the current file in the zipfile*/

173

ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/

174

ZPOS64_T current_file_ok; /* flag about the usability of the current file*/

175

ZPOS64_T central_pos; /* position of the beginning of the central dir*/

176

177

ZPOS64_T size_central_dir; /* size of the central directory */

178

ZPOS64_T offset_central_dir; /* offset of start of central directory with

179

respect to the starting disk number */

180

181

unz_file_info64 cur_file_info; /* public info about the current file in zip*/

182

unz_file_info64_internal cur_file_info_internal; /* private info about it*/

183

file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current

184

file if we are decompressing it */

185

int encrypted;

186

187

int isZip64;

188

189

# ifndef NOUNCRYPT

190

unsigned long keys[3]; /* keys defining the pseudo-random sequence */

191

const unsigned long* pcrc_32_tab;

192

# endif

193

} unz64_s;

194

195

196

#ifndef NOUNCRYPT

197

#include "crypt.h"

198

#endif

199

200

/* ===========================================================================

201

Read a byte from a gz_stream; update next_in and avail_in. Return EOF

202

for end of file.

203

IN assertion: the stream s has been sucessfully opened for reading.

204

205

206

207

local int unz64local_getByte OF((

208

const zlib_filefunc64_32_def* pzlib_filefunc_def,

209

voidpf filestream,

210

int *pi));

211

212

local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)

213

{

214

unsigned char c;

215

int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);

216

if (err==1)

217

{

218

*pi = (int)c;

219

return UNZ_OK;

220

}

221

else

222

{

223

if (ZERROR64(*pzlib_filefunc_def,filestream))

224

return UNZ_ERRNO;

225

else

226

return UNZ_EOF;

227

}

228

}

229

230

231

/* ===========================================================================

232

Reads a long in LSB order from the given gz_stream. Sets

233

234

local int unz64local_getShort OF((

235

const zlib_filefunc64_32_def* pzlib_filefunc_def,

236

voidpf filestream,

237

uLong *pX));

238

239

local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,

240

voidpf filestream,

241

uLong *pX)

242

{

243

uLong x ;

244

int i = 0;

245

int err;

246

247

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

248

x = (uLong)i;

249

250

if (err==UNZ_OK)

251

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

252

x |= ((uLong)i)<<8;

253

254

if (err==UNZ_OK)

255

*pX = x;

256

else

257

*pX = 0;

258

return err;

259

}

260

261

local int unz64local_getLong OF((

262

const zlib_filefunc64_32_def* pzlib_filefunc_def,

263

voidpf filestream,

264

uLong *pX));

265

266

local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,

267

voidpf filestream,

268

uLong *pX)

269

{

270

uLong x ;

271

int i = 0;

272

int err;

273

274

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

275

x = (uLong)i;

276

277

if (err==UNZ_OK)

278

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

279

x |= ((uLong)i)<<8;

280

281

if (err==UNZ_OK)

282

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

283

x |= ((uLong)i)<<16;

284

285

if (err==UNZ_OK)

286

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

287

x += ((uLong)i)<<24;

288

289

if (err==UNZ_OK)

290

*pX = x;

291

else

292

*pX = 0;

293

return err;

294

}

295

296

local int unz64local_getLong64 OF((

297

const zlib_filefunc64_32_def* pzlib_filefunc_def,

298

voidpf filestream,

299

ZPOS64_T *pX));

300

301

302

local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,

303

voidpf filestream,

304

ZPOS64_T *pX)

305

{

306

ZPOS64_T x ;

307

int i = 0;

308

int err;

309

310

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

311

x = (ZPOS64_T)i;

312

313

if (err==UNZ_OK)

314

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

315

x |= ((ZPOS64_T)i)<<8;

316

317

if (err==UNZ_OK)

318

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

319

x |= ((ZPOS64_T)i)<<16;

320

321

if (err==UNZ_OK)

322

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

323

x |= ((ZPOS64_T)i)<<24;

324

325

if (err==UNZ_OK)

326

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

327

x |= ((ZPOS64_T)i)<<32;

328

329

if (err==UNZ_OK)

330

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

331

x |= ((ZPOS64_T)i)<<40;

332

333

if (err==UNZ_OK)

334

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

335

x |= ((ZPOS64_T)i)<<48;

336

337

if (err==UNZ_OK)

338

err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

339

x |= ((ZPOS64_T)i)<<56;

340

341

if (err==UNZ_OK)

342

*pX = x;

343

else

344

*pX = 0;

345

return err;

346

}

347

348

/* My own strcmpi / strcasecmp */

349

local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)

350

{

351

for (;;)

352

{

353

char c1=*(fileName1++);

354

char c2=*(fileName2++);

355

if ((c1>='a') && (c1<='z'))

356

c1 -= 0x20;

357

if ((c2>='a') && (c2<='z'))

358

c2 -= 0x20;

359

if (c1=='\0')

360

return ((c2=='\0') ? 0 : -1);

361

if (c2=='\0')

362

return 1;

363

if (c1<c2)

364

return -1;

365

if (c1>c2)

366

return 1;

367

}

368

}

369

370

371

#ifdef CASESENSITIVITYDEFAULT_NO

372

#define CASESENSITIVITYDEFAULTVALUE 2

373

#else

374

#define CASESENSITIVITYDEFAULTVALUE 1

375

#endif

376

377

#ifndef STRCMPCASENOSENTIVEFUNCTION

378

#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal

379

#endif

380

381

382

Compare two filename (fileName1,fileName2).

383

If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)

384

If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi

385

or strcasecmp)

386

If iCaseSenisivity = 0, case sensitivity is defaut of your operating system

387

(like 1 on Unix, 2 on Windows)

388

389

390

extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,

391

const char* fileName2,

392

int iCaseSensitivity)

393

394

{

395

if (iCaseSensitivity==0)

396

iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;

397

398

if (iCaseSensitivity==1)

399

return strcmp(fileName1,fileName2);

400

401

return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);

402

}

403

404

#ifndef BUFREADCOMMENT

405

#define BUFREADCOMMENT (0x400)

406

#endif

407

408

409

Locate the Central directory of a zipfile (at the end, just before

410

the global comment)

411

412

local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));

413

local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)

414

{

415

unsigned char* buf;

416

ZPOS64_T uSizeFile;

417

ZPOS64_T uBackRead;

418

ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */

419

ZPOS64_T uPosFound=0;

420

421

if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)

422

return 0;

423

424

425

uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);

426

427

if (uMaxBack>uSizeFile)

428

uMaxBack = uSizeFile;

429

430

buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);

431

if (buf==NULL)

432

return 0;

433

434

uBackRead = 4;

435

while (uBackRead<uMaxBack)

436

{

437

uLong uReadSize;

438

ZPOS64_T uReadPos ;

439

int i;

440

if (uBackRead+BUFREADCOMMENT>uMaxBack)

441

uBackRead = uMaxBack;

442

else

443

uBackRead+=BUFREADCOMMENT;

444

uReadPos = uSizeFile-uBackRead ;

445

446

uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?

447

(BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);

448

if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)

449

break;

450

451

if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)

452

break;

453

454

for (i=(int)uReadSize-3; (i--)>0;)

455

if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&

456

((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))

457

{

458

uPosFound = uReadPos+i;

459

break;

460

}

461

462

if (uPosFound!=0)

463

break;

464

}

465

TRYFREE(buf);

466

return uPosFound;

467

}

468

469

470

471

Locate the Central directory 64 of a zipfile (at the end, just before

472

the global comment)

473

474

local ZPOS64_T unz64local_SearchCentralDir64 OF((

475

const zlib_filefunc64_32_def* pzlib_filefunc_def,

476

voidpf filestream));

477

478

local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,

479

voidpf filestream)

480

{

481

unsigned char* buf;

482

ZPOS64_T uSizeFile;

483

ZPOS64_T uBackRead;

484

ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */

485

ZPOS64_T uPosFound=0;

486

uLong uL;

487

ZPOS64_T relativeOffset;

488

489

if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)

490

return 0;

491

492

493

uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);

494

495

if (uMaxBack>uSizeFile)

496

uMaxBack = uSizeFile;

497

498

buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);

499

if (buf==NULL)

500

return 0;

501

502

uBackRead = 4;

503

while (uBackRead<uMaxBack)

504

{

505

uLong uReadSize;

506

ZPOS64_T uReadPos;

507

int i;

508

if (uBackRead+BUFREADCOMMENT>uMaxBack)

509

uBackRead = uMaxBack;

510

else

511

uBackRead+=BUFREADCOMMENT;

512

uReadPos = uSizeFile-uBackRead ;

513

514

uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?

515

(BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);

516

if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)

517

break;

518

519

if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)

520

break;

521

522

for (i=(int)uReadSize-3; (i--)>0;)

523

if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&

524

((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))

525

{

526

uPosFound = uReadPos+i;

527

break;

528

}

529

530

if (uPosFound!=0)

531

break;

532

}

533

TRYFREE(buf);

534

if (uPosFound == 0)

535

return 0;

536

537

/* Zip64 end of central directory locator */

538

if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)

539

return 0;

540

541

/* the signature, already checked */

542

if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

543

return 0;

544

545

/* number of the disk with the start of the zip64 end of central directory */

546

if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

547

return 0;

548

if (uL != 0)

549

return 0;

550

551

/* relative offset of the zip64 end of central directory record */

552

if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)

553

return 0;

554

555

/* total number of disks */

556

if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

557

return 0;

558

if (uL != 1)

559

return 0;

560

561

/* Goto end of central directory record */

562

if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)

563

return 0;

564

565

/* the signature */

566

if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

567

return 0;

568

569

if (uL != 0x06064b50)

570

return 0;

571

572

return relativeOffset;

573

}

574

575

576

Open a Zip file. path contain the full pathname (by example,

577

on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer

578

"zlib/zlib114.zip".

579

If the zipfile cannot be opened (file doesn't exist or in not valid), the

580

return value is NULL.

581

Else, the return value is a unzFile Handle, usable with other function

582

of this unzip package.

583

584

local unzFile unzOpenInternal (const void *path,

585

zlib_filefunc64_32_def* pzlib_filefunc64_32_def,

586

int is64bitOpenFunction)

587

{

588

unz64_s us;

589

unz64_s *s;

590

ZPOS64_T central_pos;

591

uLong uL;

592

593

uLong number_disk; /* number of the current dist, used for

594

spaning ZIP, unsupported, always 0*/

595

uLong number_disk_with_CD; /* number the the disk with central dir, used

596

for spaning ZIP, unsupported, always 0*/

597

ZPOS64_T number_entry_CD; /* total number of entries in

598

the central dir

599

(same than number_entry on nospan) */

600

601

int err=UNZ_OK;

602

603

if (unz_copyright[0]!=' ')

604

return NULL;

605

606

us.z_filefunc.zseek32_file = NULL;

607

us.z_filefunc.ztell32_file = NULL;

608

if (pzlib_filefunc64_32_def==NULL)

609

fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);

610

else

611

us.z_filefunc = *pzlib_filefunc64_32_def;

612

us.is64bitOpenFunction = is64bitOpenFunction;

613

614

615

616

us.filestream = ZOPEN64(us.z_filefunc,

617

path,

618

ZLIB_FILEFUNC_MODE_READ |

619

ZLIB_FILEFUNC_MODE_EXISTING);

620

if (us.filestream==NULL)

621

return NULL;

622

623

central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);

624

if (central_pos)

625

{

626

uLong uS;

627

ZPOS64_T uL64;

628

629

us.isZip64 = 1;

630

631

if (ZSEEK64(us.z_filefunc, us.filestream,

632

central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

633

err=UNZ_ERRNO;

634

635

/* the signature, already checked */

636

if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

637

err=UNZ_ERRNO;

638

639

/* size of zip64 end of central directory record */

640

if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)

641

err=UNZ_ERRNO;

642

643

/* version made by */

644

if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)

645

err=UNZ_ERRNO;

646

647

/* version needed to extract */

648

if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)

649

err=UNZ_ERRNO;

650

651

/* number of this disk */

652

if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)

653

err=UNZ_ERRNO;

654

655

/* number of the disk with the start of the central directory */

656

if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)

657

err=UNZ_ERRNO;

658

659

/* total number of entries in the central directory on this disk */

660

if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)

661

err=UNZ_ERRNO;

662

663

/* total number of entries in the central directory */

664

if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)

665

err=UNZ_ERRNO;

666

667

if ((number_entry_CD!=us.gi.number_entry) ||

668

(number_disk_with_CD!=0) ||

669

(number_disk!=0))

670

err=UNZ_BADZIPFILE;

671

672

/* size of the central directory */

673

if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)

674

err=UNZ_ERRNO;

675

676

/* offset of start of central directory with respect to the

677

starting disk number */

678

if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)

679

err=UNZ_ERRNO;

680

681

us.gi.size_comment = 0;

682

}

683

else

684

{

685

central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);

686

if (central_pos==0)

687

err=UNZ_ERRNO;

688

689

us.isZip64 = 0;

690

691

if (ZSEEK64(us.z_filefunc, us.filestream,

692

central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

693

err=UNZ_ERRNO;

694

695

/* the signature, already checked */

696

if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

697

err=UNZ_ERRNO;

698

699

/* number of this disk */

700

if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)

701

err=UNZ_ERRNO;

702

703

/* number of the disk with the start of the central directory */

704

if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)

705

err=UNZ_ERRNO;

706

707

/* total number of entries in the central dir on this disk */

708

if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

709

err=UNZ_ERRNO;

710

us.gi.number_entry = uL;

711

712

/* total number of entries in the central dir */

713

if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

714

err=UNZ_ERRNO;

715

number_entry_CD = uL;

716

717

if ((number_entry_CD!=us.gi.number_entry) ||

718

(number_disk_with_CD!=0) ||

719

(number_disk!=0))

720

err=UNZ_BADZIPFILE;

721

722

/* size of the central directory */

723

if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

724

err=UNZ_ERRNO;

725

us.size_central_dir = uL;

726

727

/* offset of start of central directory with respect to the

728

starting disk number */

729

if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

730

err=UNZ_ERRNO;

731

us.offset_central_dir = uL;

732

733

/* zipfile comment length */

734

if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)

735

err=UNZ_ERRNO;

736

}

737

738

if ((central_pos<us.offset_central_dir+us.size_central_dir) &&

739

(err==UNZ_OK))

740

err=UNZ_BADZIPFILE;

741

742

if (err!=UNZ_OK)

743

{

744

ZCLOSE64(us.z_filefunc, us.filestream);

745

return NULL;

746

}

747

748

us.byte_before_the_zipfile = central_pos -

749

(us.offset_central_dir+us.size_central_dir);

750

us.central_pos = central_pos;

751

us.pfile_in_zip_read = NULL;

752

us.encrypted = 0;

753

754

755

s=(unz64_s*)ALLOC(sizeof(unz64_s));

756

if( s != NULL)

757

{

758

*s=us;

759

unzGoToFirstFile((unzFile)s);

760

}

761

return (unzFile)s;

762

}

763

764

765

extern unzFile ZEXPORT unzOpen2 (const char *path,

766

zlib_filefunc_def* pzlib_filefunc32_def)

767

{

768

if (pzlib_filefunc32_def != NULL)

769

{

770

zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

771

fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);

772

return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);

773

}

774

else

775

return unzOpenInternal(path, NULL, 0);

776

}

777

778

extern unzFile ZEXPORT unzOpen2_64 (const void *path,

779

zlib_filefunc64_def* pzlib_filefunc_def)

780

{

781

if (pzlib_filefunc_def != NULL)

782

{

783

zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

784

zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;

785

zlib_filefunc64_32_def_fill.ztell32_file = NULL;

786

zlib_filefunc64_32_def_fill.zseek32_file = NULL;

787

return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);

788

}

789

else

790

return unzOpenInternal(path, NULL, 1);

791

}

792

793

extern unzFile ZEXPORT unzOpen (const char *path)

794

{

795

return unzOpenInternal(path, NULL, 0);

796

}

797

798

extern unzFile ZEXPORT unzOpen64 (const void *path)

799

{

800

return unzOpenInternal(path, NULL, 1);

801

}

802

803

804

Close a ZipFile opened with unzipOpen.

805

If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),

806

these files MUST be closed with unzipCloseCurrentFile before call unzipClose.

807

return UNZ_OK if there is no problem. */

808

extern int ZEXPORT unzClose (unzFile file)

809

{

810

unz64_s* s;

811

if (file==NULL)

812

return UNZ_PARAMERROR;

813

s=(unz64_s*)file;

814

815

if (s->pfile_in_zip_read!=NULL)

816

unzCloseCurrentFile(file);

817

818

ZCLOSE64(s->z_filefunc, s->filestream);

819

TRYFREE(s);

820

return UNZ_OK;

821

}

822

823

824

825

Write info about the ZipFile in the *pglobal_info structure.

826

No preparation of the structure is needed

827

return UNZ_OK if there is no problem. */

828

extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)

829

{

830

unz64_s* s;

831

if (file==NULL)

832

return UNZ_PARAMERROR;

833

s=(unz64_s*)file;

834

*pglobal_info=s->gi;

835

return UNZ_OK;

836

}

837

838

extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)

839

{

840

unz64_s* s;

841

if (file==NULL)

842

return UNZ_PARAMERROR;

843

s=(unz64_s*)file;

844

/* to do : check if number_entry is not truncated */

845

pglobal_info32->number_entry = (uLong)s->gi.number_entry;

846

pglobal_info32->size_comment = s->gi.size_comment;

847

return UNZ_OK;

848

}

849

850

Translate date/time from Dos format to tm_unz (readable more easilty)

851

852

local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)

853

{

854

ZPOS64_T uDate;

855

uDate = (ZPOS64_T)(ulDosDate>>16);

856

ptm->tm_mday = (uInt)(uDate&0x1f) ;

857

ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;

858

ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;

859

860

ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);

861

ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;

862

ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;

863

}

864

865

866

Get Info about the current file in the zipfile, with internal only info

867

868

local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,

869

unz_file_info64 *pfile_info,

870

unz_file_info64_internal

871

*pfile_info_internal,

872

char *szFileName,

873

uLong fileNameBufferSize,

874

void *extraField,

875

uLong extraFieldBufferSize,

876

char *szComment,

877

uLong commentBufferSize));

878

879

local int unz64local_GetCurrentFileInfoInternal (unzFile file,

880

unz_file_info64 *pfile_info,

881

unz_file_info64_internal

882

*pfile_info_internal,

883

char *szFileName,

884

uLong fileNameBufferSize,

885

void *extraField,

886

uLong extraFieldBufferSize,

887

char *szComment,

888

uLong commentBufferSize)

889

{

890

unz64_s* s;

891

unz_file_info64 file_info;

892

unz_file_info64_internal file_info_internal;

893

int err=UNZ_OK;

894

uLong uMagic;

895

long lSeek=0;

896

uLong uL;

897

898

if (file==NULL)

899

return UNZ_PARAMERROR;

900

s=(unz64_s*)file;

901

if (ZSEEK64(s->z_filefunc, s->filestream,

902

s->pos_in_central_dir+s->byte_before_the_zipfile,

903

ZLIB_FILEFUNC_SEEK_SET)!=0)

904

err=UNZ_ERRNO;

905

906

907

/* we check the magic */

908

if (err==UNZ_OK)

909

{

910

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)

911

err=UNZ_ERRNO;

912

else if (uMagic!=0x02014b50)

913

err=UNZ_BADZIPFILE;

914

}

915

916

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)

917

err=UNZ_ERRNO;

918

919

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)

920

err=UNZ_ERRNO;

921

922

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)

923

err=UNZ_ERRNO;

924

925

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)

926

err=UNZ_ERRNO;

927

928

if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)

929

err=UNZ_ERRNO;

930

931

unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);

932

933

if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)

934

err=UNZ_ERRNO;

935

936

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

937

err=UNZ_ERRNO;

938

file_info.compressed_size = uL;

939

940

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

941

err=UNZ_ERRNO;

942

file_info.uncompressed_size = uL;

943

944

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)

945

err=UNZ_ERRNO;

946

947

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)

948

err=UNZ_ERRNO;

949

950

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)

951

err=UNZ_ERRNO;

952

953

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)

954

err=UNZ_ERRNO;

955

956

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)

957

err=UNZ_ERRNO;

958

959

if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)

960

err=UNZ_ERRNO;

961

962

// relative offset of local header

963

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

964

err=UNZ_ERRNO;

965

file_info_internal.offset_curfile = uL;

966

967

lSeek+=file_info.size_filename;

968

if ((err==UNZ_OK) && (szFileName!=NULL))

969

{

970

uLong uSizeRead ;

971

if (file_info.size_filename<fileNameBufferSize)

972

{

973

*(szFileName+file_info.size_filename)='\0';

974

uSizeRead = file_info.size_filename;

975

}

976

else

977

uSizeRead = fileNameBufferSize;

978

979

if ((file_info.size_filename>0) && (fileNameBufferSize>0))

980

if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)

981

err=UNZ_ERRNO;

982

lSeek -= uSizeRead;

983

}

984

985

// Read extrafield

986

if ((err==UNZ_OK) && (extraField!=NULL))

987

{

988

ZPOS64_T uSizeRead ;

989

if (file_info.size_file_extra<extraFieldBufferSize)

990

uSizeRead = file_info.size_file_extra;

991

else

992

uSizeRead = extraFieldBufferSize;

993

994

if (lSeek!=0)

995

{

996

if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

997

lSeek=0;

998

else

999

err=UNZ_ERRNO;

1000

}

1001

1002

if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))

1003

if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)

1004

err=UNZ_ERRNO;

1005

1006

lSeek += file_info.size_file_extra - (uLong)uSizeRead;

1007

}

1008

else

1009

lSeek += file_info.size_file_extra;

1010

1011

1012

if ((err==UNZ_OK) && (file_info.size_file_extra != 0))

1013

{

1014

uLong acc = 0;

1015

1016

// since lSeek now points to after the extra field we need to move back

1017

lSeek -= file_info.size_file_extra;

1018

1019

if (lSeek!=0)

1020

{

1021

if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

1022

lSeek=0;

1023

else

1024

err=UNZ_ERRNO;

1025

}

1026

1027

while(acc < file_info.size_file_extra)

1028

{

1029

uLong headerId;

1030

uLong dataSize;

1031

1032

if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)

1033

err=UNZ_ERRNO;

1034

1035

if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)

1036

err=UNZ_ERRNO;

1037

1038

/* ZIP64 extra fields */

1039

if (headerId == 0x0001)

1040

{

1041

uLong uL;

1042

1043

if(file_info.uncompressed_size == (ZPOS64_T)(unsigned long)-1)

1044

{

1045

if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)

1046

err=UNZ_ERRNO;

1047

}

1048

1049

if(file_info.compressed_size == (ZPOS64_T)(unsigned long)-1)

1050

{

1051

if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)

1052

err=UNZ_ERRNO;

1053

}

1054

1055

if(file_info_internal.offset_curfile == (ZPOS64_T)(unsigned long)-1)

1056

{

1057

/* Relative Header offset */

1058

if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)

1059

err=UNZ_ERRNO;

1060

}

1061

1062

if(file_info.disk_num_start == (unsigned long)-1)

1063

{

1064

/* Disk Start Number */

1065

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

1066

err=UNZ_ERRNO;

1067

}

1068

1069

}

1070

else

1071

{

1072

if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)

1073

err=UNZ_ERRNO;

1074

}

1075

1076

acc += 2 + 2 + dataSize;

1077

}

1078

}

1079

1080

if ((err==UNZ_OK) && (szComment!=NULL))

1081

{

1082

uLong uSizeRead ;

1083

if (file_info.size_file_comment<commentBufferSize)

1084

{

1085

*(szComment+file_info.size_file_comment)='\0';

1086

uSizeRead = file_info.size_file_comment;

1087

}

1088

else

1089

uSizeRead = commentBufferSize;

1090

1091

if (lSeek!=0)

1092

{

1093

if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

1094

lSeek=0;

1095

else

1096

err=UNZ_ERRNO;

1097

}

1098

1099

if ((file_info.size_file_comment>0) && (commentBufferSize>0))

1100

if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)

1101

err=UNZ_ERRNO;

1102

lSeek+=file_info.size_file_comment - uSizeRead;

1103

}

1104

else

1105

lSeek+=file_info.size_file_comment;

1106

1107

1108

if ((err==UNZ_OK) && (pfile_info!=NULL))

1109

*pfile_info=file_info;

1110

1111

if ((err==UNZ_OK) && (pfile_info_internal!=NULL))

1112

*pfile_info_internal=file_info_internal;

1113

1114

return err;

1115

}

1116

1117

1118

1119

1120

Write info about the ZipFile in the *pglobal_info structure.

1121

No preparation of the structure is needed

1122

return UNZ_OK if there is no problem.

1123

1124

extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,

1125

unz_file_info64 * pfile_info,

1126

char * szFileName, uLong fileNameBufferSize,

1127

void *extraField, uLong extraFieldBufferSize,

1128

char* szComment, uLong commentBufferSize)

1129

{

1130

return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,

1131

szFileName,fileNameBufferSize,

1132

extraField,extraFieldBufferSize,

1133

szComment,commentBufferSize);

1134

}

1135

1136

extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,

1137

unz_file_info * pfile_info,

1138

char * szFileName, uLong fileNameBufferSize,

1139

void *extraField, uLong extraFieldBufferSize,

1140

char* szComment, uLong commentBufferSize)

1141

{

1142

int err;

1143

unz_file_info64 file_info64;

1144

err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,

1145

szFileName,fileNameBufferSize,

1146

extraField,extraFieldBufferSize,

1147

szComment,commentBufferSize);

1148

if (err==UNZ_OK)

1149

{

1150

pfile_info->version = file_info64.version;

1151

pfile_info->version_needed = file_info64.version_needed;

1152

pfile_info->flag = file_info64.flag;

1153

pfile_info->compression_method = file_info64.compression_method;

1154

pfile_info->dosDate = file_info64.dosDate;

1155

pfile_info->crc = file_info64.crc;

1156

1157

pfile_info->size_filename = file_info64.size_filename;

1158

pfile_info->size_file_extra = file_info64.size_file_extra;

1159

pfile_info->size_file_comment = file_info64.size_file_comment;

1160

1161

pfile_info->disk_num_start = file_info64.disk_num_start;

1162

pfile_info->internal_fa = file_info64.internal_fa;

1163

pfile_info->external_fa = file_info64.external_fa;

1164

1165

pfile_info->tmu_date = file_info64.tmu_date,

1166

1167

1168

pfile_info->compressed_size = (uLong)file_info64.compressed_size;

1169

pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;

1170

1171

}

1172

return err;

1173

}

1174

1175

Set the current file of the zipfile to the first file.

1176

return UNZ_OK if there is no problem

1177

1178

extern int ZEXPORT unzGoToFirstFile (unzFile file)

1179

{

1180

int err=UNZ_OK;

1181

unz64_s* s;

1182

if (file==NULL)

1183

return UNZ_PARAMERROR;

1184

s=(unz64_s*)file;

1185

s->pos_in_central_dir=s->offset_central_dir;

1186

s->num_file=0;

1187

err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

1188

&s->cur_file_info_internal,

1189

NULL,0,NULL,0,NULL,0);

1190

s->current_file_ok = (err == UNZ_OK);

1191

return err;

1192

}

1193

1194

1195

Set the current file of the zipfile to the next file.

1196

return UNZ_OK if there is no problem

1197

return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.

1198

1199

extern int ZEXPORT unzGoToNextFile (unzFile file)

1200

{

1201

unz64_s* s;

1202

int err;

1203

1204

if (file==NULL)

1205

return UNZ_PARAMERROR;

1206

s=(unz64_s*)file;

1207

if (!s->current_file_ok)

1208

return UNZ_END_OF_LIST_OF_FILE;

1209

if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */

1210

if (s->num_file+1==s->gi.number_entry)

1211

return UNZ_END_OF_LIST_OF_FILE;

1212

1213

s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +

1214

s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;

1215

s->num_file++;

1216

err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

1217

&s->cur_file_info_internal,

1218

NULL,0,NULL,0,NULL,0);

1219

s->current_file_ok = (err == UNZ_OK);

1220

return err;

1221

}

1222

1223

1224

1225

Try locate the file szFileName in the zipfile.

1226

For the iCaseSensitivity signification, see unzipStringFileNameCompare

1227

1228

return value :

1229

UNZ_OK if the file is found. It becomes the current file.

1230

UNZ_END_OF_LIST_OF_FILE if the file is not found

1231

1232

extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)

1233

{

1234

unz64_s* s;

1235

int err;

1236

1237

/* We remember the 'current' position in the file so that we can jump

1238

* back there if we fail.

1239

1240

unz_file_info64 cur_file_infoSaved;

1241

unz_file_info64_internal cur_file_info_internalSaved;

1242

ZPOS64_T num_fileSaved;

1243

ZPOS64_T pos_in_central_dirSaved;

1244

1245

1246

if (file==NULL)

1247

return UNZ_PARAMERROR;

1248

1249

if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)

1250

return UNZ_PARAMERROR;

1251

1252

s=(unz64_s*)file;

1253

if (!s->current_file_ok)

1254

return UNZ_END_OF_LIST_OF_FILE;

1255

1256

/* Save the current state */

1257

num_fileSaved = s->num_file;

1258

pos_in_central_dirSaved = s->pos_in_central_dir;

1259

cur_file_infoSaved = s->cur_file_info;

1260

cur_file_info_internalSaved = s->cur_file_info_internal;

1261

1262

err = unzGoToFirstFile(file);

1263

1264

while (err == UNZ_OK)

1265

{

1266

char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];

1267

err = unzGetCurrentFileInfo64(file,NULL,

1268

szCurrentFileName,sizeof(szCurrentFileName)-1,

1269

NULL,0,NULL,0);

1270

if (err == UNZ_OK)

1271

{

1272

if (unzStringFileNameCompare(szCurrentFileName,

1273

szFileName,iCaseSensitivity)==0)

1274

return UNZ_OK;

1275

err = unzGoToNextFile(file);

1276

}

1277

}

1278

1279

/* We failed, so restore the state of the 'current file' to where we

1280

* were.

1281

1282

s->num_file = num_fileSaved ;

1283

s->pos_in_central_dir = pos_in_central_dirSaved ;

1284

s->cur_file_info = cur_file_infoSaved;

1285

s->cur_file_info_internal = cur_file_info_internalSaved;

1286

return err;

1287

}

1288

1289

1290

1291

///////////////////////////////////////////

1292

// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)

1293

// I need random access

1294

1295

// Further optimization could be realized by adding an ability

1296

// to cache the directory in memory. The goal being a single

1297

// comprehensive file read to put the file I need in a memory.

1298

1299

1300

1301

typedef struct unz_file_pos_s

1302

{

1303

ZPOS64_T pos_in_zip_directory; // offset in file

1304

ZPOS64_T num_of_file; // # of file

1305

} unz_file_pos;

1306

1307

1308

extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)

1309

{

1310

unz64_s* s;

1311

1312

if (file==NULL || file_pos==NULL)

1313

return UNZ_PARAMERROR;

1314

s=(unz64_s*)file;

1315

if (!s->current_file_ok)

1316

return UNZ_END_OF_LIST_OF_FILE;

1317

1318

file_pos->pos_in_zip_directory = s->pos_in_central_dir;

1319

file_pos->num_of_file = s->num_file;

1320

1321

return UNZ_OK;

1322

}

1323

1324

extern int ZEXPORT unzGetFilePos(

1325

unzFile file,

1326

unz_file_pos* file_pos)

1327

{

1328

unz64_file_pos file_pos64;

1329

int err = unzGetFilePos64(file,&file_pos64);

1330

if (err==UNZ_OK)

1331

{

1332

file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;

1333

file_pos->num_of_file = (uLong)file_pos64.num_of_file;

1334

}

1335

return err;

1336

}

1337

1338

extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)

1339

{

1340

unz64_s* s;

1341

int err;

1342

1343

if (file==NULL || file_pos==NULL)

1344

return UNZ_PARAMERROR;

1345

s=(unz64_s*)file;

1346

1347

/* jump to the right spot */

1348

s->pos_in_central_dir = file_pos->pos_in_zip_directory;

1349

s->num_file = file_pos->num_of_file;

1350

1351

/* set the current file */

1352

err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

1353

&s->cur_file_info_internal,

1354

NULL,0,NULL,0,NULL,0);

1355

/* return results */

1356

s->current_file_ok = (err == UNZ_OK);

1357

return err;

1358

}

1359

1360

extern int ZEXPORT unzGoToFilePos(

1361

unzFile file,

1362

unz_file_pos* file_pos)

1363

{

1364

unz64_file_pos file_pos64;

1365

if (file_pos == NULL)

1366

return UNZ_PARAMERROR;

1367

1368

file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;

1369

file_pos64.num_of_file = file_pos->num_of_file;

1370

return unzGoToFilePos64(file,&file_pos64);

1371

}

1372

1373

1374

// Unzip Helper Functions - should be here?

1375

///////////////////////////////////////////

1376

1377

1378

1379

Read the local header of the current zipfile

1380

Check the coherency of the local header and info in the end of central

1381

directory about this file

1382

store in *piSizeVar the size of extra info in local header

1383

(filename and size of extra field data)

1384

1385

local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,

1386

ZPOS64_T * poffset_local_extrafield,

1387

uInt * psize_local_extrafield)

1388

{

1389

uLong uMagic,uData,uFlags;

1390

uLong size_filename;

1391

uLong size_extra_field;

1392

int err=UNZ_OK;

1393

1394

*piSizeVar = 0;

1395

*poffset_local_extrafield = 0;

1396

*psize_local_extrafield = 0;

1397

1398

if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +

1399

s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)

1400

return UNZ_ERRNO;

1401

1402

1403

if (err==UNZ_OK)

1404

{

1405

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)

1406

err=UNZ_ERRNO;

1407

else if (uMagic!=0x04034b50)

1408

err=UNZ_BADZIPFILE;

1409

}

1410

1411

if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)

1412

err=UNZ_ERRNO;

1413

1414

else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))

1415

err=UNZ_BADZIPFILE;

1416

1417

if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)

1418

err=UNZ_ERRNO;

1419

1420

if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)

1421

err=UNZ_ERRNO;

1422

else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))

1423

err=UNZ_BADZIPFILE;

1424

1425

if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&

1426

/* #ifdef HAVE_BZIP2 */

1427

(s->cur_file_info.compression_method!=Z_BZIP2ED) &&

1428

/* #endif */

1429

(s->cur_file_info.compression_method!=Z_DEFLATED))

1430

err=UNZ_BADZIPFILE;

1431

1432

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */

1433

err=UNZ_ERRNO;

1434

1435

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */

1436

err=UNZ_ERRNO;

1437

else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))

1438

err=UNZ_BADZIPFILE;

1439

1440

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */

1441

err=UNZ_ERRNO;

1442

else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))

1443

err=UNZ_BADZIPFILE;

1444

1445

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */

1446

err=UNZ_ERRNO;

1447

else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))

1448

err=UNZ_BADZIPFILE;

1449

1450

if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)

1451

err=UNZ_ERRNO;

1452

else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))

1453

err=UNZ_BADZIPFILE;

1454

1455

*piSizeVar += (uInt)size_filename;

1456

1457

if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)

1458

err=UNZ_ERRNO;

1459

*poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +

1460

SIZEZIPLOCALHEADER + size_filename;

1461

*psize_local_extrafield = (uInt)size_extra_field;

1462

1463

*piSizeVar += (uInt)size_extra_field;

1464

1465

return err;

1466

}

1467

1468

1469

Open for reading data the current file in the zipfile.

1470

If there is no error and the file is opened, the return value is UNZ_OK.

1471

1472

extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,

1473

int* level, int raw, const char* password)

1474

{

1475

int err=UNZ_OK;

1476

uInt iSizeVar;

1477

unz64_s* s;

1478

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1479

ZPOS64_T offset_local_extrafield; /* offset of the local extra field */

1480

uInt size_local_extrafield; /* size of the local extra field */

1481

# ifndef NOUNCRYPT

1482

char source[12];

1483

# else

1484

if (password != NULL)

1485

return UNZ_PARAMERROR;

1486

# endif

1487

1488

if (file==NULL)

1489

return UNZ_PARAMERROR;

1490

s=(unz64_s*)file;

1491

if (!s->current_file_ok)

1492

return UNZ_PARAMERROR;

1493

1494

if (s->pfile_in_zip_read != NULL)

1495

unzCloseCurrentFile(file);

1496

1497

if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)

1498

return UNZ_BADZIPFILE;

1499

1500

pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));

1501

if (pfile_in_zip_read_info==NULL)

1502

return UNZ_INTERNALERROR;

1503

1504

pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);

1505

pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;

1506

pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;

1507

pfile_in_zip_read_info->pos_local_extrafield=0;

1508

pfile_in_zip_read_info->raw=raw;

1509

1510

if (pfile_in_zip_read_info->read_buffer==NULL)

1511

{

1512

TRYFREE(pfile_in_zip_read_info);

1513

return UNZ_INTERNALERROR;

1514

}

1515

1516

pfile_in_zip_read_info->stream_initialised=0;

1517

1518

if (method!=NULL)

1519

*method = (int)s->cur_file_info.compression_method;

1520

1521

if (level!=NULL)

1522

{

1523

*level = 6;

1524

switch (s->cur_file_info.flag & 0x06)

1525

{

1526

case 6 : *level = 1; break;

1527

case 4 : *level = 2; break;

1528

case 2 : *level = 9; break;

1529

}

1530

}

1531

1532

if ((s->cur_file_info.compression_method!=0) &&

1533

/* #ifdef HAVE_BZIP2 */

1534

(s->cur_file_info.compression_method!=Z_BZIP2ED) &&

1535

/* #endif */

1536

(s->cur_file_info.compression_method!=Z_DEFLATED))

1537

1538

err=UNZ_BADZIPFILE;

1539

1540

pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;

1541

pfile_in_zip_read_info->crc32=0;

1542

pfile_in_zip_read_info->total_out_64=0;

1543

pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;

1544

pfile_in_zip_read_info->filestream=s->filestream;

1545

pfile_in_zip_read_info->z_filefunc=s->z_filefunc;

1546

pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;

1547

1548

pfile_in_zip_read_info->stream.total_out = 0;

1549

1550

if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))

1551

{

1552

#ifdef HAVE_BZIP2

1553

pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;

1554

pfile_in_zip_read_info->bstream.bzfree = (free_func)0;

1555

pfile_in_zip_read_info->bstream.opaque = (voidpf)0;

1556

pfile_in_zip_read_info->bstream.state = (voidpf)0;

1557

1558

pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;

1559

pfile_in_zip_read_info->stream.zfree = (free_func)0;

1560

pfile_in_zip_read_info->stream.opaque = (voidpf)0;

1561

pfile_in_zip_read_info->stream.next_in = (voidpf)0;

1562

pfile_in_zip_read_info->stream.avail_in = 0;

1563

1564

err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);

1565

if (err == Z_OK)

1566

pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;

1567

else

1568

{

1569

TRYFREE(pfile_in_zip_read_info);

1570

return err;

1571

}

1572

#else

1573

pfile_in_zip_read_info->raw=1;

1574

#endif

1575

}

1576

else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))

1577

{

1578

pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;

1579

pfile_in_zip_read_info->stream.zfree = (free_func)0;

1580

pfile_in_zip_read_info->stream.opaque = (voidpf)0;

1581

pfile_in_zip_read_info->stream.next_in = 0;

1582

pfile_in_zip_read_info->stream.avail_in = 0;

1583

1584

err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);

1585

if (err == Z_OK)

1586

pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;

1587

else

1588

{

1589

TRYFREE(pfile_in_zip_read_info);

1590

return err;

1591

}

1592

/* windowBits is passed < 0 to tell that there is no zlib header.

1593

* Note that in this case inflate *requires* an extra "dummy" byte

1594

* after the compressed stream in order to complete decompression and

1595

* return Z_STREAM_END.

1596

* In unzip, i don't wait absolutely Z_STREAM_END because I known the

1597

* size of both compressed and uncompressed data

1598

1599

}

1600

pfile_in_zip_read_info->rest_read_compressed =

1601

s->cur_file_info.compressed_size ;

1602

pfile_in_zip_read_info->rest_read_uncompressed =

1603

s->cur_file_info.uncompressed_size ;

1604

1605

1606

pfile_in_zip_read_info->pos_in_zipfile =

1607

s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +

1608

iSizeVar;

1609

1610

pfile_in_zip_read_info->stream.avail_in = (uInt)0;

1611

1612

s->pfile_in_zip_read = pfile_in_zip_read_info;

1613

s->encrypted = 0;

1614

1615

# ifndef NOUNCRYPT

1616

if (password != NULL)

1617

{

1618

int i;

1619

s->pcrc_32_tab = get_crc_table();

1620

init_keys(password,s->keys,s->pcrc_32_tab);

1621

if (ZSEEK64(s->z_filefunc, s->filestream,

1622

s->pfile_in_zip_read->pos_in_zipfile +

1623

s->pfile_in_zip_read->byte_before_the_zipfile,

1624

SEEK_SET)!=0)

1625

return UNZ_INTERNALERROR;

1626

if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)

1627

return UNZ_INTERNALERROR;

1628

1629

for (i = 0; i<12; i++)

1630

zdecode(s->keys,s->pcrc_32_tab,source[i]);

1631

1632

s->pfile_in_zip_read->pos_in_zipfile+=12;

1633

s->encrypted=1;

1634

}

1635

# endif

1636

1637

1638

return UNZ_OK;

1639

}

1640

1641

extern int ZEXPORT unzOpenCurrentFile (unzFile file)

1642

{

1643

return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);

1644

}

1645

1646

extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password)

1647

{

1648

return unzOpenCurrentFile3(file, NULL, NULL, 0, password);

1649

}

1650

1651

extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)

1652

{

1653

return unzOpenCurrentFile3(file, method, level, raw, NULL);

1654

}

1655

1656

/** Addition for GDAL : START */

1657

1658

extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)

1659

{

1660

unz64_s* s;

1661

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1662

s=(unz64_s*)file;

1663

if (file==NULL)

1664

return 0; //UNZ_PARAMERROR;

1665

pfile_in_zip_read_info=s->pfile_in_zip_read;

1666

if (pfile_in_zip_read_info==NULL)

1667

return 0; //UNZ_PARAMERROR;

1668

return pfile_in_zip_read_info->pos_in_zipfile +

1669

pfile_in_zip_read_info->byte_before_the_zipfile;

1670

}

1671

1672

/** Addition for GDAL : END */

1673

1674

1675

Read bytes from the current file.

1676

buf contain buffer where data must be copied

1677

len the size of buf.

1678

1679

return the number of byte copied if somes bytes are copied

1680

return 0 if the end of file was reached

1681

return <0 with error code if there is an error

1682

(UNZ_ERRNO for IO error, or zLib error for uncompress error)

1683

1684

extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)

1685

{

1686

int err=UNZ_OK;

1687

uInt iRead = 0;

1688

unz64_s* s;

1689

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1690

if (file==NULL)

1691

return UNZ_PARAMERROR;

1692

s=(unz64_s*)file;

1693

pfile_in_zip_read_info=s->pfile_in_zip_read;

1694

1695

if (pfile_in_zip_read_info==NULL)

1696

return UNZ_PARAMERROR;

1697

1698

1699

if ((pfile_in_zip_read_info->read_buffer == NULL))

1700

return UNZ_END_OF_LIST_OF_FILE;

1701

if (len==0)

1702

return 0;

1703

1704

pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;

1705

1706

pfile_in_zip_read_info->stream.avail_out = (uInt)len;

1707

1708

if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&

1709

(!(pfile_in_zip_read_info->raw)))

1710

pfile_in_zip_read_info->stream.avail_out =

1711

(uInt)pfile_in_zip_read_info->rest_read_uncompressed;

1712

1713

if ((len>pfile_in_zip_read_info->rest_read_compressed+

1714

pfile_in_zip_read_info->stream.avail_in) &&

1715

(pfile_in_zip_read_info->raw))

1716

pfile_in_zip_read_info->stream.avail_out =

1717

(uInt)pfile_in_zip_read_info->rest_read_compressed+

1718

pfile_in_zip_read_info->stream.avail_in;

1719

1720

while (pfile_in_zip_read_info->stream.avail_out>0)

1721

{

1722

if ((pfile_in_zip_read_info->stream.avail_in==0) &&

1723

(pfile_in_zip_read_info->rest_read_compressed>0))

1724

{

1725

uInt uReadThis = UNZ_BUFSIZE;

1726

if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)

1727

uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;

1728

if (uReadThis == 0)

1729

return UNZ_EOF;

1730

if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,

1731

pfile_in_zip_read_info->filestream,

1732

pfile_in_zip_read_info->pos_in_zipfile +

1733

pfile_in_zip_read_info->byte_before_the_zipfile,

1734

ZLIB_FILEFUNC_SEEK_SET)!=0)

1735

return UNZ_ERRNO;

1736

if (ZREAD64(pfile_in_zip_read_info->z_filefunc,

1737

pfile_in_zip_read_info->filestream,

1738

pfile_in_zip_read_info->read_buffer,

1739

uReadThis)!=uReadThis)

1740

return UNZ_ERRNO;

1741

1742

1743

# ifndef NOUNCRYPT

1744

if(s->encrypted)

1745

{

1746

uInt i;

1747

for(i=0;i<uReadThis;i++)

1748

pfile_in_zip_read_info->read_buffer[i] =

1749

zdecode(s->keys,s->pcrc_32_tab,

1750

pfile_in_zip_read_info->read_buffer[i]);

1751

}

1752

# endif

1753

1754

1755

pfile_in_zip_read_info->pos_in_zipfile += uReadThis;

1756

1757

pfile_in_zip_read_info->rest_read_compressed-=uReadThis;

1758

1759

pfile_in_zip_read_info->stream.next_in =

1760

(Bytef*)pfile_in_zip_read_info->read_buffer;

1761

pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;

1762

}

1763

1764

if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))

1765

{

1766

uInt uDoCopy,i ;

1767

1768

if ((pfile_in_zip_read_info->stream.avail_in == 0) &&

1769

(pfile_in_zip_read_info->rest_read_compressed == 0))

1770

return (iRead==0) ? UNZ_EOF : iRead;

1771

1772

if (pfile_in_zip_read_info->stream.avail_out <

1773

pfile_in_zip_read_info->stream.avail_in)

1774

uDoCopy = pfile_in_zip_read_info->stream.avail_out ;

1775

else

1776

uDoCopy = pfile_in_zip_read_info->stream.avail_in ;

1777

1778

for (i=0;i<uDoCopy;i++)

1779

*(pfile_in_zip_read_info->stream.next_out+i) =

1780

*(pfile_in_zip_read_info->stream.next_in+i);

1781

1782

pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;

1783

1784

pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,

1785

pfile_in_zip_read_info->stream.next_out,

1786

uDoCopy);

1787

pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;

1788

pfile_in_zip_read_info->stream.avail_in -= uDoCopy;

1789

pfile_in_zip_read_info->stream.avail_out -= uDoCopy;

1790

pfile_in_zip_read_info->stream.next_out += uDoCopy;

1791

pfile_in_zip_read_info->stream.next_in += uDoCopy;

1792

pfile_in_zip_read_info->stream.total_out += uDoCopy;

1793

iRead += uDoCopy;

1794

}

1795

else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)

1796

{

1797

#ifdef HAVE_BZIP2

1798

uLong uTotalOutBefore,uTotalOutAfter;

1799

const Bytef *bufBefore;

1800

uLong uOutThis;

1801

1802

pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in;

1803

pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in;

1804

pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in;

1805

pfile_in_zip_read_info->bstream.total_in_hi32 = 0;

1806

pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out;

1807

pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out;

1808

pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;

1809

pfile_in_zip_read_info->bstream.total_out_hi32 = 0;

1810

1811

uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;

1812

bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;

1813

1814

err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);

1815

1816

uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;

1817

uOutThis = uTotalOutAfter-uTotalOutBefore;

1818

1819

pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;

1820

1821

pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));

1822

pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;

1823

iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);

1824

1825

pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in;

1826

pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in;

1827

pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32;

1828

pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out;

1829

pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;

1830

pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;

1831

1832

if (err==BZ_STREAM_END)

1833

return (iRead==0) ? UNZ_EOF : iRead;

1834

if (err!=BZ_OK)

1835

break;

1836

#endif

1837

} // end Z_BZIP2ED

1838

else

1839

{

1840

ZPOS64_T uTotalOutBefore,uTotalOutAfter;

1841

const Bytef *bufBefore;

1842

ZPOS64_T uOutThis;

1843

int flush=Z_SYNC_FLUSH;

1844

1845

uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;

1846

bufBefore = pfile_in_zip_read_info->stream.next_out;

1847

1848

1849

if ((pfile_in_zip_read_info->rest_read_uncompressed ==

1850

pfile_in_zip_read_info->stream.avail_out) &&

1851

(pfile_in_zip_read_info->rest_read_compressed == 0))

1852

flush = Z_FINISH;

1853

1854

err=inflate(&pfile_in_zip_read_info->stream,flush);

1855

1856

if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))

1857

err = Z_DATA_ERROR;

1858

1859

uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;

1860

uOutThis = uTotalOutAfter-uTotalOutBefore;

1861

1862

pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;

1863

1864

pfile_in_zip_read_info->crc32 =

1865

crc32(pfile_in_zip_read_info->crc32,bufBefore,

1866

(uInt)(uOutThis));

1867

1868

pfile_in_zip_read_info->rest_read_uncompressed -=

1869

uOutThis;

1870

1871

iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);

1872

1873

if (err==Z_STREAM_END)

1874

return (iRead==0) ? UNZ_EOF : iRead;

1875

if (err!=Z_OK)

1876

break;

1877

}

1878

}

1879

1880

if (err==Z_OK)

1881

return iRead;

1882

return err;

1883

}

1884

1885

1886

1887

Give the current position in uncompressed data

1888

1889

extern z_off_t ZEXPORT unztell (unzFile file)

1890

{

1891

unz64_s* s;

1892

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1893

if (file==NULL)

1894

return UNZ_PARAMERROR;

1895

s=(unz64_s*)file;

1896

pfile_in_zip_read_info=s->pfile_in_zip_read;

1897

1898

if (pfile_in_zip_read_info==NULL)

1899

return UNZ_PARAMERROR;

1900

1901

return (z_off_t)pfile_in_zip_read_info->stream.total_out;

1902

}

1903

1904

extern ZPOS64_T ZEXPORT unztell64 (unzFile file)

1905

{

1906

1907

unz64_s* s;

1908

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1909

if (file==NULL)

1910

return (ZPOS64_T)-1;

1911

s=(unz64_s*)file;

1912

pfile_in_zip_read_info=s->pfile_in_zip_read;

1913

1914

if (pfile_in_zip_read_info==NULL)

1915

return (ZPOS64_T)-1;

1916

1917

return pfile_in_zip_read_info->total_out_64;

1918

}

1919

1920

1921

1922

return 1 if the end of file was reached, 0 elsewhere

1923

1924

extern int ZEXPORT unzeof (unzFile file)

1925

{

1926

unz64_s* s;

1927

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1928

if (file==NULL)

1929

return UNZ_PARAMERROR;

1930

s=(unz64_s*)file;

1931

pfile_in_zip_read_info=s->pfile_in_zip_read;

1932

1933

if (pfile_in_zip_read_info==NULL)

1934

return UNZ_PARAMERROR;

1935

1936

if (pfile_in_zip_read_info->rest_read_uncompressed == 0)

1937

return 1;

1938

else

1939

return 0;

1940

}

1941

1942

1943

1944

1945

Read extra field from the current file (opened by unzOpenCurrentFile)

1946

This is the local-header version of the extra field (sometimes, there is

1947

more info in the local-header version than in the central-header)

1948

1949

if buf==NULL, it return the size of the local extra field that can be read

1950

1951

if buf!=NULL, len is the size of the buffer, the extra header is copied in

1952

buf.

1953

the return value is the number of bytes copied in buf, or (if <0)

1954

the error code

1955

1956

extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)

1957

{

1958

unz64_s* s;

1959

file_in_zip64_read_info_s* pfile_in_zip_read_info;

1960

uInt read_now;

1961

ZPOS64_T size_to_read;

1962

1963

if (file==NULL)

1964

return UNZ_PARAMERROR;

1965

s=(unz64_s*)file;

1966

pfile_in_zip_read_info=s->pfile_in_zip_read;

1967

1968

if (pfile_in_zip_read_info==NULL)

1969

return UNZ_PARAMERROR;

1970

1971

size_to_read = (pfile_in_zip_read_info->size_local_extrafield -

1972

pfile_in_zip_read_info->pos_local_extrafield);

1973

1974

if (buf==NULL)

1975

return (int)size_to_read;

1976

1977

if (len>size_to_read)

1978

read_now = (uInt)size_to_read;

1979

else

1980

read_now = (uInt)len ;

1981

1982

if (read_now==0)

1983

return 0;

1984

1985

if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,

1986

pfile_in_zip_read_info->filestream,

1987

pfile_in_zip_read_info->offset_local_extrafield +

1988

pfile_in_zip_read_info->pos_local_extrafield,

1989

ZLIB_FILEFUNC_SEEK_SET)!=0)

1990

return UNZ_ERRNO;

1991

1992

if (ZREAD64(pfile_in_zip_read_info->z_filefunc,

1993

pfile_in_zip_read_info->filestream,

1994

buf,read_now)!=read_now)

1995

return UNZ_ERRNO;

1996

1997

return (int)read_now;

1998

}

1999

2000

2001

Close the file in zip opened with unzipOpenCurrentFile

2002

Return UNZ_CRCERROR if all the file was read but the CRC is not good

2003

2004

extern int ZEXPORT unzCloseCurrentFile (unzFile file)

2005

{

2006

int err=UNZ_OK;

2007

2008

unz64_s* s;

2009

file_in_zip64_read_info_s* pfile_in_zip_read_info;

2010

if (file==NULL)

2011

return UNZ_PARAMERROR;

2012

s=(unz64_s*)file;

2013

pfile_in_zip_read_info=s->pfile_in_zip_read;

2014

2015

if (pfile_in_zip_read_info==NULL)

2016

return UNZ_PARAMERROR;

2017

2018

2019

if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&

2020

(!pfile_in_zip_read_info->raw))

2021

{

2022

if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)

2023

err=UNZ_CRCERROR;

2024

}

2025

2026

2027

TRYFREE(pfile_in_zip_read_info->read_buffer);

2028

pfile_in_zip_read_info->read_buffer = NULL;

2029

if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)

2030

inflateEnd(&pfile_in_zip_read_info->stream);

2031

#ifdef HAVE_BZIP2

2032

else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)

2033

BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);

2034

#endif

2035

2036

2037

pfile_in_zip_read_info->stream_initialised = 0;

2038

TRYFREE(pfile_in_zip_read_info);

2039

2040

s->pfile_in_zip_read=NULL;

2041

2042

return err;

2043

}

2044

2045

2046

2047

Get the global comment string of the ZipFile, in the szComment buffer.

2048

uSizeBuf is the size of the szComment buffer.

2049

return the number of byte copied or an error code <0

2050

2051

extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)

2052

{

2053

unz64_s* s;

2054

uLong uReadThis ;

2055

if (file==NULL)

2056

return (int)UNZ_PARAMERROR;

2057

s=(unz64_s*)file;

2058

2059

uReadThis = uSizeBuf;

2060

if (uReadThis>s->gi.size_comment)

2061

uReadThis = s->gi.size_comment;

2062

2063

if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)

2064

return UNZ_ERRNO;

2065

2066

if (uReadThis>0)

2067

{

2068

*szComment='\0';

2069

if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)

2070

return UNZ_ERRNO;

2071

}

2072

2073

if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))

2074

*(szComment+s->gi.size_comment)='\0';

2075

return (int)uReadThis;

2076

}

2077

2078

/* Additions by RX '2004 */

2079

extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)

2080

{

2081

unz64_s* s;

2082

2083

if (file==NULL)

2084

return 0; //UNZ_PARAMERROR;

2085

s=(unz64_s*)file;

2086

if (!s->current_file_ok)

2087

return 0;

2088

if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)

2089

if (s->num_file==s->gi.number_entry)

2090

return 0;

2091

return s->pos_in_central_dir;

2092

}

2093

2094

extern uLong ZEXPORT unzGetOffset (unzFile file)

2095

{

2096

ZPOS64_T offset64;

2097

2098

if (file==NULL)

2099

return 0; //UNZ_PARAMERROR;

2100

offset64 = unzGetOffset64(file);

2101

return (uLong)offset64;

2102

}

2103

2104

extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)

2105

{

2106

unz64_s* s;

2107

int err;

2108

2109

if (file==NULL)

2110

return UNZ_PARAMERROR;

2111

s=(unz64_s*)file;

2112

2113

s->pos_in_central_dir = pos;

2114

s->num_file = s->gi.number_entry; /* hack */

2115

err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,

2116

&s->cur_file_info_internal,

2117

NULL,0,NULL,0,NULL,0);

2118

s->current_file_ok = (err == UNZ_OK);

2119

return err;

2120

}

2121

2122

extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)

2123

{

2124

return unzSetOffset64(file,pos);

2125

}

Older »