/*
* We don't bother with the usual FSpExchangeFiles dance here because
* it doesn't really matter if the old random seed gets lost.
*/
void write_random_seed(void *data, int len)
{
short puttyVRefNum;
long puttyDirID;
OSErr error;
FSSpec dstfile;
short refnum;
long count = len;
if (get_putty_dir(kCreateFolder, &puttyVRefNum, &puttyDirID) != noErr)
return;
error = FSMakeFSSpec(puttyVRefNum, puttyDirID, "\pPuTTY Random Seed",
&dstfile);
if (error == fnfErr) {
/* Set up standard resources */
FSpCreateResFile(&dstfile, INTERNAL_CREATOR, SEED_TYPE, smRoman);
refnum = FSpOpenResFile(&dstfile, fsWrPerm);
if (ResError() == noErr) {
copy_resource('STR ', -16397);
CloseResFile(refnum);
}
} else if (error != noErr) return;
if (FSpOpenDF(&dstfile, fsWrPerm, &refnum) != noErr) return;
FSWrite(refnum, &count, data);
FSClose(refnum);
return;
}
static void
pdf_filter_cs(fz_context *ctx, pdf_processor *proc, const char *name, fz_colorspace *cs)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_gstate *gstate = gstate_to_update(ctx, p);
fz_strlcpy(gstate->cs.name, name, sizeof gstate->cs.name);
gstate->cs.cs = cs;
copy_resource(ctx, p, PDF_NAME_ColorSpace, name);
}
static void
pdf_filter_Tf(fz_context *ctx, pdf_processor *proc, const char *name, pdf_font_desc *font, float size)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_flush(ctx, p, 0);
if (p->chain->op_Tf)
p->chain->op_Tf(ctx, p->chain, name, font, size);
copy_resource(ctx, p, PDF_NAME_Font, name);
}
static void
pdf_filter_gs_begin(fz_context *ctx, pdf_processor *proc, const char *name, pdf_obj *extgstate)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_flush(ctx, p, FLUSH_ALL);
if (p->chain->op_gs_begin)
p->chain->op_gs_begin(ctx, p->chain, name, extgstate);
copy_resource(ctx, p, PDF_NAME_ExtGState, name);
}
static void
pdf_filter_Do_form(fz_context *ctx, pdf_processor *proc, const char *name, pdf_xobject *xobj, pdf_obj *page_resources)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_flush(ctx, p, FLUSH_ALL);
if (p->chain->op_Do_form)
p->chain->op_Do_form(ctx, p->chain, name, xobj, page_resources);
copy_resource(ctx, p, PDF_NAME_XObject, name);
}
static void
pdf_filter_Do_image(fz_context *ctx, pdf_processor *proc, const char *name, fz_image *image)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_flush(ctx, p, FLUSH_ALL);
if (p->chain->op_Do_image)
p->chain->op_Do_image(ctx, p->chain, name, image);
copy_resource(ctx, p, PDF_NAME_XObject, name);
}
static void
pdf_filter_sh(fz_context *ctx, pdf_processor *proc, const char *name, fz_shade *shade)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_flush(ctx, p, FLUSH_ALL);
if (p->chain->op_sh)
p->chain->op_sh(ctx, p->chain, name, shade);
copy_resource(ctx, p, PDF_NAME_Shading, name);
}
static void
pdf_filter_sc_shade(fz_context *ctx, pdf_processor *proc, const char *name, fz_shade *shade)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_gstate *gstate = gstate_to_update(ctx, p);
fz_strlcpy(gstate->sc.name, name, sizeof gstate->sc.name);
gstate->sc.pat = NULL;
gstate->sc.shd = shade;
gstate->sc.n = 0;
copy_resource(ctx, p, PDF_NAME_Pattern, name);
}
/*
* NB: Destination file must exist.
*/
void *open_settings_w_fsp(FSSpec *dstfile)
{
short tmpVRefNum;
long tmpDirID;
struct write_settings *ws;
OSErr error;
Str255 tmpname;
ws = snew(struct write_settings);
ws->dstfile = *dstfile;
/* Create a temporary file to save to first. */
error = FindFolder(ws->dstfile.vRefNum, kTemporaryFolderType,
kCreateFolder, &tmpVRefNum, &tmpDirID);
if (error != noErr) goto out;
c2pstrcpy(tmpname, tmpnam(NULL));
error = FSMakeFSSpec(tmpVRefNum, tmpDirID, tmpname, &ws->tmpfile);
if (error != noErr && error != fnfErr) goto out;
if (error == noErr) {
error = FSpDelete(&ws->tmpfile);
if (error != noErr) goto out;
}
FSpCreateResFile(&ws->tmpfile, PUTTY_CREATOR, SESS_TYPE, smSystemScript);
if ((error = ResError()) != noErr) goto out;
ws->fd = FSpOpenResFile(&ws->tmpfile, fsWrPerm);
if (ws->fd == -1) {error = ResError(); goto out;}
/* Set up standard resources. Doesn't matter if these fail. */
copy_resource('STR ', -16396);
copy_resource('TMPL', TMPL_Int);
return ws;
out:
safefree(ws);
fatalbox("Failed to open session for write (%d)", error);
}
static void
pdf_filter_sc_pattern(fz_context *ctx, pdf_processor *proc, const char *name, pdf_pattern *pat, int n, float *color)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_gstate *gstate = gstate_to_update(ctx, p);
int i;
fz_strlcpy(gstate->sc.name, name, sizeof gstate->sc.name);
gstate->sc.pat = pat;
gstate->sc.shd = NULL;
gstate->sc.n = n;
for (i = 0; i < n; ++i)
gstate->sc.c[i] = color[i];
copy_resource(ctx, p, PDF_NAME_Pattern, name);
}
/*
move_resource
will decrement usage count of the source resource,
note this will not necessary cause the source resource
to be deleted, only if its usage count reaches zero.
*/
F8RES_API int move_resource(
const f8_uuid * s,
const f8_uuid * t
)
{
int r;
F8_RESOURCE *tr, *sr;
if(query_resource(t) >= 0){
return F8_NAME_DUPLICATE;
}
sr = _get_res(s);
if(!sr){
return F8_OBJECT_NOT_FOUND;
}
if(!create_resource(t)){
return F8_LOW_MEMORY;
}
if(sr->refcount == 1){
/*
a little optimization, if the reference count of source
is 1, then no actual copy is made, instead, we move
the contents of s to t, and detach s from its contents.
*/
tr = _get_res(t);
delete tr->pItems;
tr->pItems = _get_res(s)->pItems;
sr->pItems = 0;
_free_resource(sr);
r = F8_SUCCESS;
}else{
r = copy_resource(s, t);
}
/*
this will decrement the reference count, and remove the
resource entry if necessary
*/
unload_resource(s);
return r;
}
/*
load resource from stream, but in another name.
again, the reference count is not affected.
*/
F8RES_API __bool load_res_stream_as(
IF8Stream * s,
const f8_uuid * newId
)
{
F8_RESOURCE *h;
int ret;
h = _load_res_stream(s);
if(!h){
return __false;
}
ret = copy_resource(&h->id, newId);
if(F8_FAILED(ret)){
return __false;
}
/*
to be compatible with load_res_stream, we
remove a reference count from the one incremented
by copy_resource
*/
h = _get_res(newId);
h->refcount--;
return __true;
}
void jscoverage_instrument(const char * source,
const char * destination,
int verbose,
char ** exclude,
int num_exclude,
char ** no_instrument,
int num_no_instrument)
{
assert(source != NULL);
assert(destination != NULL);
g_verbose = verbose;
/* check if they are the same */
check_same_file(source, destination);
/* check if source directory is an ancestor of destination directory */
check_contains_file(source, destination);
/* check that the source exists and is a directory */
struct stat buf;
xstat(source, &buf);
if (! S_ISDIR(buf.st_mode)) {
fatal("not a directory: %s", source);
}
/* if the destination directory exists, check that it is a jscoverage directory */
if (stat(destination, &buf) == 0) {
/* it exists */
if (! S_ISDIR(buf.st_mode)) {
fatal("not a directory: %s", destination);
}
if (! directory_is_empty(destination)) {
char * expected_file = NULL;
if (jscoverage_mode == JSCOVERAGE_MOZILLA) {
char * modules_directory = make_path(destination, "modules");
expected_file = make_path(modules_directory, "jscoverage.jsm");
free(modules_directory);
}
else {
expected_file = make_path(destination, "jscoverage.html");
}
if (stat(expected_file, &buf) == -1) {
fatal("refusing to overwrite directory: %s", destination);
}
free(expected_file);
}
}
else if (errno == ENOENT) {
xmkdir(destination);
}
else {
fatal("cannot stat directory: %s", destination);
}
/* copy the resources */
if (jscoverage_mode == JSCOVERAGE_MOZILLA) {
char * chrome_directory = make_path(destination, "chrome");
char * jscoverage_chrome_directory = make_path(chrome_directory, "jscoverage");
mkdirs(jscoverage_chrome_directory);
copy_resource("jscoverage.manifest", chrome_directory);
copy_resource("jscoverage.html", jscoverage_chrome_directory);
copy_resource("jscoverage.css", jscoverage_chrome_directory);
copy_resource("jscoverage.js", jscoverage_chrome_directory);
copy_resource("jscoverage-throbber.gif", jscoverage_chrome_directory);
copy_resource("jscoverage-highlight.css", jscoverage_chrome_directory);
copy_resource("jscoverage.xul", jscoverage_chrome_directory);
copy_resource("jscoverage-overlay.js", jscoverage_chrome_directory);
free(jscoverage_chrome_directory);
free(chrome_directory);
char * modules_directory = make_path(destination, "modules");
mkdirs(modules_directory);
copy_resource("jscoverage.jsm", modules_directory);
free(modules_directory);
}
else {
jscoverage_copy_resources(destination);
}
/* finally: copy the directory */
struct DirListEntry * list = make_recursive_dir_list(source);
for (struct DirListEntry * p = list; p != NULL; p = p->next) {
char * s = make_path(source, p->name);
char * d = make_path(destination, p->name);
/* check if it's on the exclude list */
for (int i = 0; i < num_exclude; i++) {
char * x = make_path(source, exclude[i]);
if (is_same_file(x, s) || contains_file(x, s)) {
free(x);
goto cleanup;
}
free(x);
}
char * dd = make_dirname(d);
mkdirs(dd);
free(dd);
int instrument_this = 1;
/* check if it's on the no-instrument list */
for (int i = 0; i < num_no_instrument; i++) {
char * ni = make_path(source, no_instrument[i]);
if (is_same_file(ni, s) || contains_file(ni, s)) {
instrument_this = 0;
}
free(ni);
}
instrument_file(s, d, p->name, instrument_this);
cleanup:
free(s);
free(d);
}
free_dir_list(list);
}
