/* $Xorg: t1io.c,v 1.3 2000/08/17 19:46:33 cpqbld Exp $ */
/* Copyright International Business Machines,Corp. 1991
* All Rights Reserved
*
* License to use, copy, modify, and distribute this software
* and its documentation for any purpose and without fee is
* hereby granted, provided that the above copyright notice
* appear in all copies and that both that copyright notice and
* this permission notice appear in supporting documentation,
* and that the name of IBM not be used in advertising or
* publicity pertaining to distribution of the software without
* specific, written prior permission.
*
* IBM PROVIDES THIS SOFTWARE "AS IS", WITHOUT ANY WARRANTIES
* OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT
* LIMITED TO ANY IMPLIED WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT OF
* THIRD PARTY RIGHTS. THE ENTIRE RISK AS TO THE QUALITY AND
* PERFORMANCE OF THE SOFTWARE, INCLUDING ANY DUTY TO SUPPORT
* OR MAINTAIN, BELONGS TO THE LICENSEE. SHOULD ANY PORTION OF
* THE SOFTWARE PROVE DEFECTIVE, THE LICENSEE (NOT IBM) ASSUMES
* THE ENTIRE COST OF ALL SERVICING, REPAIR AND CORRECTION. IN
* NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
* Author: Carol H. Thompson IBM Almaden Research Center
*/
/* $XFree86: xc/lib/font/Type1/t1io.c,v 3.8 2001/01/17 19:43:23 dawes Exp $ */
/*******************************************************************
* I/O package for Type 1 font reading
********************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifndef STATIC
#define STATIC static
#endif
#ifndef FONTMODULE
#include <fcntl.h>
#include <unistd.h>
#else
#include "Xdefs.h"
#include "Xmd.h" /* INT32 declaration */
#include "xf86_ansic.h"
#endif
#include "t1stdio.h"
#include "t1hdigit.h"
#ifdef WIN32
#include <X11/Xw32defs.h>
#endif
#include <X11/Xdefs.h>
/* Constants and variables used in the decryption */
#define c1 ((unsigned short)52845)
#define c2 ((unsigned short)22719)
static unsigned short r;
static int asc, Decrypt;
static int extrach;
static int haveextrach;
/* Our single FILE structure and buffer for this package */
STATIC F_FILE TheFile;
STATIC unsigned char TheBuffer[F_BUFSIZ];
/* Our routines */
static int T1Decrypt ( unsigned char *p, int len );
static int T1Fill ( F_FILE *f );
/* -------------------------------------------------------------- */
/*ARGSUSED*/
F_FILE *
T1Open(char *fn, /* Pointer to filename */
char *mode) /* Pointer to open mode string */
{
F_FILE *of = &TheFile;
int oflags = O_RDONLY; /* We know we are only reading */
Decrypt = 0;
#ifdef O_BINARY /* VMS or DOS */
oflags |= O_BINARY;
#endif
of->fd = open(fn, oflags, 0);
if (of->fd < 0)
return NULL;
/* Initialize the buffer information of our file descriptor */
of->b_base = TheBuffer;
of->b_size = F_BUFSIZ;
of->b_ptr = NULL;
of->b_cnt = 0;
of->flags = 0;
of->error = 0;
haveextrach = 0;
return &TheFile;
} /* end Open */
/* -------------------------------------------------------------- */
int /* Read one character */
T1Getc(F_FILE *f) /* Stream descriptor */
{
if (f->b_base == NULL) return EOF; /* already closed */
if (f->flags & UNGOTTENC) { /* there is an ungotten c */
f->flags &= ~UNGOTTENC;
return (int) f->ungotc;
}
if (f->b_cnt == 0) /* Buffer needs to be (re)filled */
f->b_cnt = T1Fill(f);
if (f->b_cnt > 0) return (f->b_cnt--, (int) *(f->b_ptr++));
else {
f->flags |= FIOEOF;
return EOF;
}
} /* end Getc */
/* -------------------------------------------------------------- */
int /* Put back one character */
T1Ungetc(int c,
F_FILE *f) /* Stream descriptor */
{
if (c != EOF) {
f->ungotc = c;
f->flags |= UNGOTTENC; /* set flag */
f->flags &= ~FIOEOF; /* reset EOF */
}
return c;
} /* end Ungetc */
/* -------------------------------------------------------------- */
int /* Read n items into caller's buffer */
T1Read(char *buffP, /* Buffer to be filled */
int size, /* Size of each item */
int n, /* Number of items to read */
F_FILE *f) /* Stream descriptor */
{
int bytelen, cnt, i;
F_char *p = (F_char *)buffP;
int icnt; /* Number of characters to read */
if (f->b_base == NULL) return 0; /* closed */
icnt = (size!=1)?n*size:n; /* Number of bytes we want */
if (f->flags & UNGOTTENC) { /* there is an ungotten c */
f->flags &= ~UNGOTTENC;
*(p++) = f->ungotc;
icnt--; bytelen = 1;
}
else bytelen = 0;
while (icnt > 0) {
/* First use any bytes we have buffered in the stream buffer */
if ((cnt=f->b_cnt) > 0) {
if (cnt > icnt) cnt = icnt;
for (i=0; i<cnt; i++) *(p++) = *(f->b_ptr++);
f->b_cnt -= cnt;
icnt -= cnt;
bytelen += cnt;
}
if ((icnt == 0) || (f->flags & FIOEOF)) break;
f->b_cnt = T1Fill(f);
}
return ((size!=1)?bytelen/size:bytelen);
} /* end Read */
/* -------------------------------------------------------------- */
int /* Close the file */
T1Close(F_FILE *f) /* Stream descriptor */
{
if (f->b_base == NULL) return 0; /* already closed */
f->b_base = NULL; /* no valid stream */
return close(f->fd);
} /* end Close */
/* -------------------------------------------------------------- */
F_FILE * /* Initialization */
T1eexec(F_FILE *f) /* Stream descriptor */
{
int i, c;
int H;
unsigned char *p;
unsigned char randomP[8];
r = 55665; /* initial key */
asc = 1; /* indicate ASCII form */
/* Consume the 4 random bytes, determining if we are also to
ASCIIDecodeHex as we process our input. (See pages 63-64
of the Adobe Type 1 Font Format book.) */
/* Skip over any initial white space chars */
while (HighHexP[c=_XT1getc(f)] == HWHITE_SPACE) ;
/* If ASCII, the next 7 chars are guaranteed consecutive */
randomP[0] = c; /* store first non white space char */
T1Read((pointer)(randomP+1), 1, 3, f); /* read 3 more, for a total of 4 */
/* store first four chars */
for (i=0,p=randomP; i<4; i++) { /* Check 4 valid ASCIIEncode chars */
if (HighHexP[*p++] > LAST_HDIGIT) { /* non-ASCII byte */
asc = 0;
break;
}
}
if (asc) { /* ASCII form, convert first eight bytes to binary */
T1Read((pointer)(randomP+4), 1, 4, f); /* Need four more */
for (i=0,p=randomP; i<4; i++) { /* Convert */
H = HighHexP[*p++];
randomP[i] = H | LowHexP[*p++];
}
}
/* Adjust our key */
for (i=0,p=randomP; i<4; i++) {
r = (*p++ + r) * c1 + c2;
}
/* Decrypt the remaining buffered bytes */
f->b_cnt = T1Decrypt(f->b_ptr, f->b_cnt);
Decrypt = 1;
return (T1Feof(f))?NULL:f;
} /* end eexec */
/* -------------------------------------------------------------- */
STATIC int
T1Decrypt(unsigned char *p, int len)
{
int n;
int H = 0, L;
unsigned char *inp = p;
unsigned char *tblP;
if (asc) {
if (haveextrach) {
H = extrach;
tblP = LowHexP;
}
else tblP = HighHexP;
for (n=0; len>0; len--) {
L = tblP[*inp++];
if (L == HWHITE_SPACE) continue;
if (L > LAST_HDIGIT) break;
if (tblP == HighHexP) { /* Got first hexit value */
H = L;
tblP = LowHexP;
} else { /* Got second hexit value; compute value and store it */
n++;
tblP = HighHexP;
H |= L;
/* H is an int, 0 <= H <= 255, so all of this will work */
*p++ = H ^ (r >> 8);
r = (H + r) * c1 + c2;
}
}
if (tblP != HighHexP) { /* We had an odd number of hexits */
extrach = H;
haveextrach = 1;
} else haveextrach = 0;
return n;
} else {
for (n = len; n>0; n--) {
H = *inp++;
*p++ = H ^ (r >> 8);
r = (H + r) * c1 + c2;
}
return len;
}
} /* end Decrypt */
/* -------------------------------------------------------------- */
STATIC int /* Refill stream buffer */
T1Fill(F_FILE *f) /* Stream descriptor */
{
int rc;
rc = read(f->fd, f->b_base, F_BUFSIZ);
/* propagate any error or eof to current file */
if (rc <= 0) {
if (rc == 0) /* means EOF */
f->flags |= FIOEOF;
else {
f->error = (short)-rc;
f->flags |= FIOERROR;
rc = 0;
}
}
f->b_ptr = f->b_base;
if (Decrypt) rc = T1Decrypt(f->b_base, rc);
return rc;
} /* end Fill */
|