Grcov report - cairo-type1-subset.c

1

/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */

2

/* cairo - a vector graphics library with display and print output

3

4

 * Copyright © 2006 Red Hat, Inc

5

6

 * This library is free software; you can redistribute it and/or

7

 * modify it either under the terms of the GNU Lesser General Public

8

 * License version 2.1 as published by the Free Software Foundation

9

 * (the "LGPL") or, at your option, under the terms of the Mozilla

10

 * Public License Version 1.1 (the "MPL"). If you do not alter this

11

 * notice, a recipient may use your version of this file under either

12

 * the MPL or the LGPL.

13

14

 * You should have received a copy of the LGPL along with this library

15

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

16

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

17

 * You should have received a copy of the MPL along with this library

18

 * in the file COPYING-MPL-1.1

19

20

 * The contents of this file are subject to the Mozilla Public License

21

 * Version 1.1 (the "License"); you may not use this file except in

22

 * compliance with the License. You may obtain a copy of the License at

23

 * http://www.mozilla.org/MPL/

24

25

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

26

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

27

 * the specific language governing rights and limitations.

28

29

 * The Original Code is the cairo graphics library.

30

31

 * The Initial Developer of the Original Code is Red Hat, Inc.

32

33

 * Contributor(s):

34

 *	Kristian Høgsberg <krh@redhat.com>

35

*/

36

37

/*

38

 * Useful links:

39

 * http://partners.adobe.com/public/developer/en/font/T1_SPEC.PDF

40

*/

41

42

43

#define _DEFAULT_SOURCE /* for snprintf(), strdup() */

44

#include "cairoint.h"

45

46

#include "cairo-array-private.h"

47

#include "cairo-error-private.h"

48

49

#if CAIRO_HAS_FONT_SUBSET

50

51

#include "cairo-type1-private.h"

52

#include "cairo-scaled-font-subsets-private.h"

53

#include "cairo-output-stream-private.h"

54

55

#include <ctype.h>

56

57

#define TYPE1_STACKSIZE 24 /* Defined in Type 1 Font Format */

58

59

60

typedef struct {

61

    int subset_index;

62

    double width;

63

    const char *encrypted_charstring;

64

    int encrypted_charstring_length;

65

} glyph_data_t;

66

67

typedef struct _cairo_type1_font_subset {

68

    cairo_scaled_font_subset_t *scaled_font_subset;

69

70

    struct {

71

	unsigned int font_id;

72

	char *base_font;

73

	unsigned int num_glyphs; /* Num /CharStrings in font */

74

	double x_min, y_min, x_max, y_max;

75

	double ascent, descent;

76

	double units_per_em;

77

78

	const char    *data;

79

	unsigned long  header_size;

80

	unsigned long  data_size;

81

	unsigned long  trailer_size;

82

    } base;

83

84

    /* Num glyphs in subset. May be greater than

85

     * scaled_font_subset->num_glyphs due to glyphs required by the

86

     * SEAC operator. */

87

    int num_glyphs;

88

89

    /* The glyphs and glyph_names arrays are indexed by the order of

90

     * the Charstrings in the font. This is not necessarily the same

91

     * order as the glyph index. The index_to_glyph_name() font backend

92

     * function is used to map the glyph index to the glyph order in

93

     * the Charstrings. */

94

95

    cairo_array_t glyphs_array;

96

    glyph_data_t *glyphs; /* pointer to first element of above array */

97

    cairo_array_t glyph_names_array;

98

    char **glyph_names; /* pointer to first element of above array */

99

100

    int num_subrs; /* Num /Subrs routines in the font */

101

    cairo_bool_t subset_subrs;

102

    struct {

103

	const char *subr_string;

104

	int subr_length;

105

	const char *np;

106

	int np_length;

107

	cairo_bool_t used;

108

    } *subrs; /* array with num_subrs elements */

109

110

    /* Maps scaled_font_subset index to glyphs_array.

111

     * Array size = scaled_font_subset->num_glyphs. */

112

    int *scaled_subset_index_to_glyphs;

113

114

    /* Keeps track of the glyphs that will be emitted in the subset.

115

     * Allocated size = base.num_glyphs. Number of entries = num_glyphs.

116

     * Array values are glyph_array indexes.

117

*/

118

    int *type1_subset_index_to_glyphs;

119

120

    cairo_output_stream_t *output;

121

    cairo_array_t contents;

122

123

    const char *rd, *nd, *np;

124

125

    int lenIV;

126

127

    char *type1_data;

128

    unsigned int type1_length;

129

    char *type1_end;

130

131

    char *header_segment;

132

    unsigned int header_segment_size;

133

    char *eexec_segment;

134

    unsigned int eexec_segment_size;

135

    cairo_bool_t eexec_segment_is_ascii;

136

137

    char *cleartext;

138

    char *cleartext_end;

139

140

    unsigned int header_size;

141

142

    unsigned short eexec_key;

143

    cairo_bool_t hex_encode;

144

    int hex_column;

145

146

    struct {

147

	double stack[TYPE1_STACKSIZE];

148

	int sp;

149

    } build_stack;

150

151

    struct {

152

	int stack[TYPE1_STACKSIZE];

153

	int sp;

154

    } ps_stack;

155

156

157

} cairo_type1_font_subset_t;

158

159

160

static cairo_status_t

161

_cairo_type1_font_subset_init (cairo_type1_font_subset_t  *font,

162

			       cairo_scaled_font_subset_t *scaled_font_subset,

163

			       cairo_bool_t                hex_encode)

164

165

    memset (font, 0, sizeof (*font));

166

    font->scaled_font_subset = scaled_font_subset;

167

168

    _cairo_array_init (&font->glyphs_array, sizeof (glyph_data_t));

169

    _cairo_array_init (&font->glyph_names_array, sizeof (char *));

170

    font->scaled_subset_index_to_glyphs = _cairo_calloc_ab (scaled_font_subset->num_glyphs,

171

							    sizeof font->scaled_subset_index_to_glyphs[0]);

172

    if (unlikely (font->scaled_subset_index_to_glyphs == NULL))

173

        return _cairo_error (CAIRO_STATUS_NO_MEMORY);

174

175

176

    font->type1_subset_index_to_glyphs = NULL;

177

    font->base.num_glyphs = 0;

178

    font->num_subrs = 0;

179

    font->subset_subrs = TRUE;

180

    font->subrs = NULL;

181

182

    font->hex_encode = hex_encode;

183

    font->num_glyphs = 0;

184

185

    _cairo_array_init (&font->contents, sizeof (char));

186

187

    return CAIRO_STATUS_SUCCESS;

188

189

190

static void

191

cairo_type1_font_subset_use_glyph (cairo_type1_font_subset_t *font, int glyph)

192

193

    if (font->glyphs[glyph].subset_index >= 0)

194

	return;

195

196

    font->glyphs[glyph].subset_index = font->num_glyphs;

197

    font->type1_subset_index_to_glyphs[font->num_glyphs] = glyph;

198

    font->num_glyphs++;

199

200

201

static cairo_bool_t

202

is_ps_delimiter(int c)

203

204

    static const char delimiters[] = "()[]{}<>/% \t\r\n";

205

206

    return strchr (delimiters, c) != NULL;

207

208

209

static const char *

210

find_token (const char *buffer, const char *end, const char *token)

211

212

    int i, length;

213

    /* FIXME: find substring really must be find_token */

214

215

    if (buffer == NULL)

216

	return NULL;

217

218

    length = strlen (token);

219

    for (i = 0; buffer + i < end - length + 1; i++)

220

	if (memcmp (buffer + i, token, length) == 0)

221

	    if ((i == 0 || token[0] == '/' || is_ps_delimiter(buffer[i - 1])) &&

222

		(buffer + i == end - length || is_ps_delimiter(buffer[i + length])))

223

		return buffer + i;

224

225

    return NULL;

226

227

228

static cairo_status_t

229

cairo_type1_font_subset_find_segments (cairo_type1_font_subset_t *font)

230

231

    unsigned char *p;

232

    const char *eexec_token;

233

    unsigned int size, i;

234

235

    p = (unsigned char *) font->type1_data;

236

    font->type1_end = font->type1_data + font->type1_length;

237

    if (font->type1_length >= 2 && p[0] == 0x80 && p[1] == 0x01) {

238

	if (font->type1_end < (char *)(p + 6))

239

	    return CAIRO_INT_STATUS_UNSUPPORTED;

240

	font->header_segment_size =

241

	    p[2] | (p[3] << 8) | (p[4] << 16) | ((unsigned int) p[5] << 24);

242

	font->header_segment = (char *) p + 6;

243

244

	p += 6 + font->header_segment_size;

245

	if (font->type1_end < (char *)(p + 6))

246

	    return CAIRO_INT_STATUS_UNSUPPORTED;

247

	font->eexec_segment_size =

248

	    p[2] | (p[3] << 8) | (p[4] << 16) | ((unsigned int) p[5] << 24);

249

	font->eexec_segment = (char *) p + 6;

250

	font->eexec_segment_is_ascii = (p[1] == 1);

251

252

        p += 6 + font->eexec_segment_size;

253

	while (font->type1_end >= (char *)(p + 6) && p[1] != 0x03) {

254

	    size = p[2] | (p[3] << 8) | (p[4] << 16) | ((unsigned int) p[5] << 24);

255

	    if (font->type1_end < (char *)(p + 6 + size))

256

		return CAIRO_INT_STATUS_UNSUPPORTED;

257

	    p += 6 + size;

258

259

        font->type1_end = (char *) p;

260

    } else {

261

	eexec_token = find_token ((char *) p, font->type1_end, "eexec");

262

	if (eexec_token == NULL)

263

	    return CAIRO_INT_STATUS_UNSUPPORTED;

264

265

	font->header_segment_size = eexec_token - (char *) p + strlen ("eexec\n");

266

	font->header_segment = (char *) p;

267

	font->eexec_segment_size = font->type1_length - font->header_segment_size;

268

	font->eexec_segment = (char *) p + font->header_segment_size;

269

	font->eexec_segment_is_ascii = TRUE;

270

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

271

	    if (!_cairo_isxdigit (font->eexec_segment[i]))

272

		font->eexec_segment_is_ascii = FALSE;

273

274

275

276

    return CAIRO_STATUS_SUCCESS;

277

278

279

/* Search for the definition of key and erase it by overwriting with spaces.

280

 * This function is looks for definitions of the form:

281

282

 * /key1 1234 def

283

 * /key2 [12 34 56] def

284

285

 * ie a key defined as an integer or array of integers.

286

287

*/

288

static void

289

cairo_type1_font_erase_dict_key (cairo_type1_font_subset_t *font,

290

				 const char *key)

291

292

    const char *start, *p, *segment_end;

293

294

    segment_end = font->header_segment + font->header_segment_size;

295

296

    start = font->header_segment;

297

    do {

298

	start = find_token (start, segment_end, key);

299

	if (start) {

300

	    p = start + strlen(key);

301

	    /* skip integers or array of integers */

302

	    while (p < segment_end &&

303

		   (_cairo_isspace(*p) ||

304

		    _cairo_isdigit(*p) ||

305

		    *p == '[' ||

306

		    *p == ']'))

307

308

		p++;

309

310

311

	    if (p + 3 < segment_end && memcmp(p, "def", 3) == 0) {

312

		/* erase definition of the key */

313

		memset((char *) start, ' ', p + 3 - start);

314

315

	    start += strlen(key);

316

317

    } while (start);

318

319

320

static cairo_status_t

321

cairo_type1_font_subset_get_matrix (cairo_type1_font_subset_t *font,

322

				    const char                *name,

323

				    double                    *a,

324

				    double                    *b,

325

				    double                    *c,

326

				    double                    *d)

327

328

    const char *start, *end, *segment_end;

329

    int ret, s_max, i, j;

330

    char *s;

331

    const char *decimal_point;

332

    int decimal_point_len;

333

334

    decimal_point = _cairo_get_locale_decimal_point ();

335

    decimal_point_len = strlen (decimal_point);

336

337

    assert (decimal_point_len != 0);

338

339

    segment_end = font->header_segment + font->header_segment_size;

340

    start = find_token (font->header_segment, segment_end, name);

341

    if (start == NULL)

342

	return CAIRO_INT_STATUS_UNSUPPORTED;

343

344

    end = find_token (start, segment_end, "def");

345

    if (end == NULL)

346

	return CAIRO_INT_STATUS_UNSUPPORTED;

347

348

    s_max = end - start + 5*decimal_point_len + 1;

349

    s = _cairo_malloc (s_max);

350

    if (unlikely (s == NULL))

351

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

352

353

    i = 0;

354

    j = 0;

355

    while (i < end - start && j < s_max - decimal_point_len) {

356

	if (start[i] == '.') {

357

	    strncpy(s + j, decimal_point, decimal_point_len + 1);

358

	    i++;

359

	    j += decimal_point_len;

360

	} else {

361

	    s[j++] = start[i++];

362

363

364

    s[j] = 0;

365

366

    start = strpbrk (s, "{[");

367

    if (!start) {

368

	free (s);

369

	return CAIRO_INT_STATUS_UNSUPPORTED;

370

371

372

    start++;

373

    ret = 0;

374

    if (*start)

375

	ret = sscanf(start, "%lf %lf %lf %lf", a, b, c, d);

376

377

    free (s);

378

379

    if (ret != 4)

380

	return CAIRO_INT_STATUS_UNSUPPORTED;

381

382

    return CAIRO_STATUS_SUCCESS;

383

384

385

static cairo_status_t

386

cairo_type1_font_subset_get_bbox (cairo_type1_font_subset_t *font)

387

388

    cairo_status_t status;

389

    double x_min, y_min, x_max, y_max;

390

    double xx, yx, xy, yy;

391

392

    status = cairo_type1_font_subset_get_matrix (font, "/FontBBox",

393

						 &x_min,

394

						 &y_min,

395

						 &x_max,

396

						 &y_max);

397

    if (unlikely (status))

398

	return status;

399

400

    status = cairo_type1_font_subset_get_matrix (font, "/FontMatrix",

401

						 &xx, &yx, &xy, &yy);

402

    if (unlikely (status))

403

	return status;

404

405

    if (yy == 0.0)

406

	return CAIRO_INT_STATUS_UNSUPPORTED;

407

408

    /* FreeType uses 1/yy to get units per EM */

409

    font->base.units_per_em = 1.0/yy;

410

411

    /* If the FontMatrix is not a uniform scale the metrics we extract

412

     * from the font won't match what FreeType returns */

413

    if (xx != yy || yx != 0.0 || xy != 0.0)

414

	return CAIRO_INT_STATUS_UNSUPPORTED;

415

416

    font->base.x_min = x_min / font->base.units_per_em;

417

    font->base.y_min = y_min / font->base.units_per_em;

418

    font->base.x_max = x_max / font->base.units_per_em;

419

    font->base.y_max = y_max / font->base.units_per_em;

420

    font->base.ascent = font->base.y_max;

421

    font->base.descent = font->base.y_min;

422

423

    return CAIRO_STATUS_SUCCESS;

424

425

426

static cairo_status_t

427

cairo_type1_font_subset_get_fontname (cairo_type1_font_subset_t *font)

428

429

    const char *start, *end, *segment_end;

430

    char *s;

431

    int i;

432

    cairo_status_t status;

433

434

    segment_end = font->header_segment + font->header_segment_size;

435

    start = find_token (font->header_segment, segment_end, "/FontName");

436

    if (start == NULL)

437

	return CAIRO_INT_STATUS_UNSUPPORTED;

438

439

    start += strlen ("/FontName");

440

441

    end = find_token (start, segment_end, "def");

442

    if (end == NULL)

443

	return CAIRO_INT_STATUS_UNSUPPORTED;

444

445

    while (end > start && _cairo_isspace(end[-1]))

446

	end--;

447

448

    s = _cairo_malloc (end - start + 1);

449

    if (unlikely (s == NULL))

450

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

451

452

    strncpy (s, start, end - start);

453

    s[end - start] = 0;

454

455

    start = strchr (s, '/');

456

    if (!start++ || !start) {

457

	free (s);

458

	return CAIRO_INT_STATUS_UNSUPPORTED;

459

460

461

    /* If font name is prefixed with a subset tag, strip it off. */

462

    if (strlen(start) > 7 && start[6] == '+') {

463

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

464

	    if (start[i] < 'A' || start[i] > 'Z')

465

		break;

466

467

	if (i == 6)

468

	    start += 7;

469

470

471

    font->base.base_font = strdup (start);

472

    free (s);

473

    if (unlikely (font->base.base_font == NULL))

474

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

475

476

    status = _cairo_escape_ps_name (&font->base.base_font);

477

478

    return status;

479

480

481

static cairo_status_t

482

cairo_type1_font_subset_write_header (cairo_type1_font_subset_t *font,

483

					 const char *name)

484

485

    const char *start, *end, *segment_end;

486

    unsigned int i;

487

    int glyph;

488

489

    /* FIXME:

490

     * This function assumes that /FontName always appears

491

     * before /Encoding. This appears to always be the case with Type1

492

     * fonts.

493

494

     * The more recently added code for removing the UniqueID and XUID

495

     * keys can not make any assumptions about the position of the

496

     * keys in the dictionary so it is implemented by overwriting the

497

     * key definition with spaces before we start copying the font to

498

     * the output.

499

500

     * This code should be rewritten to not make any assumptions about

501

     * the order of dictionary keys. This will allow UniqueID to be

502

     * stripped out instead of leaving a bunch of spaces in the

503

     * output.

504

*/

505

    cairo_type1_font_erase_dict_key (font, "/UniqueID");

506

    cairo_type1_font_erase_dict_key (font, "/XUID");

507

508

    segment_end = font->header_segment + font->header_segment_size;

509

510

    /* Type 1 fonts created by Fontforge have some PostScript code at

511

     * the start of the font that skips the font if the printer has a

512

     * cached copy of the font with the same unique id. This breaks

513

     * our subsetted font so we disable it by searching for the

514

     * PostScript operator "known" when used to check for the

515

     * "/UniqueID" dictionary key. We append " pop false " after it to

516

     * pop the result of this check off the stack and replace it with

517

     * "false" to make the PostScript code think "/UniqueID" does not

518

     * exist.

519

*/

520

    end = font->header_segment;

521

    start = find_token (font->header_segment, segment_end, "/UniqueID");

522

    if (start) {

523

	start += 9;

524

	while (start < segment_end && _cairo_isspace (*start))

525

	    start++;

526

	if (start + 5 < segment_end && memcmp(start, "known", 5) == 0) {

527

	    _cairo_output_stream_write (font->output, font->header_segment,

528

					start + 5 - font->header_segment);

529

	    _cairo_output_stream_printf (font->output, " pop false ");

530

	    end = start + 5;

531

532

533

534

    start = find_token (end, segment_end, "/FontName");

535

    if (start == NULL)

536

	return CAIRO_INT_STATUS_UNSUPPORTED;

537

538

    _cairo_output_stream_write (font->output, end,

539

				start - end);

540

541

    _cairo_output_stream_printf (font->output, "/FontName /%s def", name);

542

543

    end = find_token (start, segment_end, "def");

544

    if (end == NULL)

545

	return CAIRO_INT_STATUS_UNSUPPORTED;

546

    end += 3;

547

548

    start = find_token (end, segment_end, "/Encoding");

549

    if (start == NULL)

550

	return CAIRO_INT_STATUS_UNSUPPORTED;

551

    _cairo_output_stream_write (font->output, end, start - end);

552

553

    _cairo_output_stream_printf (font->output,

554

				 "/Encoding 256 array\n"

555

				 "0 1 255 {1 index exch /.notdef put} for\n");

556

    if (font->scaled_font_subset->is_latin) {

557

	for (i = 1; i < 256; i++) {

558

	    int subset_glyph = font->scaled_font_subset->latin_to_subset_glyph_index[i];

559

560

	    if (subset_glyph > 0) {

561

		_cairo_output_stream_printf (font->output,

562

					     "dup %d /%s put\n",

563

i,

564

					     _cairo_winansi_to_glyphname (i));

565

566

567

    } else {

568

	for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) {

569

	    glyph = font->scaled_subset_index_to_glyphs[i];

570

	    _cairo_output_stream_printf (font->output,

571

					 "dup %d /%s put\n",

572

i,

573

					 font->glyph_names[glyph]);

574

575

576

    _cairo_output_stream_printf (font->output, "readonly def");

577

578

    end = find_token (start, segment_end, "def");

579

    if (end == NULL)

580

	return CAIRO_INT_STATUS_UNSUPPORTED;

581

    end += 3;

582

583

    /* There are some buggy fonts that contain more than one /Encoding */

584

    if (find_token (end, segment_end, "/Encoding"))

585

	return CAIRO_INT_STATUS_UNSUPPORTED;

586

587

    _cairo_output_stream_write (font->output, end, segment_end - end);

588

589

    return font->output->status;

590

591

592

static int

593

hex_to_int (int ch)

594

595

    if (ch <= '9')

596

	return ch - '0';

597

    else if (ch <= 'F')

598

	return ch - 'A' + 10;

599

    else

600

	return ch - 'a' + 10;

601

602

603

static cairo_status_t

604

cairo_type1_font_subset_write_encrypted (cairo_type1_font_subset_t *font,

605

					 const char *data, unsigned int length)

606

607

    const unsigned char *in, *end;

608

    int c, p;

609

    static const char hex_digits[16] = "0123456789abcdef";

610

    char digits[3];

611

612

    in = (const unsigned char *) data;

613

    end = (const unsigned char *) data + length;

614

    while (in < end) {

615

	p = *in++;

616

	c = p ^ (font->eexec_key >> 8);

617

	font->eexec_key = (c + font->eexec_key) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2;

618

619

	if (font->hex_encode) {

620

	    digits[0] = hex_digits[c >> 4];

621

	    digits[1] = hex_digits[c & 0x0f];

622

	    digits[2] = '\n';

623

	    font->hex_column += 2;

624

625

	    if (font->hex_column == 78) {

626

		_cairo_output_stream_write (font->output, digits, 3);

627

		font->hex_column = 0;

628

	    } else {

629

		_cairo_output_stream_write (font->output, digits, 2);

630

631

	} else {

632

	    digits[0] = c;

633

	    _cairo_output_stream_write (font->output, digits, 1);

634

635

636

637

    return font->output->status;

638

639

640

static cairo_status_t

641

cairo_type1_font_subset_decrypt_eexec_segment (cairo_type1_font_subset_t *font)

642

643

    unsigned short r = CAIRO_TYPE1_PRIVATE_DICT_KEY;

644

    unsigned char *in, *end;

645

    char *out;

646

    int c, p;

647

    unsigned int i;

648

649

    in = (unsigned char *) font->eexec_segment;

650

    end = (unsigned char *) in + font->eexec_segment_size;

651

652

    font->cleartext = _cairo_malloc (font->eexec_segment_size + 1);

653

    if (unlikely (font->cleartext == NULL))

654

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

655

656

    out = font->cleartext;

657

    while (in < end) {

658

	if (font->eexec_segment_is_ascii) {

659

	    c = *in++;

660

	    if (_cairo_isspace (c))

661

		continue;

662

	    c = (hex_to_int (c) << 4) | hex_to_int (*in++);

663

	} else {

664

	    c = *in++;

665

666

	p = c ^ (r >> 8);

667

	r = (c + r) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2;

668

669

	*out++ = p;

670

671

    font->cleartext_end = out;

672

673

    /* Overwrite random bytes with spaces.

674

675

     * The first 4 bytes of the cleartext are the random bytes

676

     * required by the encryption algorithm. When encrypting the

677

     * cleartext, the first ciphertext byte must not be a white space

678

     * character and the first 4 bytes must not be an ASCII Hex

679

     * character. Some fonts do not check that their randomly chosen

680

     * bytes results in ciphertext that complies with this

681

     * restriction. This may cause problems for some PDF consumers. By

682

     * replacing the random bytes with spaces, the first four bytes of

683

     * ciphertext will always be 0xf9, 0x83, 0xef, 0x00 which complies

684

     * with this restriction. Using spaces also means we don't have to

685

     * skip over the random bytes when parsing the cleartext.

686

*/

687

    for (i = 0; i < 4 && i < font->eexec_segment_size; i++)

688

	font->cleartext[i] = ' ';

689

690

    /* Ensure strtol() can not scan past the end of the cleartext */

691

    font->cleartext[font->eexec_segment_size] = 0;

692

693

    return CAIRO_STATUS_SUCCESS;

694

695

696

static const char *

697

skip_token (const char *p, const char *end)

698

699

    while (p < end && _cairo_isspace(*p))

700

	p++;

701

702

    while (p < end && !_cairo_isspace(*p))

703

	p++;

704

705

    if (p == end)

706

	return NULL;

707

708

    return p;

709

710

711

static void

712

cairo_type1_font_subset_decrypt_charstring (const unsigned char *in, int size, unsigned char *out)

713

714

    unsigned short r = CAIRO_TYPE1_CHARSTRING_KEY;

715

    int c, p, i;

716

717

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

718

        c = *in++;

719

	p = c ^ (r >> 8);

720

	r = (c + r) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2;

721

	*out++ = p;

722

723

724

725

static cairo_status_t

726

cairo_type1_font_subset_decode_integer (const unsigned char **p, const unsigned char *end, int *integer)

727

728

    const unsigned char *pp = *p;

729

    if (*pp <= 246 && pp + 1 <= end) {

730

        *integer = *pp - 139;

731

        *p += 1;

732

    } else if (*pp <= 250 && pp + 2 <= end) {

733

        *integer = (pp[0] - 247) * 256 + pp[1] + 108;

734

        *p += 2;

735

    } else if (*pp <= 254 && pp + 2 <= end) {

736

        *integer = -(pp[0] - 251) * 256 - pp[1] - 108;

737

        *p += 2;

738

    } else if (pp + 5 <= end) {

739

        *integer = ((uint32_t)pp[1] << 24) | (pp[2] << 16) | (pp[3] << 8) | pp[4];

740

        *p += 5;

741

    } else {

742

        return CAIRO_INT_STATUS_UNSUPPORTED;

743

744

745

    return CAIRO_STATUS_SUCCESS;

746

747

748

static cairo_status_t

749

use_standard_encoding_glyph (cairo_type1_font_subset_t *font, int index)

750

751

    const char *glyph_name;

752

    unsigned int i;

753

754

    if (index < 0 || index > 255)

755

	return CAIRO_STATUS_SUCCESS;

756

757

    glyph_name = _cairo_ps_standard_encoding_to_glyphname (index);

758

    if (glyph_name == NULL)

759

	return CAIRO_STATUS_SUCCESS;

760

761

    for (i = 0; i < font->base.num_glyphs; i++) {

762

	if (font->glyph_names[i] &&  strcmp (font->glyph_names[i], glyph_name) == 0) {

763

	    cairo_type1_font_subset_use_glyph (font, i);

764

765

	    return CAIRO_STATUS_SUCCESS;

766

767

768

769

    return CAIRO_INT_STATUS_UNSUPPORTED;

770

771

772

773

#define TYPE1_CHARSTRING_COMMAND_HSTEM		 0x01

774

#define TYPE1_CHARSTRING_COMMAND_VSTEM		 0x03

775

#define TYPE1_CHARSTRING_COMMAND_VMOVETO	 0x04

776

#define TYPE1_CHARSTRING_COMMAND_RLINETO	 0x05

777

#define TYPE1_CHARSTRING_COMMAND_HLINETO	 0x06

778

#define TYPE1_CHARSTRING_COMMAND_VLINETO	 0x07

779

#define TYPE1_CHARSTRING_COMMAND_RRCURVETO	 0x08

780

#define TYPE1_CHARSTRING_COMMAND_CLOSEPATH	 0x09

781

#define TYPE1_CHARSTRING_COMMAND_CALLSUBR	 0x0a

782

#define TYPE1_CHARSTRING_COMMAND_RETURN		 0x0b

783

#define TYPE1_CHARSTRING_COMMAND_ESCAPE		 0x0c

784

#define TYPE1_CHARSTRING_COMMAND_HSBW		 0x0d

785

#define TYPE1_CHARSTRING_COMMAND_ENDCHAR	 0x0e

786

#define TYPE1_CHARSTRING_COMMAND_RMOVETO	 0x15

787

#define TYPE1_CHARSTRING_COMMAND_HMOVETO	 0x16

788

#define TYPE1_CHARSTRING_COMMAND_VHCURVETO	 0x1e

789

#define TYPE1_CHARSTRING_COMMAND_HVCURVETO	 0x1f

790

#define TYPE1_CHARSTRING_COMMAND_DOTSECTION	 0x0c00

791

#define TYPE1_CHARSTRING_COMMAND_VSTEM3		 0x0c01

792

#define TYPE1_CHARSTRING_COMMAND_HSTEM3		 0x0c02

793

#define TYPE1_CHARSTRING_COMMAND_SEAC		 0x0c06

794

#define TYPE1_CHARSTRING_COMMAND_SBW		 0x0c07

795

#define TYPE1_CHARSTRING_COMMAND_DIV		 0x0c0c

796

#define TYPE1_CHARSTRING_COMMAND_CALLOTHERSUBR   0x0c10

797

#define TYPE1_CHARSTRING_COMMAND_POP	         0x0c11

798

#define TYPE1_CHARSTRING_COMMAND_SETCURRENTPOINT 0x0c21

799

800

/* Parse the charstring, including recursing into subroutines. Find

801

 * the glyph width, subroutines called, and glyphs required by the

802

 * SEAC operator. */

803

static cairo_status_t

804

cairo_type1_font_subset_parse_charstring (cairo_type1_font_subset_t *font,

805

					  int                        glyph,

806

					  const char                *encrypted_charstring,

807

					  int                        encrypted_charstring_length)

808

809

    cairo_status_t status;

810

    unsigned char *charstring;

811

    const unsigned char *end;

812

    const unsigned char *p;

813

    int command;

814

815

    charstring = _cairo_malloc (encrypted_charstring_length);

816

    if (unlikely (charstring == NULL))

817

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

818

819

    cairo_type1_font_subset_decrypt_charstring ((const unsigned char *)

820

						encrypted_charstring,

821

						encrypted_charstring_length,

822

						charstring);

823

    end = charstring + encrypted_charstring_length;

824

    p = charstring + font->lenIV;

825

    status = CAIRO_STATUS_SUCCESS;

826

    while (p < end) {

827

        if (*p < 32) {

828

	    command = *p++;

829

	    switch (command) {

830

	    case TYPE1_CHARSTRING_COMMAND_HSTEM:

831

	    case TYPE1_CHARSTRING_COMMAND_VSTEM:

832

	    case TYPE1_CHARSTRING_COMMAND_VMOVETO:

833

	    case TYPE1_CHARSTRING_COMMAND_RLINETO:

834

	    case TYPE1_CHARSTRING_COMMAND_HLINETO:

835

	    case TYPE1_CHARSTRING_COMMAND_VLINETO:

836

	    case TYPE1_CHARSTRING_COMMAND_RRCURVETO:

837

	    case TYPE1_CHARSTRING_COMMAND_CLOSEPATH:

838

	    case TYPE1_CHARSTRING_COMMAND_RMOVETO:

839

	    case TYPE1_CHARSTRING_COMMAND_HMOVETO:

840

	    case TYPE1_CHARSTRING_COMMAND_VHCURVETO:

841

	    case TYPE1_CHARSTRING_COMMAND_HVCURVETO:

842

	    case TYPE1_CHARSTRING_COMMAND_RETURN:

843

	    case TYPE1_CHARSTRING_COMMAND_ENDCHAR:

844

	    default:

845

		/* stack clearing operator */

846

		font->build_stack.sp = 0;

847

		break;

848

849

	    case TYPE1_CHARSTRING_COMMAND_CALLSUBR:

850

		if (font->subset_subrs && font->build_stack.sp > 0) {

851

		    double int_val;

852

		    if (modf(font->build_stack.stack[--font->build_stack.sp], &int_val) == 0.0) {

853

			int subr_num = int_val;

854

			if (subr_num >= 0 && subr_num < font->num_subrs) {

855

			    font->subrs[subr_num].used = TRUE;

856

			    status = cairo_type1_font_subset_parse_charstring (

857

				font,

858

				glyph,

859

				font->subrs[subr_num].subr_string,

860

				font->subrs[subr_num].subr_length);

861

			    break;

862

863

864

865

		font->subset_subrs = FALSE;

866

		break;

867

868

	    case TYPE1_CHARSTRING_COMMAND_HSBW:

869

		if (font->build_stack.sp < 2) {

870

		    status = CAIRO_INT_STATUS_UNSUPPORTED;

871

		    goto cleanup;

872

873

874

		font->glyphs[glyph].width = font->build_stack.stack[1]/font->base.units_per_em;

875

		font->build_stack.sp = 0;

876

		break;

877

878

	    case TYPE1_CHARSTRING_COMMAND_ESCAPE:

879

		command = command << 8 | *p++;

880

		switch (command) {

881

		case TYPE1_CHARSTRING_COMMAND_DOTSECTION:

882

		case TYPE1_CHARSTRING_COMMAND_VSTEM3:

883

		case TYPE1_CHARSTRING_COMMAND_HSTEM3:

884

		case TYPE1_CHARSTRING_COMMAND_SETCURRENTPOINT:

885

		default:

886

		    /* stack clearing operator */

887

		    font->build_stack.sp = 0;

888

		    break;

889

890

		case TYPE1_CHARSTRING_COMMAND_SEAC:

891

		    /* The seac command takes five integer arguments.  The

892

		     * last two are glyph indices into the PS standard

893

		     * encoding give the names of the glyphs that this

894

		     * glyph is composed from.  All we need to do is to

895

		     * make sure those glyphs are present in the subset

896

		     * under their standard names. */

897

		    if (font->build_stack.sp < 5) {

898

			status = CAIRO_INT_STATUS_UNSUPPORTED;

899

			goto cleanup;

900

901

902

		    status = use_standard_encoding_glyph (font, font->build_stack.stack[3]);

903

		    if (unlikely (status))

904

			goto cleanup;

905

906

		    status = use_standard_encoding_glyph (font, font->build_stack.stack[4]);

907

		    if (unlikely (status))

908

			goto cleanup;

909

910

		    font->build_stack.sp = 0;

911

		    break;

912

913

		case TYPE1_CHARSTRING_COMMAND_SBW:

914

		    if (font->build_stack.sp < 4) {

915

			status = CAIRO_INT_STATUS_UNSUPPORTED;

916

			goto cleanup;

917

918

919

		    font->glyphs[glyph].width = font->build_stack.stack[2]/font->base.units_per_em;

920

		    font->build_stack.sp = 0;

921

		    break;

922

923

		case TYPE1_CHARSTRING_COMMAND_DIV:

924

		    if (font->build_stack.sp < 2) {

925

			status = CAIRO_INT_STATUS_UNSUPPORTED;

926

			goto cleanup;

927

		    } else {

928

			double num1 = font->build_stack.stack[font->build_stack.sp - 2];

929

			double num2 = font->build_stack.stack[font->build_stack.sp - 1];

930

			font->build_stack.sp--;

931

			if (num2 == 0.0) {

932

			    status = CAIRO_INT_STATUS_UNSUPPORTED;

933

			    goto cleanup;

934

935

			font->build_stack.stack[font->build_stack.sp - 1] = num1/num2;

936

937

		    break;

938

939

		case TYPE1_CHARSTRING_COMMAND_CALLOTHERSUBR:

940

		    if (font->build_stack.sp < 1) {

941

			status = CAIRO_INT_STATUS_UNSUPPORTED;

942

			goto cleanup;

943

944

945

		    font->build_stack.sp--;

946

		    font->ps_stack.sp = 0;

947

		    while (font->build_stack.sp)

948

			font->ps_stack.stack[font->ps_stack.sp++] = font->build_stack.stack[--font->build_stack.sp];

949

950

                    break;

951

952

		case TYPE1_CHARSTRING_COMMAND_POP:

953

		    if (font->ps_stack.sp < 1) {

954

			status = CAIRO_INT_STATUS_UNSUPPORTED;

955

			goto cleanup;

956

957

958

		    /* T1 spec states that if the interpreter does not

959

		     * support executing the callothersub, the results

960

		     * must be taken from the callothersub arguments. */

961

		    font->build_stack.stack[font->build_stack.sp++] = font->ps_stack.stack[--font->ps_stack.sp];

962

		    break;

963

964

		break;

965

966

	} else {

967

            /* integer argument */

968

	    if (font->build_stack.sp < TYPE1_STACKSIZE) {

969

		int val;

970

		status = cairo_type1_font_subset_decode_integer (&p, end, &val);

971

		if (unlikely (status))

972

		    goto cleanup;

973

		font->build_stack.stack[font->build_stack.sp++] = val;

974

	    } else {

975

		status = CAIRO_INT_STATUS_UNSUPPORTED;

976

		goto cleanup;

977

978

979

980

981

cleanup:

982

    free (charstring);

983

984

    return status;

985

986

987

static cairo_status_t

988

cairo_type1_font_subset_build_subr_list (cairo_type1_font_subset_t *font,

989

					 int subr_number,

990

					 const char *encrypted_charstring, int encrypted_charstring_length,

991

					 const char *np, int np_length)

992

993

994

    font->subrs[subr_number].subr_string = encrypted_charstring;

995

    font->subrs[subr_number].subr_length = encrypted_charstring_length;

996

    font->subrs[subr_number].np = np;

997

    font->subrs[subr_number].np_length = np_length;

998

999

    return CAIRO_STATUS_SUCCESS;

1000

1001

1002

static cairo_status_t

1003

write_used_subrs (cairo_type1_font_subset_t *font,

1004

		  int subr_number,

1005

		  const char *subr_string, int subr_string_length,

1006

		  const char *np, int np_length)

1007

1008

    cairo_status_t status;

1009

    char buffer[256];

1010

    int length;

1011

1012

    if (!font->subrs[subr_number].used)

1013

	return CAIRO_STATUS_SUCCESS;

1014

1015

    length = snprintf (buffer, sizeof buffer,

1016

		       "dup %d %d %s ",

1017

		       subr_number, subr_string_length, font->rd);

1018

    status = cairo_type1_font_subset_write_encrypted (font, buffer, length);

1019

    if (unlikely (status))

1020

	return status;

1021

1022

    status = cairo_type1_font_subset_write_encrypted (font,

1023

					              subr_string,

1024

						      subr_string_length);

1025

    if (unlikely (status))

1026

	return status;

1027

1028

    if (np) {

1029

	status = cairo_type1_font_subset_write_encrypted (font, np, np_length);

1030

    } else {

1031

	length = snprintf (buffer, sizeof buffer, "%s\n", font->np);

1032

	status = cairo_type1_font_subset_write_encrypted (font, buffer, length);

1033

1034

    if (unlikely (status))

1035

	return status;

1036

1037

    return CAIRO_STATUS_SUCCESS;

1038

1039

1040

typedef cairo_status_t (*subr_func_t) (cairo_type1_font_subset_t *font,

1041

				       int subr_number,

1042

				       const char *subr_string, int subr_string_length,

1043

				       const char *np, int np_length);

1044

1045

static cairo_status_t

1046

cairo_type1_font_for_each_subr (cairo_type1_font_subset_t  *font,

1047

				const char                 *array_start,

1048

				const char                 *cleartext_end,

1049

				subr_func_t                 func,

1050

				const char                **array_end)

1051

1052

    const char *p, *subr_string;

1053

    char *end;

1054

    int subr_num, subr_length;

1055

    const char *np;

1056

    int np_length;

1057

    cairo_status_t status;

1058

1059

    /* We're looking at "dup" at the start of the first subroutine. The subroutines

1060

     * definitions are on the form:

1061

1062

     *   dup 5 23 RD <23 binary bytes> NP

1063

1064

     * or alternatively using -| and |- instead of RD and ND.

1065

     * The first number is the subroutine number.

1066

*/

1067

1068

    p = array_start;

1069

    while (p + 3 < cleartext_end && strncmp (p, "dup", 3) == 0) {

1070

	p = skip_token (p, cleartext_end);

1071

1072

	/* get subr number */

1073

	subr_num = strtol (p, &end, 10);

1074

	if (p == end)

1075

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1076

1077

	if (subr_num < 0 || subr_num >= font->num_subrs)

1078

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1079

1080

	/* get subr length */

1081

	p = end;

1082

	subr_length = strtol (p, &end, 10);

1083

	if (p == end)

1084

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1085

1086

	/* Skip past -| or RD to binary data.  There is exactly one space

1087

	 * between the -| or RD token and the encrypted data, thus '+ 1'. */

1088

	subr_string = skip_token (end, cleartext_end) + 1;

1089

1090

	np = NULL;

1091

	np_length = 0;

1092

1093

	/* Skip binary data and | or NP token. */

1094

	p = skip_token (subr_string + subr_length, cleartext_end);

1095

        if (p == NULL)

1096

            return CAIRO_INT_STATUS_UNSUPPORTED;

1097

1098

	while (p < cleartext_end && _cairo_isspace(*p))

1099

	    p++;

1100

1101

	/* Some fonts have "noaccess put" instead of "NP" */

1102

	if (p + 3 < cleartext_end && strncmp (p, "put", 3) == 0) {

1103

	    p = skip_token (p, cleartext_end);

1104

	    while (p < cleartext_end && _cairo_isspace(*p))

1105

		p++;

1106

1107

	    np = subr_string + subr_length;

1108

	    np_length = p - np;

1109

1110

1111

	status = func (font, subr_num,

1112

		       subr_string, subr_length, np, np_length);

1113

	if (unlikely (status))

1114

	    return status;

1115

1116

1117

1118

    *array_end = (char *) p;

1119

1120

    return CAIRO_STATUS_SUCCESS;

1121

1122

1123

static cairo_status_t

1124

cairo_type1_font_subset_build_glyph_list (cairo_type1_font_subset_t *font,

1125

					  int glyph_number,

1126

					  const char *name, int name_length,

1127

					  const char *encrypted_charstring, int encrypted_charstring_length)

1128

1129

    char *s;

1130

    glyph_data_t glyph;

1131

    cairo_status_t status;

1132

1133

    s = _cairo_malloc (name_length + 1);

1134

    if (unlikely (s == NULL))

1135

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1136

1137

    strncpy (s, name, name_length);

1138

    s[name_length] = 0;

1139

1140

    status = _cairo_array_append (&font->glyph_names_array, &s);

1141

    if (unlikely (status))

1142

	return status;

1143

1144

    glyph.subset_index = -1;

1145

    glyph.width = 0;

1146

    glyph.encrypted_charstring = encrypted_charstring;

1147

    glyph.encrypted_charstring_length = encrypted_charstring_length;

1148

    status = _cairo_array_append (&font->glyphs_array, &glyph);

1149

1150

    return status;

1151

1152

1153

static cairo_status_t

1154

write_used_glyphs (cairo_type1_font_subset_t *font,

1155

		   int glyph_number,

1156

		   const char *name, int name_length,

1157

		   const char *charstring, int charstring_length)

1158

1159

    cairo_status_t status;

1160

    char buffer[256];

1161

    int length;

1162

    unsigned int subset_id;

1163

    int ch;

1164

    const char *wa_name;

1165

1166

    if (font->glyphs[glyph_number].subset_index < 0)

1167

	return CAIRO_STATUS_SUCCESS;

1168

1169

    if (font->scaled_font_subset->is_latin) {

1170

	/* When using the WinAnsi encoding in PDF, the /Encoding array

1171

	 * is ignored and instead glyphs are keyed by glyph names. To

1172

	 * ensure correct rendering we replace the glyph name in the

1173

	 * font with the standard name.

1174

**/

1175

	subset_id = font->glyphs[glyph_number].subset_index;

1176

	/* Any additional glyph included for use by the seac operator

1177

	 * will either have subset_id >= font->scaled_font_subset->num_glyphs

1178

	 * or will not map to a winansi name (wa_name = NULL).  In this

1179

	 * case the original name is used.

1180

*/

1181

	if (subset_id > 0 && subset_id < font->scaled_font_subset->num_glyphs) {

1182

	    ch = font->scaled_font_subset->to_latin_char[subset_id];

1183

	    wa_name = _cairo_winansi_to_glyphname (ch);

1184

	    if (wa_name) {

1185

		name = wa_name;

1186

		name_length = strlen(name);

1187

1188

1189

1190

1191

    length = snprintf (buffer, sizeof buffer,

1192

		       "/%.*s %d %s ",

1193

		       name_length, name, charstring_length, font->rd);

1194

    status = cairo_type1_font_subset_write_encrypted (font, buffer, length);

1195

    if (unlikely (status))

1196

	return status;

1197

1198

    status = cairo_type1_font_subset_write_encrypted (font,

1199

					              charstring,

1200

						      charstring_length);

1201

    if (unlikely (status))

1202

	return status;

1203

1204

    length = snprintf (buffer, sizeof buffer, "%s\n", font->nd);

1205

    status = cairo_type1_font_subset_write_encrypted (font, buffer, length);

1206

    if (unlikely (status))

1207

	return status;

1208

1209

    return CAIRO_STATUS_SUCCESS;

1210

1211

1212

typedef cairo_status_t (*glyph_func_t) (cairo_type1_font_subset_t *font,

1213

					int glyph_number,

1214

			                const char *name, int name_length,

1215

			                const char *charstring, int charstring_length);

1216

1217

static cairo_status_t

1218

cairo_type1_font_subset_for_each_glyph (cairo_type1_font_subset_t *font,

1219

					const char *dict_start,

1220

					const char *dict_end,

1221

					glyph_func_t func,

1222

					const char **dict_out)

1223

1224

    int charstring_length, name_length;

1225

    const char *p, *charstring, *name;

1226

    char *end;

1227

    cairo_status_t status;

1228

    int glyph_count;

1229

1230

    /* We're looking at '/' in the name of the first glyph.  The glyph

1231

     * definitions are on the form:

1232

1233

     *   /name 23 RD <23 binary bytes> ND

1234

1235

     * or alternatively using -| and |- instead of RD and ND.

1236

1237

     * We parse the glyph name and see if it is in the subset.  If it

1238

     * is, we call the specified callback with the glyph name and

1239

     * glyph data, otherwise we just skip it.  We need to parse

1240

     * through a glyph definition; we can't just find the next '/',

1241

     * since the binary data could contain a '/'.

1242

*/

1243

1244

    p = dict_start;

1245

    glyph_count = 0;

1246

    while (*p == '/') {

1247

	name = p + 1;

1248

	p = skip_token (p, dict_end);

1249

	name_length = p - name;

1250

1251

	charstring_length = strtol (p, &end, 10);

1252

	if (p == end)

1253

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1254

1255

	/* Skip past -| or RD to binary data.  There is exactly one space

1256

	 * between the -| or RD token and the encrypted data, thus '+ 1'. */

1257

	charstring = skip_token (end, dict_end) + 1;

1258

1259

	/* Skip binary data and |- or ND token. */

1260

	p = skip_token (charstring + charstring_length, dict_end);

1261

        if (p == NULL)

1262

            return CAIRO_INT_STATUS_UNSUPPORTED;

1263

1264

	while (p < dict_end && _cairo_isspace(*p))

1265

	    p++;

1266

1267

	/* In case any of the skip_token() calls above reached EOF, p will

1268

	 * be equal to dict_end. */

1269

	if (p == dict_end)

1270

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1271

1272

	status = func (font, glyph_count++,

1273

		       name, name_length,

1274

		       charstring, charstring_length);

1275

	if (unlikely (status))

1276

	    return status;

1277

1278

1279

    *dict_out = p;

1280

1281

    return CAIRO_STATUS_SUCCESS;

1282

1283

1284

1285

static cairo_status_t

1286

cairo_type1_font_subset_write_private_dict (cairo_type1_font_subset_t *font,

1287

					    const char                *name)

1288

1289

    cairo_status_t status;

1290

    const char *p, *subrs, *charstrings, *array_start, *array_end, *dict_start, *dict_end;

1291

    const char *lenIV_start, *lenIV_end, *closefile_token;

1292

    char buffer[32], *lenIV_str, *subr_count_end, *glyph_count_end;

1293

    int ret, lenIV, length;

1294

    const cairo_scaled_font_backend_t *backend;

1295

    unsigned int i;

1296

    int glyph, j;

1297

1298

    /* The private dict holds hint information, common subroutines and

1299

     * the actual glyph definitions (charstrings).

1300

1301

     * What we do here is scan directly to the /Subrs token, which

1302

     * marks the beginning of the subroutines. We read in all the

1303

     * subroutines, then move on to the /CharString token, which marks

1304

     * the beginning of the glyph definitions, and read in the charstrings.

1305

1306

     * The charstrings are parsed to extract glyph widths, work out

1307

     * which subroutines are called, and to see if any extra glyphs

1308

     * need to be included due to the use of the seac glyph combining

1309

     * operator.

1310

1311

     * Finally, the private dict is copied to the subset font minus the

1312

     * subroutines and charstrings not required.

1313

*/

1314

1315

    /* Determine lenIV, the number of random characters at the start of

1316

       each encrypted charstring. The default is 4, but this can be

1317

       overridden in the private dict. */

1318

    font->lenIV = 4;

1319

    if ((lenIV_start = find_token (font->cleartext, font->cleartext_end, "/lenIV")) != NULL) {

1320

        lenIV_start += 6;

1321

        lenIV_end = find_token (lenIV_start, font->cleartext_end, "def");

1322

        if (lenIV_end == NULL)

1323

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1324

1325

        lenIV_str = _cairo_malloc (lenIV_end - lenIV_start + 1);

1326

        if (unlikely (lenIV_str == NULL))

1327

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1328

1329

        strncpy (lenIV_str, lenIV_start, lenIV_end - lenIV_start);

1330

        lenIV_str[lenIV_end - lenIV_start] = 0;

1331

1332

        ret = sscanf(lenIV_str, "%d", &lenIV);

1333

        free(lenIV_str);

1334

1335

        if (unlikely (ret <= 0))

1336

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1337

1338

        /* Apparently some fonts signal unencrypted charstrings with a negative lenIV,

1339

           though this is not part of the Type 1 Font Format specification.  See, e.g.

1340

           http://lists.gnu.org/archive/html/freetype-devel/2000-06/msg00064.html. */

1341

        if (unlikely (lenIV < 0))

1342

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1343

1344

        font->lenIV = lenIV;

1345

1346

1347

    /* Find start of Subrs */

1348

    subrs = find_token (font->cleartext, font->cleartext_end, "/Subrs");

1349

    if (subrs == NULL) {

1350

	font->subset_subrs = FALSE;

1351

	p = font->cleartext;

1352

	array_start = NULL;

1353

	goto skip_subrs;

1354

1355

1356

    /* Scan past /Subrs and get the array size. */

1357

    p = subrs + strlen ("/Subrs");

1358

    font->num_subrs = strtol (p, &subr_count_end, 10);

1359

    if (subr_count_end == p)

1360

	return CAIRO_INT_STATUS_UNSUPPORTED;

1361

1362

    if (font->num_subrs <= 0)

1363

	return CAIRO_INT_STATUS_UNSUPPORTED;

1364

1365

    font->subrs = _cairo_calloc_ab (font->num_subrs, sizeof (font->subrs[0]));

1366

    if (unlikely (font->subrs == NULL))

1367

        return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1368

1369

    /* look for "dup" which marks the beginning of the first subr */

1370

    array_start = find_token (subr_count_end, font->cleartext_end, "dup");

1371

    if (array_start == NULL)

1372

	return CAIRO_INT_STATUS_UNSUPPORTED;

1373

1374

    /* Read in the subroutines */

1375

    status = cairo_type1_font_for_each_subr (font,

1376

					     array_start,

1377

					     font->cleartext_end,

1378

					     cairo_type1_font_subset_build_subr_list,

1379

					     &array_end);

1380

    if (unlikely(status))

1381

	return status;

1382

1383

    p = array_end;

1384

skip_subrs:

1385

1386

    /* Find start of CharStrings */

1387

    charstrings = find_token (p, font->cleartext_end, "/CharStrings");

1388

    if (charstrings == NULL)

1389

	return CAIRO_INT_STATUS_UNSUPPORTED;

1390

1391

    /* Scan past /CharStrings and the integer following it. */

1392

    p = charstrings + strlen ("/CharStrings");

1393

    strtol (p, &glyph_count_end, 10);

1394

    if (p == glyph_count_end)

1395

	return CAIRO_INT_STATUS_UNSUPPORTED;

1396

1397

    /* Look for a '/' which marks the beginning of the first glyph

1398

     * definition. */

1399

    for (p = glyph_count_end; p < font->cleartext_end; p++)

1400

	if (*p == '/')

1401

	    break;

1402

    if (p == font->cleartext_end)

1403

	return CAIRO_INT_STATUS_UNSUPPORTED;

1404

    dict_start = p;

1405

1406

    /* Now that we have the private dictionary broken down in

1407

     * sections, do the first pass through the glyph definitions to

1408

     * build a list of glyph names and charstrings. */

1409

    status = cairo_type1_font_subset_for_each_glyph (font,

1410

						     dict_start,

1411

						     font->cleartext_end,

1412

						     cairo_type1_font_subset_build_glyph_list,

1413

						     &dict_end);

1414

    if (unlikely(status))

1415

	return status;

1416

1417

    font->glyphs = _cairo_array_index (&font->glyphs_array, 0);

1418

    font->glyph_names = _cairo_array_index (&font->glyph_names_array, 0);

1419

    font->base.num_glyphs = _cairo_array_num_elements (&font->glyphs_array);

1420

    font->type1_subset_index_to_glyphs = _cairo_calloc_ab (font->base.num_glyphs,

1421

							sizeof font->type1_subset_index_to_glyphs[0]);

1422

    if (unlikely (font->type1_subset_index_to_glyphs == NULL))

1423

        return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1424

1425

    backend = font->scaled_font_subset->scaled_font->backend;

1426

    if (!backend->index_to_glyph_name)

1427

	return CAIRO_INT_STATUS_UNSUPPORTED;

1428

1429

    /* Find the glyph number corresponding to each glyph in the subset

1430

     * and mark it as in use */

1431

1432

    for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {

1433

	unsigned long index;

1434

1435

	status = backend->index_to_glyph_name (font->scaled_font_subset->scaled_font,

1436

					       font->glyph_names,

1437

					       font->base.num_glyphs,

1438

					       font->scaled_font_subset->glyphs[i],

1439

					       &index);

1440

	if (unlikely(status))

1441

	    return status;

1442

1443

	cairo_type1_font_subset_use_glyph (font, index);

1444

	font->scaled_subset_index_to_glyphs[i] = index;

1445

1446

1447

    /* Go through the charstring of each glyph in use, get the glyph

1448

     * width and figure out which extra glyphs may be required by the

1449

     * seac operator (which may cause font->num_glyphs to increase

1450

     * while this loop is executing). Also subset the Subrs. */

1451

    for (j = 0; j < font->num_glyphs; j++) {

1452

	glyph = font->type1_subset_index_to_glyphs[j];

1453

	font->build_stack.sp = 0;

1454

	font->ps_stack.sp = 0;

1455

	status = cairo_type1_font_subset_parse_charstring (font,

1456

							   glyph,

1457

							   font->glyphs[glyph].encrypted_charstring,

1458

							   font->glyphs[glyph].encrypted_charstring_length);

1459

	if (unlikely (status))

1460

	    return status;

1461

1462

1463

    /* Always include the first five subroutines in case the Flex/hint mechanism is

1464

     * being used. */

1465

    for (j = 0; j < MIN (font->num_subrs, 5); j++) {

1466

	font->subrs[j].used = TRUE;

1467

1468

1469

    closefile_token = find_token (dict_end, font->cleartext_end, "closefile");

1470

    if (closefile_token == NULL)

1471

	return CAIRO_INT_STATUS_UNSUPPORTED;

1472

1473

    /* We're ready to start outputting. First write the header,

1474

     * i.e. the public part of the font dict.*/

1475

    status = cairo_type1_font_subset_write_header (font, name);

1476

    if (unlikely (status))

1477

	return status;

1478

1479

    font->base.header_size = _cairo_output_stream_get_position (font->output);

1480

1481

    /* Start outputting the private dict */

1482

    if (font->subset_subrs) {

1483

	/* First output everything up to the start of the Subrs array. */

1484

	status = cairo_type1_font_subset_write_encrypted (font, font->cleartext,

1485

							  array_start - font->cleartext);

1486

	if (unlikely (status))

1487

	    return status;

1488

1489

	/* Write out the subr definitions for each of the glyphs in

1490

	 * the subset. */

1491

	status = cairo_type1_font_for_each_subr (font,

1492

						 array_start,

1493

						 font->cleartext_end,

1494

						 write_used_subrs,

1495

						 &p);

1496

	if (unlikely (status))

1497

	    return status;

1498

    } else {

1499

	p = font->cleartext;

1500

1501

1502

    /* If subr subsetting, output everything from end of subrs to

1503

     * start of /CharStrings token.  If not subr subsetting, output

1504

     * everything start of private dict to start of /CharStrings

1505

     * token. */

1506

    status = cairo_type1_font_subset_write_encrypted (font, p, charstrings - p);

1507

    if (unlikely (status))

1508

	return status;

1509

1510

    /* Write out new charstring count */

1511

    length = snprintf (buffer, sizeof buffer,

1512

		       "/CharStrings %d", font->num_glyphs);

1513

    status = cairo_type1_font_subset_write_encrypted (font, buffer, length);

1514

    if (unlikely (status))

1515

	return status;

1516

1517

    /* Write out text between the charstring count and the first

1518

     * charstring definition */

1519

    status = cairo_type1_font_subset_write_encrypted (font, glyph_count_end,

1520

	                                          dict_start - glyph_count_end);

1521

    if (unlikely (status))

1522

	return status;

1523

1524

    /* Write out the charstring definitions for each of the glyphs in

1525

     * the subset. */

1526

    status = cairo_type1_font_subset_for_each_glyph (font,

1527

						     dict_start,

1528

						     font->cleartext_end,

1529

						     write_used_glyphs,

1530

						     &p);

1531

    if (unlikely (status))

1532

	return status;

1533

1534

    /* Output what's left between the end of the glyph definitions and

1535

     * the end of the private dict to the output. */

1536

    status = cairo_type1_font_subset_write_encrypted (font, p,

1537

	                        closefile_token - p + strlen ("closefile") + 1);

1538

    if (unlikely (status))

1539

	return status;

1540

1541

    if (font->hex_encode)

1542

	_cairo_output_stream_write (font->output, "\n", 1);

1543

1544

    return CAIRO_STATUS_SUCCESS;

1545

1546

1547

static cairo_status_t

1548

cairo_type1_font_subset_write_trailer(cairo_type1_font_subset_t *font)

1549

1550

    const char *cleartomark_token;

1551

    int i;

1552

    static const char zeros[65] =

1553

	"0000000000000000000000000000000000000000000000000000000000000000\n";

1554

1555

1556

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

1557

	_cairo_output_stream_write (font->output, zeros, sizeof zeros);

1558

1559

    cleartomark_token = find_token (font->type1_data, font->type1_end, "cleartomark");

1560

    if (cleartomark_token) {

1561

	/* Some fonts have conditional save/restore around the entire

1562

	 * font dict, so we need to retain whatever postscript code

1563

	 * that may come after 'cleartomark'. */

1564

1565

	_cairo_output_stream_write (font->output, cleartomark_token,

1566

				    font->type1_end - cleartomark_token);

1567

	if (*(font->type1_end - 1) != '\n')

1568

	    _cairo_output_stream_printf (font->output, "\n");

1569

1570

    } else if (!font->eexec_segment_is_ascii) {

1571

	/* Fonts embedded in PDF may omit the fixed-content portion

1572

	 * that includes the 'cleartomark' operator. Type 1 in PDF is

1573

	 * always binary. */

1574

1575

	_cairo_output_stream_printf (font->output, "cleartomark\n");

1576

    } else {

1577

	return CAIRO_INT_STATUS_UNSUPPORTED;

1578

1579

1580

    /* some fonts do not have a newline at the end of the last line */

1581

    _cairo_output_stream_printf (font->output, "\n");

1582

1583

    return CAIRO_STATUS_SUCCESS;

1584

1585

1586

static cairo_status_t

1587

type1_font_write (void *closure, const unsigned char *data, unsigned int length)

1588

1589

    cairo_type1_font_subset_t *font = closure;

1590

1591

    return _cairo_array_append_multiple (&font->contents, data, length);

1592

1593

1594

static cairo_status_t

1595

cairo_type1_font_subset_write (cairo_type1_font_subset_t *font,

1596

			       const char *name)

1597

1598

    cairo_status_t status;

1599

1600

    status = cairo_type1_font_subset_find_segments (font);

1601

    if (unlikely (status))

1602

	return status;

1603

1604

    status = cairo_type1_font_subset_decrypt_eexec_segment (font);

1605

    if (unlikely (status))

1606

	return status;

1607

1608

    /* Determine which glyph definition delimiters to use. */

1609

    if (find_token (font->cleartext, font->cleartext_end, "/-|") != NULL) {

1610

	font->rd = "-|";

1611

	font->nd = "|-";

1612

	font->np = "|";

1613

    } else if (find_token (font->cleartext, font->cleartext_end, "/RD") != NULL) {

1614

	font->rd = "RD";

1615

	font->nd = "ND";

1616

	font->np = "NP";

1617

    } else {

1618

	/* Don't know *what* kind of font this is... */

1619

	return CAIRO_INT_STATUS_UNSUPPORTED;

1620

1621

1622

    font->eexec_key = CAIRO_TYPE1_PRIVATE_DICT_KEY;

1623

    font->hex_column = 0;

1624

1625

    status = cairo_type1_font_subset_get_bbox (font);

1626

    if (unlikely (status))

1627

	return status;

1628

1629

    status = cairo_type1_font_subset_get_fontname (font);

1630

    if (unlikely (status))

1631

	return status;

1632

1633

    status = cairo_type1_font_subset_write_private_dict (font, name);

1634

    if (unlikely (status))

1635

	return status;

1636

1637

    font->base.data_size = _cairo_output_stream_get_position (font->output) -

1638

	font->base.header_size;

1639

1640

    status = cairo_type1_font_subset_write_trailer (font);

1641

    if (unlikely (status))

1642

	return status;

1643

1644

    font->base.trailer_size =

1645

	_cairo_output_stream_get_position (font->output) -

1646

	font->base.header_size - font->base.data_size;

1647

1648

    return CAIRO_STATUS_SUCCESS;

1649

1650

1651

static cairo_bool_t

1652

check_fontdata_is_type1 (const unsigned char *data, long length)

1653

1654

    /* Test for  Type 1 Binary (PFB) */

1655

    if (length > 2 && data[0] == 0x80 && data[1] == 0x01)

1656

	return TRUE;

1657

1658

    /* Test for Type 1 1 ASCII (PFA) */

1659

    if (length > 2 && data[0] == '%' && data[1] == '!')

1660

	return TRUE;

1661

1662

    return FALSE;

1663

1664

1665

static cairo_status_t

1666

cairo_type1_font_subset_generate (void       *abstract_font,

1667

				  const char *name)

1668

1669

1670

    cairo_type1_font_subset_t *font = abstract_font;

1671

    cairo_scaled_font_t *scaled_font;

1672

    cairo_status_t status;

1673

    unsigned long data_length;

1674

1675

    scaled_font = font->scaled_font_subset->scaled_font;

1676

    if (!scaled_font->backend->load_type1_data)

1677

	return CAIRO_INT_STATUS_UNSUPPORTED;

1678

1679

    status = scaled_font->backend->load_type1_data (scaled_font, 0, NULL, &data_length);

1680

    if (status)

1681

	return CAIRO_INT_STATUS_UNSUPPORTED;

1682

1683

    font->type1_length = data_length;

1684

    font->type1_data = _cairo_malloc (font->type1_length);

1685

    if (unlikely (font->type1_data == NULL))

1686

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

1687

1688

    status = scaled_font->backend->load_type1_data (scaled_font, 0,

1689

						    (unsigned char *) font->type1_data,

1690

						    &data_length);

1691

    if (unlikely (status))

1692

        return status;

1693

1694

    if (!check_fontdata_is_type1 ((unsigned char *)font->type1_data, data_length))

1695

	return CAIRO_INT_STATUS_UNSUPPORTED;

1696

1697

    status = _cairo_array_grow_by (&font->contents, 4096);

1698

    if (unlikely (status))

1699

	return status;

1700

1701

    font->output = _cairo_output_stream_create (type1_font_write, NULL, font);

1702

    if (unlikely ((status = font->output->status)))

1703

	return status;

1704

1705

    status = cairo_type1_font_subset_write (font, name);

1706

    if (unlikely (status))

1707

	return status;

1708

1709

    font->base.data = _cairo_array_index (&font->contents, 0);

1710

1711

    return status;

1712

1713

1714

static cairo_status_t

1715

_cairo_type1_font_subset_fini (cairo_type1_font_subset_t *font)

1716

1717

    cairo_status_t status = CAIRO_STATUS_SUCCESS;

1718

    unsigned int i;

1719

1720

    /* If the subset generation failed, some of the pointers below may

1721

     * be NULL depending on at which point the error occurred. */

1722

1723

    _cairo_array_fini (&font->contents);

1724

1725

    free (font->type1_data);

1726

    for (i = 0; i < _cairo_array_num_elements (&font->glyph_names_array); i++) {

1727

	char **s;

1728

1729

	s = _cairo_array_index (&font->glyph_names_array, i);

1730

	free (*s);

1731

1732

    _cairo_array_fini (&font->glyph_names_array);

1733

    _cairo_array_fini (&font->glyphs_array);

1734

1735

    free (font->subrs);

1736

1737

    if (font->output != NULL)

1738

	status = _cairo_output_stream_destroy (font->output);

1739

1740

    free (font->base.base_font);

1741

1742

    free (font->scaled_subset_index_to_glyphs);

1743

1744

    free (font->type1_subset_index_to_glyphs);

1745

1746

    free (font->cleartext);

1747

1748

    return status;

1749

1750

1751

cairo_status_t

1752

_cairo_type1_subset_init (cairo_type1_subset_t		*type1_subset,

1753

			  const char			*name,

1754

			  cairo_scaled_font_subset_t	*scaled_font_subset,

1755

                          cairo_bool_t                   hex_encode)

1756

1757

    cairo_type1_font_subset_t font;

1758

    cairo_status_t status;

1759

    cairo_bool_t is_synthetic;

1760

    unsigned long length;

1761

    unsigned int i;

1762

    char buf[30];

1763

    int glyph;

1764

1765

    /* We need to use a fallback font if this font differs from the type1 outlines. */

1766

    if (scaled_font_subset->scaled_font->backend->is_synthetic) {

1767

	status = scaled_font_subset->scaled_font->backend->is_synthetic (scaled_font_subset->scaled_font, &is_synthetic);

1768

	if (unlikely (status))

1769

	    return status;

1770

1771

	if (is_synthetic)

1772

	    return CAIRO_INT_STATUS_UNSUPPORTED;

1773

1774

1775

    status = _cairo_type1_font_subset_init (&font, scaled_font_subset, hex_encode);

1776

    if (unlikely (status))

1777

	return status;

1778

1779

    status = cairo_type1_font_subset_generate (&font, name);

1780

    if (unlikely (status))

1781

	goto fail1;

1782

1783

    if (font.base.base_font) {

1784

	type1_subset->base_font = strdup (font.base.base_font);

1785

    } else {

1786

        snprintf(buf, sizeof (buf), "CairoFont-%u-%u",

1787

                 scaled_font_subset->font_id, scaled_font_subset->subset_id);

1788

	type1_subset->base_font = strdup (buf);

1789

1790

    if (unlikely (type1_subset->base_font == NULL))

1791

	goto fail1;

1792

1793

    type1_subset->widths = _cairo_calloc_ab (scaled_font_subset->num_glyphs, sizeof (double));

1794

    if (unlikely (type1_subset->widths == NULL))

1795

	goto fail2;

1796

1797

    for (i = 0; i < font.scaled_font_subset->num_glyphs; i++) {

1798

	glyph = font.scaled_subset_index_to_glyphs[i];

1799

	type1_subset->widths[i] = font.glyphs[glyph].width;

1800

1801

1802

    type1_subset->x_min = font.base.x_min;

1803

    type1_subset->y_min = font.base.y_min;

1804

    type1_subset->x_max = font.base.x_max;

1805

    type1_subset->y_max = font.base.y_max;

1806

    type1_subset->ascent = font.base.ascent;

1807

    type1_subset->descent = font.base.descent;

1808

1809

    length = font.base.header_size +

1810

	     font.base.data_size +

1811

	     font.base.trailer_size;

1812

    type1_subset->data = _cairo_malloc (length);

1813

    if (unlikely (type1_subset->data == NULL))

1814

	goto fail3;

1815

1816

    memcpy (type1_subset->data,

1817

	    _cairo_array_index (&font.contents, 0), length);

1818

1819

    type1_subset->header_length = font.base.header_size;

1820

    type1_subset->data_length = font.base.data_size;

1821

    type1_subset->trailer_length = font.base.trailer_size;

1822

1823

    return _cairo_type1_font_subset_fini (&font);

1824

1825

 fail3:

1826

    free (type1_subset->widths);

1827

 fail2:

1828

    free (type1_subset->base_font);

1829

 fail1:

1830

    _cairo_type1_font_subset_fini (&font);

1831

1832

    return status;

1833

1834

1835

void

1836

_cairo_type1_subset_fini (cairo_type1_subset_t *subset)

1837

1838

    free (subset->base_font);

1839

    free (subset->widths);

1840

    free (subset->data);

1841

1842

1843

cairo_bool_t

1844

_cairo_type1_scaled_font_is_type1 (cairo_scaled_font_t *scaled_font)

1845

1846

    cairo_status_t status;

1847

    unsigned long length;

1848

    unsigned char buf[64];

1849

1850

    if (!scaled_font->backend->load_type1_data)

1851

	return FALSE;

1852

1853

    status = scaled_font->backend->load_type1_data (scaled_font, 0, NULL, &length);

1854

    if (status)

1855

	return FALSE;

1856

1857

    /* We only need a few bytes to test for Type 1 */

1858

    if (length > sizeof (buf))

1859

	length = sizeof (buf);

1860

1861

    status = scaled_font->backend->load_type1_data (scaled_font, 0, buf, &length);

1862

    if (status)

1863

	return FALSE;

1864

1865

    return check_fontdata_is_type1 (buf, length);

1866

1867

1868

#endif /* CAIRO_HAS_FONT_SUBSET */