/* <string> getenv false */
static int
zgetenv(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
char *str;
byte *value;
int len = 0;
check_read_type(*op, t_string);
str = ref_to_string(op, imemory, "getenv key");
if (str == 0)
return_error(e_VMerror);
if (gp_getenv(str, (char *)0, &len) > 0) { /* key missing */
ifree_string((byte *) str, r_size(op) + 1, "getenv key");
make_false(op);
return 0;
}
value = ialloc_string(len, "getenv value");
if (value == 0) {
ifree_string((byte *) str, r_size(op) + 1, "getenv key");
return_error(e_VMerror);
}
DISCARD(gp_getenv(str, (char *)value, &len)); /* can't fail */
ifree_string((byte *) str, r_size(op) + 1, "getenv key");
/* Delete the stupid C string terminator. */
value = iresize_string(value, len, len - 1,
"getenv value"); /* can't fail */
push(1);
make_string(op - 1, a_all | icurrent_space, len - 1, value);
make_true(op);
return 0;
}
/* - .defaultpapersize false */
static int
zdefaultpapersize(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
byte *value;
int len = 0;
if (gp_defaultpapersize((char *)0, &len) > 0) {
/* no default paper size */
push(1);
make_false(op);
return 0;
}
value = ialloc_string(len, "defaultpapersize value");
if (value == 0) {
return_error(e_VMerror);
}
DISCARD(gp_defaultpapersize((char *)value, &len)); /* can't fail */
/* Delete the stupid C string terminator. */
value = iresize_string(value, len, len - 1,
"defaultpapersize value"); /* can't fail */
push(2);
make_string(op - 1, a_all | icurrent_space, len - 1, value);
make_true(op);
return 0;
}
/* <file> .filename false */
static int
zfilename(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
gs_const_string fname;
byte *str;
check_file(s, op);
if (sfilename(s, &fname) < 0) {
make_false(op);
return 0;
}
check_ostack(1);
str = ialloc_string(fname.size, "filename");
if (str == 0)
return_error(e_VMerror);
memcpy(str, fname.data, fname.size);
push(1); /* can't fail */
make_const_string( op - 1 ,
a_all | imemory_space((const struct gs_ref_memory_s*) imemory),
fname.size,
str);
make_true(op);
return 0;
}
/* Given a UTF-8 password string, convert it to the canonical form
* defined by SASLprep (RFC 4013). This is a permissive implementation,
* suitable for verifying existing passwords but not for creating new
* ones -- if you want to create a new password, you'll need to add a
* strict mode that returns stringprep errors to the user, and uses the
* STRINGPREP_NO_UNASSIGNED flag to disallow unassigned characters.
* <string> .saslprep <string> */
static int
zsaslprep(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
uint input_size = r_size(op);
byte *buffer;
uint buffer_size;
uint output_size;
Stringprep_rc err;
check_read_type(*op, t_string);
/* According to http://unicode.org/faq/normalization.html, converting
* a UTF-8 string to normalization form KC has a worst-case expansion
* factor of 11, so we allocate 11 times the length of the string plus
* 1 for the NUL terminator. If somehow that's still not big enough,
* stringprep will return STRINGPREP_TOO_SMALL_BUFFER; there's no
* danger of corrupting memory. */
buffer_size = input_size * 11 + 1;
buffer = ialloc_string(buffer_size, "saslprep result");
if (buffer == 0)
return_error(e_VMerror);
memcpy(buffer, op->value.bytes, input_size);
buffer[input_size] = '\0';
err = stringprep((char *)buffer, buffer_size, 0, stringprep_saslprep);
if (err != STRINGPREP_OK) {
ifree_string(buffer, buffer_size, "saslprep result");
/* Since we're just verifying the password to an existing
* document here, we don't care about "invalid input" errors
* like STRINGPREP_CONTAINS_PROHIBITED. In these cases, we
* ignore the error and return the original string unchanged --
* chances are it's not the right password anyway, and if it
* is we shouldn't gratuitously fail to decrypt the document.
*
* On the other hand, errors like STRINGPREP_NFKC_FAILED are
* real errors, and should be returned to the user.
*
* Fortunately, the stringprep error codes are sorted to make
* this easy: the errors we want to ignore are the ones with
* codes less than 100. */
if ((int)err < 100)
return 0;
return_error(e_ioerror);
}
output_size = strlen((char *)buffer);
buffer = iresize_string(buffer, buffer_size, output_size,
"saslprep result"); /* can't fail */
make_string(op, a_all | icurrent_space, output_size, buffer);
return 0;
}
/* <int> string <string> */
int
zstring(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
byte *sbody;
uint size;
check_int_leu(*op, max_string_size);
size = op->value.intval;
sbody = ialloc_string(size, "string");
if (sbody == 0)
return_error(e_VMerror);
make_string(op, a_all | icurrent_space, size, sbody);
memset(sbody, 0, size);
return 0;
}
/* <int> string <string> */
int
zstring(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
byte *sbody;
uint size;
check_type(*op, t_integer);
if (op->value.intval < 0 )
return_error(e_rangecheck);
if (op->value.intval > max_string_size )
return_error(e_limitcheck); /* to match Distiller */
size = op->value.intval;
sbody = ialloc_string(size, "string");
if (sbody == 0)
return_error(e_VMerror);
make_string(op, a_all | icurrent_space, size, sbody);
memset(sbody, 0, size);
return 0;
}
/* (password) <encryption dict> check_r6_password (key) true|false */
static int
zcheck_r6_password(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
ref *CryptDict, *Oref, *OEref, *Uref, *UEref, *Pref;
int code, PWlen;
unsigned char validation[32];
unsigned char output[32];
ref stref;
byte *body;
check_op(2);
CryptDict = op--;
Pref = op;
if (!r_has_type(CryptDict, t_dictionary))
return_error(e_typecheck);
if (!r_has_type(Pref, t_string))
return_error(e_typecheck);
code = dict_find_string(CryptDict, "O", &Oref);
if (code < 0 || !r_has_type(Oref, t_string)) {
return_error(e_typecheck);
}
code = dict_find_string(CryptDict, "OE", &OEref);
if (code < 0 || !r_has_type(OEref, t_string)) {
return_error(e_typecheck);
}
code = dict_find_string(CryptDict, "U", &Uref);
if (code < 0 || !r_has_type(Uref, t_string)) {
return_error(e_typecheck);
}
code = dict_find_string(CryptDict, "UE", &UEref);
if (code < 0 || !r_has_type(UEref, t_string)) {
return_error(e_typecheck);
}
pop(2);
op = osp;
PWlen = r_size(Pref);
/* First, try the password as the user password */
pdf_compute_encryption_key_r6((unsigned char *)Pref->value.const_bytes, PWlen, (unsigned char *)Oref->value.const_bytes,
(unsigned char *)OEref->value.const_bytes, (unsigned char *)Uref->value.const_bytes, (unsigned char *)UEref->value.const_bytes, 0, validation, output);
if (memcmp(validation, Uref->value.const_bytes, 32) != 0){
/* It wasn't the user password, maybe its the owner password */
pdf_compute_encryption_key_r6((unsigned char *)Pref->value.const_bytes, PWlen, (unsigned char *)Oref->value.const_bytes,
(unsigned char *)OEref->value.const_bytes, (unsigned char *)Uref->value.const_bytes, (unsigned char *)UEref->value.const_bytes, 1, validation, output);
if (memcmp(validation, Oref->value.const_bytes, 32) != 0){
/* Doesn't seem to be a valid password.... */
push(1);
make_bool(op, 0);
return 0;
}
}
body = ialloc_string(32, "r6 encryption key");
if (body == 0)
return_error(e_VMerror);
push(1);
memcpy(body, output, 32);
make_string(&stref, a_all | icurrent_space, 32, body);
ref_assign(op, &stref);
push(1);
make_bool(op, 1);
return 0;
}
/* allocation callback for query result */
static void *
pcache_alloc_callback(void *userdata, int bytes)
{
i_ctx_t *i_ctx_p = (i_ctx_t*)userdata;
return ialloc_string(bytes, "pcache buffer");
}
/* .getnativefonts [ [<name> <path>] ... ] */
static int
z_fontenum(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
void *enum_state;
int code = 0;
int e,elements;
char *fontname, *path;
fontenum_t *r, *results;
ref array;
uint length;
byte *string;
enum_state = gp_enumerate_fonts_init(imemory);
if (enum_state == NULL) {
/* put false on the stack and return */
push(1);
make_bool(op, false);
return code;
}
r = results = gs_malloc(imemory->non_gc_memory, 1, sizeof(fontenum_t), "fontenum list");
elements = 0;
while((code = gp_enumerate_fonts_next(enum_state, &fontname, &path )) > 0) {
if (fontname == NULL || path == NULL) {
gp_enumerate_fonts_free(enum_state);
return_error(e_ioerror);
}
length = strlen(fontname) + 1;
r->fontname = gs_malloc(imemory->non_gc_memory, length, 1, "native font name");
memcpy(r->fontname, fontname, length);
length = strlen(path) + 1;
r->path = gs_malloc(imemory->non_gc_memory, length, 1, "native font path");
memcpy(r->path, path, length);
r->next = gs_malloc(imemory->non_gc_memory, 1, sizeof(fontenum_t), "fontenum list");
r = r->next;
elements += 1;
}
gp_enumerate_fonts_free(enum_state);
code = ialloc_ref_array(&array, a_all | icurrent_space, elements, "native fontmap");
r = results;
for (e = 0; e < elements; e++) {
ref mapping;
code = ialloc_ref_array(&mapping, a_all | icurrent_space, 2, "native font mapping");
length = strlen(r->fontname);
string = ialloc_string(length, "native font name");
if (string == NULL)
return_error(e_VMerror);
memcpy(string, r->fontname, length);
make_string(&(mapping.value.refs[0]), a_all | icurrent_space, length, string);
length = strlen(r->path);
string = ialloc_string(length, "native font path");
if (string == NULL)
return_error(e_VMerror);
memcpy(string, r->path, length);
make_string(&(mapping.value.refs[1]), a_all | icurrent_space, length, string);
ref_assign(&(array.value.refs[e]), &mapping);
results = r;
r = r->next;
gs_free(imemory->non_gc_memory,
results->fontname, strlen(results->fontname) + 1, 1, "native font name");
gs_free(imemory->non_gc_memory,
results->path, strlen(results->path) + 1, 1, "native font path");
gs_free(imemory->non_gc_memory,
results, 1, sizeof(fontenum_t), "fontenum list");
}
push(2);
ref_assign(op-1, &array);
make_bool(op, true);
return code;
}
/* <prefix|null> <access_string> .tempfile <name_string> <file> */
static int
ztempfile(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const char *pstr;
char fmode[4];
int code = parse_file_access_string(op, fmode);
char prefix[gp_file_name_sizeof];
char fname[gp_file_name_sizeof];
uint fnlen;
FILE *sfile;
stream *s;
byte *buf, *sbody;
if (code < 0)
return code;
strcat(fmode, gp_fmode_binary_suffix);
if (r_has_type(op - 1, t_null))
pstr = gp_scratch_file_name_prefix;
else {
uint psize;
check_read_type(op[-1], t_string);
psize = r_size(op - 1);
if (psize >= gp_file_name_sizeof)
return_error(e_rangecheck);
memcpy(prefix, op[-1].value.const_bytes, psize);
prefix[psize] = 0;
pstr = prefix;
}
if (gp_file_name_is_absolute(pstr, strlen(pstr))) {
if (check_file_permissions(i_ctx_p, pstr, strlen(pstr),
"PermitFileWriting") < 0) {
return_error(e_invalidfileaccess);
}
} else if (!prefix_is_simple(pstr)) {
return_error(e_invalidfileaccess);
}
s = file_alloc_stream(imemory, "ztempfile(stream)");
if (s == 0)
return_error(e_VMerror);
buf = gs_alloc_bytes(imemory, file_default_buffer_size,
"ztempfile(buffer)");
if (buf == 0)
return_error(e_VMerror);
sfile = gp_open_scratch_file(imemory, pstr, fname, fmode);
if (sfile == 0) {
gs_free_object(imemory, buf, "ztempfile(buffer)");
return_error(e_invalidfileaccess);
}
fnlen = strlen(fname);
sbody = ialloc_string(fnlen, ".tempfile(fname)");
if (sbody == 0) {
gs_free_object(imemory, buf, "ztempfile(buffer)");
return_error(e_VMerror);
}
memcpy(sbody, fname, fnlen);
file_init_stream(s, sfile, fmode, buf, file_default_buffer_size);
code = ssetfilename(s, (const unsigned char*) fname, fnlen);
if (code < 0) {
gx_io_device *iodev_dflt = iodev_default(imemory);
sclose(s);
iodev_dflt->procs.delete_file(iodev_dflt, fname);
ifree_string(sbody, fnlen, ".tempfile(fname)");
return_error(e_VMerror);
}
make_string(op - 1, a_readonly | icurrent_space, fnlen, sbody);
make_stream_file(op, s, fmode);
return code;
}