~ubuntu-branches/ubuntu/jaunty/fastjar/jaunty-security : revision 8

23

#include "config.h"

24

#endif

25

26

#include <inttypes.h>

27

#include <stdint.h>

28

26

29

#include <zlib.h>

27

30

28

31

#ifdef HAVE_STDLIB_H

102

105

103

106

typedef struct ziplistentry ziplistentry;

104

107

108

static void exit_on_error(const char* message);

105

109

static void usage(const char*);

106

110

static void help(const char *);

107

111

static void version(void);

354

358

if ((jarfd = open (jarfile, O_RDWR | O_BINARY)) < 0)

355

359

{

356

360

fprintf (stderr, "Error opening %s for reading!\n", jarfile);

357

perror (jarfile);

358

exit(EXIT_FAILURE);

361

exit_on_error (jarfile);

359

362

}

360

363

361

364

/* Assert that jarfd is seekable. */

425

428

/* Check if the file shrunk when we updated it. */

426

429

if (action == ACTION_UPDATE)

427

430

#ifdef HAVE_FTRUNCATE

428

ftruncate (jarfd, lseek (jarfd, 0, SEEK_CUR));

431

if (-1 == ftruncate (jarfd, lseek (jarfd, 0, SEEK_CUR)))

432

exit_on_error("ftruncate");

429

433

#else

430

434

_chsize (jarfd, lseek (jarfd, 0, SEEK_CUR));

431

435

#endif

462

466

create_central_header(jarfd);

463

467

464

468

#ifdef HAVE_FTRUNCATE

465

ftruncate (jarfd, lseek (jarfd, 0, SEEK_CUR));

469

if (-1 == ftruncate (jarfd, lseek (jarfd, 0, SEEK_CUR)))

470

exit_on_error("ftruncate");

466

471

#else

467

472

_chsize (jarfd, lseek (jarfd, 0, SEEK_CUR));

468

473

#endif

478

483

exit(EXIT_SUCCESS);

479

484

}

480

485

486

static void

487

exit_on_error(const char* message)

488

{

489

perror(message);

490

exit(EXIT_FAILURE);

491

}

492

481

493

static int args_current_g;

482

494

static const char **args_g;

483

495

521

533

522

534

s = (char *) malloc (len);

523

535

if (s == NULL)

524

{

525

perror ("malloc");

526

exit(EXIT_FAILURE);

527

}

536

exit_on_error("malloc");

528

537

529

538

/* Get rid of '\n' and '\r' first. */

530

539

while (1)

555

564

len *= 2;

556

565

s = (char *) realloc (s, len);

557

566

if (s == NULL)

558

{

559

perror ("realloc");

560

exit(EXIT_FAILURE);

561

}

567

exit_on_error ("realloc");

562

568

}

563

569

}

564

570

672

678

/*

673

679

* Read the zip entries of an existing file, building `ziplist' as we go.

674

680

*/

681

static

675

682

int read_entries (int fd)

676

683

{

677

684

struct zipentry *ze;

812

819

size_t nlen; /* length of file name */

813

820

int mod_time; /* file modification time */

814

821

struct zipentry *ze;

822

823

mod_time = unix2dostime(&current_time);

815

824

816

825

/* If we are creating a new manifest, create a META-INF directory entry */

817

826

if (0 == updating) {

820

829

memset((file_header + 12), '\0', 16); /*clear mod time, crc, size fields*/

821

830

822

831

current_time = time(NULL);

823

if(current_time == (time_t)-1){

824

perror("time");

825

exit(EXIT_FAILURE);

826

}

832

if(current_time == (time_t)-1)

833

exit_on_error("time");

827

834

828

mod_time = unix2dostime(&current_time);

829

830

835

PACK_UB2(file_header, LOC_EXTRA, 0);

831

836

PACK_UB2(file_header, LOC_COMP, 0);

832

837

PACK_UB2(file_header, LOC_FNLEN, nlen);

836

841

printf("adding: META-INF/ (in=0) (out=0) (stored 0%%)\n");

837

842

838

843

ze = (zipentry*)malloc(sizeof(zipentry));

839

if(ze == NULL){

840

perror("malloc");

841

exit(EXIT_FAILURE);

842

}

844

if(ze == NULL)

845

exit_on_error("malloc");

843

846

844

847

memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/

845

848

ze->filename = strdup("META-INF/");

846

if (NULL == ze->filename) {

847

perror("strdup");

848

exit(EXIT_FAILURE);

849

}

849

if (NULL == ze->filename)

850

exit_on_error("strdup");

850

851

852

ze->offset = lseek(jfd, 0, SEEK_CUR);

852

853

ze->mod_time = (ub2)(mod_time & 0x0000ffff);

855

856

857

add_entry(ze);

857

858

write(jfd, file_header, 30);

859

write(jfd, "META-INF/", nlen);

859

if (-1 == write(jfd, file_header, 30))

860

exit_on_error("write");

861

if (-1 == write(jfd, "META-INF/", nlen))

862

exit_on_error("write");

860

863

}

861

864

862

865

/* if the user didn't specify an external manifest file... */

889

892

printf("adding: META-INF/MANIFEST.MF (in=56) (out=56) (stored 0%%)\n");

890

893

891

894

ze = (zipentry*)malloc(sizeof(zipentry));

892

if(ze == NULL){

893

perror("malloc");

894

exit(EXIT_FAILURE);

895

}

895

if(ze == NULL)

896

exit_on_error("malloc");

896

897

898

memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/

898

899

ze->filename = strdup("META-INF/MANIFEST.MF");

899

if (NULL == ze->filename) {

900

perror("strdup");

901

exit(EXIT_FAILURE);

902

}

900

if (NULL == ze->filename)

901

exit_on_error("strdup");

903

902

904

903

ze->offset = lseek(jfd, 0, SEEK_CUR);

905

904

ze->mod_time = (ub2)(mod_time & 0x0000ffff);

911

910

912

911

add_entry(ze);

913

912

914

write(jfd, file_header, 30);

915

write(jfd, "META-INF/MANIFEST.MF", nlen);

916

write(jfd, mf, mf_len);

913

if (-1 == write(jfd, file_header, 30))

914

exit_on_error("write");

915

if (-1 == write(jfd, "META-INF/MANIFEST.MF", nlen))

916

exit_on_error("write");

917

if (-1 == write(jfd, mf, mf_len))

918

exit_on_error("write");

917

919

free(mf);

918

920

}

919

921

else {

938

940

exit(EXIT_FAILURE);

939

941

}

940

942

941

if(add_file_to_jar(jfd, mfd, "META-INF/MANIFEST.MF", &statbuf, updating)){

942

perror("error writing to jar");

943

exit(EXIT_FAILURE);

944

}

945

943

if(add_file_to_jar(jfd, mfd, "META-INF/MANIFEST.MF", &statbuf, updating))

944

exit_on_error("error writing to jar");

946

945

}

947

946

948

947

return 0;

966

965

967

966

old_dir = (char *) malloc (old_dir_len);

968

967

if (old_dir == NULL)

969

{

970

perror ("malloc");

971

exit(EXIT_FAILURE);

972

}

968

exit_on_error ("malloc");

973

969

974

970

while (1)

975

971

{

983

979

old_dir_len *= 2;

984

980

old_dir = (char *) realloc (old_dir, old_dir_len);

985

981

if (old_dir == NULL)

986

{

987

perror ("realloc");

988

exit(EXIT_FAILURE);

989

}

982

exit_on_error ("realloc");

990

983

}

991

984

992

985

if (chdir(new_dir) == -1) {

1077

1070

PACK_UB4(file_header, LOC_MODTIME, mod_time);

1078

1071

1079

1072

ze = (zipentry*)malloc(sizeof(zipentry));

1080

if(ze == NULL){

1081

perror("malloc");

1082

exit(EXIT_FAILURE);

1083

}

1073

if(ze == NULL)

1074

exit_on_error("malloc");

1084

1075

1085

1076

memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/

1086

1077

ze->filename = strdup(fullname);

1113

1104

if (!existing)

1114

1105

{

1115

1106

add_entry (ze);

1116

write (fd, file_header, 30);

1117

write (fd, fullname, nlen);

1107

if (-1 == write (fd, file_header, 30))

1108

exit_on_error("write");

1109

if (-1 == write (fd, fullname, nlen))

1110

exit_on_error("write");

1118

1111

end_of_entries = lseek (fd, 0, SEEK_CUR);

1119

1112

1120

1113

if (verbose)

1221

1214

memset((file_header + LOC_CRC), '\0', 12); /* clear crc/usize/csize */

1222

1215

1223

1216

ze = (zipentry*)malloc(sizeof(zipentry));

1224

if(ze == NULL){

1225

perror("malloc");

1226

exit(EXIT_FAILURE);

1227

}

1228

1217

if(ze == NULL)

1218

exit_on_error("malloc");

1219

1229

1220

memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/

1230

1221

ze->filename = strdup(fname);

1231

1222

1262

1253

as before */

1263

1254

1264

1255

/* Write the local header */

1265

write(jfd, file_header, 30);

1266

1256

if (-1 == write(jfd, file_header, 30))

1257

exit_on_error("write");

1258

1267

1259

/* write the file name to the zip file */

1268

write(jfd, fname, file_name_length);

1269

1260

if (1 == write(jfd, fname, file_name_length))

1261

exit_on_error("write");

1270

1262

1271

1263

if(verbose){

1272

1264

if (existing)

1317

1309

if(seekable){

1318

1310

offset = (ze->csize + strlen(ze->filename) + 16);

1319

1311

1320

if(lseek(jfd, -offset, SEEK_CUR) == (off_t)-1){

1321

perror("lseek");

1322

exit(EXIT_FAILURE);

1323

}

1312

if(lseek(jfd, -offset, SEEK_CUR) == (off_t)-1)

1313

exit_on_error("lseek");

1324

1314

1325

1315

if(write(jfd, (data_descriptor + 4), 12) != 12){

1326

1316

perror("write");

1329

1319

1330

1320

offset -= 12;

1331

1321

1332

if(lseek(jfd, offset, SEEK_CUR) == (off_t)-1){

1333

perror("lseek");

1334

exit(EXIT_FAILURE);

1335

}

1322

if(lseek(jfd, offset, SEEK_CUR) == (off_t)-1)

1323

exit_on_error("lseek");

1324

1336

1325

} else if(do_compress){

1337

1326

/* Sun's jar tool will only allow a data descriptor if the entry is

1338

1327

compressed, but we'll save 16 bytes/entry if we only use it when

1477

1466

PACK_UB2(header, CEN_FNLEN, strlen(ze->filename));

1478

1467

PACK_UB4(header, CEN_OFFSET, ze->offset);

1479

1468

1480

write(fd, header, 46);

1469

if (-1 == write(fd, header, 46))

1470

exit_on_error("write");

1481

1471

1482

write(fd, ze->filename, strlen(ze->filename));

1472

if (-1 == write(fd, ze->filename, strlen(ze->filename)))

1473

exit_on_error("write");

1483

1474

}

1484

1475

1485

1476

dir_size = lseek(fd, 0, SEEK_CUR) - start_offset;

1507

1498

end_header[20] = 0;

1508

1499

end_header[21] = 0;

1509

1500

1510

write(fd, end_header, 22);

1511

1501

if (-1 == write(fd, end_header, 22))

1502

exit_on_error("write");

1503

1512

1504

if(verbose)

1513

1505

printf("Total:\n------\n(in = %d) (out = %d) (%s %d%%)\n",

1514

1506

total_in,

1523

1515

int extract_jar(int fd, const char **files, int file_num){

1524

1516

size_t rdamt;

1525

1517

int out_a, in_a;

1526

ub4 signature;

1518

uint32_t signature;

1527

1519

ub4 csize;

1528

1520

ub4 crc;

1529

1521

ub2 fnlen;

1583

1575

#endif

1584

1576

break;

1585

1577

}else if(signature != 0x04034b50){

1586

printf("Ick! %#x\n", signature);

1578

printf("Ick! %#" PRIx32 "\n", signature);

1587

1579

break;

1588

1580

}

1589

1581

1701

1693

/* Add 10 more spots to subdir_list */

1702

1694

if (subdir_list_index == subdir_list_size) {

1703

1695

subdir_list_size = subdir_list_size + 10;

1704

subdir_list = realloc(subdir_list, (subdir_list_size) * sizeof(char*));

1696

subdir_list = realloc(subdir_list, (subdir_list_size) * sizeof(char *));

1705

1697

1706

1698

if (subdir_list == NULL) {

1707

1699

fprintf(stderr, "error realloc-ing subdir_list_size\n");

1766

1758

} else if (strcmp(tmp_buff, ".") != 0)

1767

1759

++depth;

1768

1760

if(stat(tmp_buff, &sbuf) < 0){

1769

if(errno != ENOENT){

1770

perror("stat");

1771

exit(EXIT_FAILURE);

1772

}

1761

if(errno != ENOENT)

1762

exit_on_error("stat");

1773

1763

1774

1764

} else if(S_ISDIR(sbuf.st_mode)){

1775

1765

#ifdef DEBUG

1785

1775

#ifdef DEBUG

1786

1776

printf("Making directory..\n");

1787

1777

#endif

1788

if(mkdir(tmp_buff, 0755) < 0){

1789

perror("mkdir");

1790

exit(EXIT_FAILURE);

1791

}

1778

if(mkdir(tmp_buff, 0755) < 0)

1779

exit_on_error("mkdir");

1780

1792

1781

if(verbose && handle)

1793

1782

printf("%10s: %s/\n", "created", tmp_buff);

1794

1783

1815

1804

1816

1805

if(f_fd < 0){

1817

1806

fprintf(stderr, "Error extracting JAR archive!\n");

1818

perror((const char *)filename);

1819

exit(EXIT_FAILURE);

1807

exit_on_error((const char *)filename);

1820

1808

}

1821

1809

}

1822

1810

1844

1832

1845

1833

while(out_a < (int)csize){

1846

1834

rdamt = (in_a > RDSZ ? RDSZ : in_a);

1847

if(pb_read(&pbf, rd_buff, rdamt) != rdamt){

1848

perror("read");

1849

exit(EXIT_FAILURE);

1850

}

1835

if(pb_read(&pbf, rd_buff, rdamt) != rdamt)

1836

exit_on_error("read");

1851

1837

1852

1838

ze.crc = crc32(ze.crc, (Bytef*)rd_buff, rdamt);

1853

1839

1854

1840

if(f_fd >= 0) {

1855

1841

ssize_t num_written;

1856

1842

num_written = write(f_fd, rd_buff, rdamt);

1857

if (num_written == -1) {

1858

perror("write");

1859

exit(EXIT_FAILURE);

1860

}

1843

if (num_written == -1)

1844

exit_on_error("write");

1861

1845

}

1862

1846

1863

1847

out_a += rdamt;

1872

1856

/* if there is a data descriptor left, compare the CRC */

1873

1857

if(flags & 0x0008){

1874

1858

1875

if(pb_read(&pbf, scratch, 16) != 16){

1876

perror("read");

1877

exit(EXIT_FAILURE);

1878

}

1859

if(pb_read(&pbf, scratch, 16) != 16)

1860

exit_on_error("read");

1879

1861

1880

1862

signature = UNPACK_UB4(scratch, 0);

1881

1863

1905

1887

for (j = 0; j < subdir_list_index; j++) {

1906

1888

free(subdir_list[j]);

1907

1889

}

1890

free(subdir_list);

1908

1891

return 0;

1909

1892

}

1910

1893

1939

1922

1940

1923

/* This should be the start of the central-header-end section */

1941

1924

if(seekable){

1942

if(lseek(fd, -22, SEEK_END) == (off_t)-1){

1943

perror("lseek");

1944

exit(EXIT_FAILURE);

1945

}

1925

if(lseek(fd, -22, SEEK_END) == (off_t)-1)

1926

exit_on_error("lseek");

1946

1927

1947

if(read(fd, &tmp, sizeof(ub4)) != 4){

1948

perror("read");

1949

exit(EXIT_FAILURE);

1950

}

1928

if(read(fd, &tmp, sizeof(ub4)) != 4)

1929

exit_on_error("read");

1951

1930

1952

1931

#ifdef WORDS_BIGENDIAN

1953

1932

tmp = L2BI(tmp);

1961

1940

position, so we have to fall back on the method used for

1962

1941

non-seekable files. */

1963

1942

seekable = FALSE;

1964

if(lseek(fd, 0, SEEK_SET) == (off_t)-1){

1965

perror("lseek");

1966

exit(EXIT_FAILURE);

1967

}

1943

if(lseek(fd, 0, SEEK_SET) == (off_t)-1)

1944

exit_on_error("lseek");

1968

1945

} else {

1969

if(lseek(fd, 6, SEEK_CUR) == (off_t)-1){

1970

perror("lseek");

1971

exit(EXIT_FAILURE);

1972

}

1946

if(lseek(fd, 6, SEEK_CUR) == (off_t)-1)

1947

exit_on_error("lseek");

1973

1948

1974

if(read(fd, &cen_size, 2) != 2){

1975

perror("read");

1976

exit(EXIT_FAILURE);

1977

}

1949

if(read(fd, &cen_size, 2) != 2)

1950

exit_on_error("read");

1978

1951

1979

1952

#ifdef WORDS_BIGENDIAN

1980

1953

cen_size = L2BS(cen_size);

1982

1955

1983

1956

/* printf("%hu entries in central header\n", cen_size); */

1984

1957

1985

if(lseek(fd, 4, SEEK_CUR) == (off_t)-1){

1986

perror("lseek");

1987

exit(EXIT_FAILURE);

1988

}

1989

1990

if(read(fd, &tmp, 4) != 4){

1991

perror("read");

1992

exit(EXIT_FAILURE);

1993

}

1958

if(lseek(fd, 4, SEEK_CUR) == (off_t)-1)

1959

exit_on_error("lseek");

1960

1961

if(read(fd, &tmp, 4) != 4)

1962

exit_on_error("read");

1963

1994

1964

1995

1965

#ifdef WORDS_BIGENDIAN

1996

1966

tmp = L2BI(tmp);

2000

1970

2001

1971

/* printf("Central header offset = %d\n", central_header_offset); */

2002

1972

2003

if(lseek(fd, central_header_offset, SEEK_SET) != central_header_offset){

2004

perror("lseek");

2005

exit(EXIT_FAILURE);

2006

}

1973

if(lseek(fd, central_header_offset, SEEK_SET) != central_header_offset)

1974

exit_on_error("lseek");

2007

1975

2008

1976

/* Loop through the entries in the central header */

2009

1977

for(i = 0; i < cen_size; i++){

2011

1979

2012

1980

read_amt = read(fd, &cen_header, 46);

2013

1981

2014

if(read_amt == -1 || read_amt != 46){

2015

perror("read");

2016

exit(EXIT_FAILURE);

2017

}

1982

if(read_amt == -1 || read_amt != 46)

1983

exit_on_error("read");

2018

1984

2019

1985

signature = UNPACK_UB4(cen_header, 0);

2020

1986

if(signature != 0x02014b50){

2036

2002

tdate = dos2unixtime(mdate);

2037

2003

s_tm = localtime(&tdate);

2038

2004

time_string_length = strftime(ascii_date, 30, "%a %b %d %H:%M:%S %Z %Y", s_tm);

2039

if (0 == time_string_length) {

2040

perror("strftime");

2041

exit(EXIT_FAILURE);

2042

}

2005

if (0 == time_string_length)

2006

exit_on_error("strftime");

2007

2043

2008

ascii_date[30] = '\0';

2044

2009

}

2045

2010

2048

2013

free(filename);

2049

2014

2050

2015

filename = malloc(sizeof(ub1) * (fnlen + 1));

2051

if (NULL == filename) {

2052

perror("malloc");

2053

exit(EXIT_FAILURE);

2054

}

2016

if (NULL == filename)

2017

exit_on_error("malloc");

2018

2055

2019

filename_len = fnlen + 1;

2056

2020

}

2057

2021

2058

2022

read_amt = read(fd, filename, fnlen);

2059

if(read_amt == -1 || read_amt != (ssize_t) fnlen){

2060

perror("read");

2061

exit(EXIT_FAILURE);

2062

}

2023

if(read_amt == -1 || read_amt != (ssize_t) fnlen)

2024

exit_on_error("read");

2025

2063

2026

filename[fnlen] = (ub1) '\0';

2064

2027

2065

2028

/* if the user specified a list of files on the command line,

2082

2045

2083

2046

size = eflen + clen;

2084

2047

if(size > 0){

2085

if(lseek(fd, size, SEEK_CUR) == (off_t)-1){

2086

perror("lseek");

2087

exit(EXIT_FAILURE);

2088

}

2048

if(lseek(fd, size, SEEK_CUR) == (off_t)-1)

2049

exit_on_error("lseek");

2089

2050

}

2090

2051

}

2091

2052

}

2250

2211

#endif

2251

2212

2252

2213

buff = (ub1 *) malloc(RDSZ * sizeof(ub1));

2253

if (NULL == buff) {

2254

perror("malloc");

2255

exit(EXIT_FAILURE);

2256

}

2214

if (NULL == buff)

2215

exit_on_error("malloc");

2257

2216

2258

2217

if (seekable){

2259

2218

if (amt <= pbf->buff_amt)

2261

2220

else {

2262

2221

off_t location;

2263

2222

location = lseek(pbf->fd, amt - pbf->buff_amt, SEEK_CUR);

2264

if (location == -1) {

2265

perror("lseek");

2266

exit(EXIT_FAILURE);

2267

}

2223

if (location == -1)

2224

exit_on_error("lseek");

2225

2268

2226

tc += pb_read(pbf, buff, pbf->buff_amt); /* clear pbf */

2269

2227

}

2270

2228

} else

2467

2425

}

2468

2426

2469

2427

current_time = time(NULL);

2470

if(current_time == (time_t)-1){

2471

perror("time");

2472

exit(EXIT_FAILURE);

2473

}

2428

if(current_time == (time_t)-1)

2429

exit_on_error("time");

2474

2430

2475

2431

mod_time = unix2dostime(&current_time);

2476

2432

file_name_length = strlen(fname);

2498

2454

memset((file_header + LOC_CRC), '\0', 12); /* clear crc/usize/csize */

2499

2455

2500

2456

ze = (zipentry*)malloc(sizeof(zipentry));

2501

if(ze == NULL){

2502

perror("malloc");

2503

exit(EXIT_FAILURE);

2504

}

2457

if(ze == NULL)

2458

exit_on_error("malloc");

2505

2459

2506

2460

memset(ze, 0, sizeof(zipentry)); /* clear all the fields*/

2507

2461

ze->filename = strdup(fname);

2537

2491

2538

2492

/* Write the local header */

2539

2493

written = write(jfd, file_header, 30);

2540

if ((written == -1) || ((size_t) written != 30)){

2541

perror("write");

2542

exit(EXIT_FAILURE);

2543

}

2494

if ((written == -1) || ((size_t) written != 30))

2495

exit_on_error("write");

2544

2496

2545

2497

/* write the file name to the zip file */

2546

2498

written = write(jfd, fname, file_name_length);

2547

if ((written == -1) || ((size_t) written != file_name_length)){

2548

perror("write");

2549

exit(EXIT_FAILURE);

2550

}

2551

2499

if ((written == -1) || ((size_t) written != file_name_length))

2500

exit_on_error("write");

2552

2501

2553

2502

if(verbose){

2554

2503

if (existing)

2579

2528

2580

2529

ze->crc = crc32(ze->crc, (unsigned char*)content, content_length);

2581

2530

written = write(jfd, content, content_length);

2582

if ((written == -1) || ((size_t) written != content_length)){

2583

perror("write");

2584

exit(EXIT_FAILURE);

2585

}

2531

if ((written == -1) || ((size_t) written != content_length))

2532

exit_on_error("write");

2586

2533

2587

2534

/* write out data descriptor */

2588

2535

PACK_UB4(data_descriptor, 4, ze->crc);

2593

2540

if(seekable){

2594

2541

offset = (ze->csize + strlen(ze->filename) + 16);

2595

2542

2596

if(lseek(jfd, -offset, SEEK_CUR) == (off_t)-1){

2597

perror("lseek");

2598

exit(EXIT_FAILURE);

2599

}

2543

if(lseek(jfd, -offset, SEEK_CUR) == (off_t)-1)

2544

exit_on_error("lseek");

2600

2545

2601

2546

if(write(jfd, (data_descriptor + 4), 12) != 12){

2602

2547

perror("write");

2605

2550

2606

2551

offset -= 12;

2607

2552

2608

if(lseek(jfd, offset, SEEK_CUR) == (off_t)-1){

2609

perror("lseek");

2610

exit(EXIT_FAILURE);

2611

}

2553

if(lseek(jfd, offset, SEEK_CUR) == (off_t)-1)

2554

exit_on_error("lseek");

2612

2555

}

2613

2556

2614

2557

if (existing)

2654

2597

{

2655

2598

char * result = strdup(fname);

2656

2599

if (!result)

2657

{

2658

perror("strdup");

2659

exit(EXIT_FAILURE);

2660

}

2600

exit_on_error("strdup");

2601

2661

2602

*strrchr(result, '/') = '\0';

2662

2603

return result;

2663

2604

}