/*
* Remove unneeded leaves from the old tree.
* Remove directories from the lookup chains.
*/
void
removeoldleaves(void)
{
struct entry *ep;
ino_t i;
Vprintf(stdout, "Mark entries to be removed.\n");
for (i = ROOTINO + 1; i < maxino; i++) {
ep = lookupino(i);
if (ep == NULL)
continue;
if (TSTINO(i, usedinomap))
continue;
for ( ; ep != NULL; ep = ep->e_links) {
Dprintf(stdout, "%s: REMOVE\n", myname(ep));
if (ep->e_type == LEAF) {
removeleaf(ep);
freeentry(ep);
} else {
mktempname(ep);
deleteino(ep->e_ino);
ep->e_next = removelist;
removelist = ep;
}
}
}
}
void gfxdevice_record_init(gfxdevice_t*dev, char use_tempfile)
{
internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
memset(dev, 0, sizeof(gfxdevice_t));
dev->name = "record";
dev->internal = i;
i->use_tempfile = use_tempfile;
if(!use_tempfile) {
writer_init_growingmemwriter(&i->w, 1048576);
} else {
char buffer[128];
i->filename = strdup(mktempname(buffer, "gfx"));
writer_init_filewriter2(&i->w, i->filename);
}
i->fontlist = gfxfontlist_create();
i->cliplevel = 0;
dev->setparameter = record_setparameter;
dev->startpage = record_startpage;
dev->startclip = record_startclip;
dev->endclip = record_endclip;
dev->stroke = record_stroke;
dev->fill = record_fill;
dev->fillbitmap = record_fillbitmap;
dev->fillgradient = record_fillgradient;
dev->addfont = record_addfont;
dev->drawchar = record_drawchar;
dev->drawlink = record_drawlink;
dev->endpage = record_endpage;
dev->finish = record_finish;
}
void pdf_startpage(gfxdevice_t*dev, int width, int height)
{
internal_t*i = (internal_t*)dev->internal;
if(!i->tempfile) {
i->tempfile = strdup(mktempname(0, "pdf"));
PDF_begin_document(i->p, i->tempfile, 0, "");
//PDF_set_value(i->p, "compress", 0);
PDF_set_parameter(i->p, "usercoordinates", "true");
PDF_set_parameter(i->p, "topdown", "true");
}
int width_plus_pad = width+floor(i->config_xpad*2);
int height_plus_pad = height+floor(i->config_ypad*2);
PDF_begin_page_ext(i->p, width_plus_pad, height_plus_pad, i->page_opts);
PDF_set_value(i->p, "CropBox/llx", 0);
PDF_set_value(i->p, "CropBox/lly", 0);
PDF_set_value(i->p, "CropBox/urx", width_plus_pad);
PDF_set_value(i->p, "CropBox/ury", height_plus_pad);
if(i->config_xpad || i->config_ypad) {
PDF_set_value(i->p, "TrimBox/llx", i->config_xpad);
PDF_set_value(i->p, "TrimBox/lly", i->config_ypad);
PDF_set_value(i->p, "TrimBox/urx", i->config_xpad+width);
PDF_set_value(i->p, "TrimBox/ury", i->config_ypad+height);
}
PDF_set_parameter(i->p, "fillrule", "evenodd");
i->width = width;
i->height = height;
i->num_pages++;
reset_matrix(i);
}
static struct ptunit_result sfix_init(struct section_fixture *sfix)
{
sfix->section = NULL;
sfix->file = NULL;
sfix->name = NULL;
sfix->name = mktempname();
ptu_ptr(sfix->name);
sfix->file = fopen(sfix->name, "wb");
ptu_ptr(sfix->file);
ptu_test(ptunit_thrd_init, &sfix->thrd);
return ptu_passed();
}
static int rcbmail(void)
{
int r, hunc, saveout;
static char tmprbname[SSIZE];
strcpy(tmpmask, tmpdir);
strcat(tmpmask, TMPUNZNAME);
mktempname(tmpmask, tmprbname);
sprintf(cmdline, uncompress, "");
hunc=open(tmprbname, O_BINARY|O_RDWR|O_CREAT|O_EXCL, S_IREAD|S_IWRITE);
if (hunc==-1)
{ logwrite('?',"Can't create %s: %s!\n", tmprbname, strerror(errno));
return 1;
}
saveout=dup(fileno(stdout));
dup2(hunc, fileno(stdout));
close(hunc);
debug(4,"rcbmail: run '%s'", cmdline);
if (!quiet)
{ fputs("Uncompressing batchmail-packet...", stderr);
fflush(stderr);
}
r=swap_system(cmdline);
if (!quiet)
fputs("\n", stderr);
if (r)
{ dup2(saveout,fileno(stdout));
close(saveout);
unlink(tmprbname);
logwrite('!', "Uncompress retcode %d\n", r);
return 1;
}
r=dup(fileno(stdin));
rewind(stdout);
dup2(fileno(stdout), fileno(stdin));
dup2(saveout, fileno(stdout));
close(saveout);
saveout=r;
if (!quiet)
fputs("\n", stderr);
r=rbmail();
debug(4, "rbmail retcode %d", r);
dup2(saveout, fileno(stdin));
close(saveout);
unlink(tmprbname);
return r;
}
/*
* Remove invalid whiteouts from the old tree.
* Remove unneeded leaves from the old tree.
* Remove directories from the lookup chains.
*/
void
removeoldleaves(void)
{
struct entry *ep, *nextep;
ino_t i, mydirino;
vprintf(stdout, "Mark entries to be removed.\n");
if ((ep = lookupino(WINO))) {
vprintf(stdout, "Delete whiteouts\n");
for ( ; ep != NULL; ep = nextep) {
nextep = ep->e_links;
mydirino = ep->e_parent->e_ino;
/*
* We remove all whiteouts that are in directories
* that have been removed or that have been dumped.
*/
if (TSTINO(mydirino, usedinomap) &&
!TSTINO(mydirino, dumpmap))
continue;
delwhiteout(ep);
freeentry(ep);
}
}
for (i = ROOTINO + 1; i < maxino; i++) {
ep = lookupino(i);
if (ep == NULL)
continue;
if (TSTINO(i, usedinomap))
continue;
for ( ; ep != NULL; ep = ep->e_links) {
dprintf(stdout, "%s: REMOVE\n", myname(ep));
if (ep->e_type == LEAF) {
removeleaf(ep);
freeentry(ep);
} else {
mktempname(ep);
deleteino(ep->e_ino);
ep->e_next = removelist;
removelist = ep;
}
}
}
}
/*
* For each directory entry on the incremental tape, determine which
* category it falls into as follows:
* KEEP - entries that are to be left alone.
* NEW - new entries to be added.
* EXTRACT - files that must be updated with new contents.
* LINK - new links to be added.
* Renames are done at the same time.
*/
long
nodeupdates(char *name, ino_t ino, int type)
{
struct entry *ep, *np, *ip;
long descend = GOOD;
int lookuptype = 0;
int key = 0;
/* key values */
# define ONTAPE 0x1 /* inode is on the tape */
# define INOFND 0x2 /* inode already exists */
# define NAMEFND 0x4 /* name already exists */
# define MODECHG 0x8 /* mode of inode changed */
/*
* This routine is called once for each element in the
* directory hierarchy, with a full path name.
* The "type" value is incorrectly specified as LEAF for
* directories that are not on the dump tape.
*
* Check to see if the file is on the tape.
*/
if (TSTINO(ino, dumpmap))
key |= ONTAPE;
/*
* Check to see if the name exists, and if the name is a link.
*/
np = lookupname(name);
if (np != NULL) {
key |= NAMEFND;
ip = lookupino(np->e_ino);
if (ip == NULL)
panic("corrupted symbol table\n");
if (ip != np)
lookuptype = LINK;
}
/*
* Check to see if the inode exists, and if one of its links
* corresponds to the name (if one was found).
*/
ip = lookupino(ino);
if (ip != NULL) {
key |= INOFND;
for (ep = ip->e_links; ep != NULL; ep = ep->e_links) {
if (ep == np) {
ip = ep;
break;
}
}
}
/*
* If both a name and an inode are found, but they do not
* correspond to the same file, then both the inode that has
* been found and the inode corresponding to the name that
* has been found need to be renamed. The current pathname
* is the new name for the inode that has been found. Since
* all files to be deleted have already been removed, the
* named file is either a now unneeded link, or it must live
* under a new name in this dump level. If it is a link, it
* can be removed. If it is not a link, it is given a
* temporary name in anticipation that it will be renamed
* when it is later found by inode number.
*/
if (((key & (INOFND|NAMEFND)) == (INOFND|NAMEFND)) && ip != np) {
if (lookuptype == LINK) {
removeleaf(np);
freeentry(np);
} else {
dprintf(stdout, "name/inode conflict, mktempname %s\n",
myname(np));
mktempname(np);
}
np = NULL;
key &= ~NAMEFND;
}
if ((key & ONTAPE) &&
(((key & INOFND) && ip->e_type != type) ||
((key & NAMEFND) && np->e_type != type)))
key |= MODECHG;
/*
* Decide on the disposition of the file based on its flags.
* Note that we have already handled the case in which
* a name and inode are found that correspond to different files.
* Thus if both NAMEFND and INOFND are set then ip == np.
*/
switch (key) {
/*
* A previously existing file has been found.
* Mark it as KEEP so that other links to the inode can be
* detected, and so that it will not be reclaimed by the search
* for unreferenced names.
*/
case INOFND|NAMEFND:
ip->e_flags |= KEEP;
dprintf(stdout, "[%s] %s: %s\n", keyval(key), name,
flagvalues(ip));
break;
/*
* A file on the tape has a name which is the same as a name
* corresponding to a different file in the previous dump.
* Since all files to be deleted have already been removed,
* this file is either a now unneeded link, or it must live
* under a new name in this dump level. If it is a link, it
* can simply be removed. If it is not a link, it is given a
* temporary name in anticipation that it will be renamed
* when it is later found by inode number (see INOFND case
* below). The entry is then treated as a new file.
*/
case ONTAPE|NAMEFND:
case ONTAPE|NAMEFND|MODECHG:
if (lookuptype == LINK) {
removeleaf(np);
freeentry(np);
} else {
mktempname(np);
}
/* FALLTHROUGH */
/*
* A previously non-existent file.
* Add it to the file system, and request its extraction.
* If it is a directory, create it immediately.
* (Since the name is unused there can be no conflict)
*/
case ONTAPE:
ep = addentry(name, ino, type);
if (type == NODE)
newnode(ep);
ep->e_flags |= NEW|KEEP;
dprintf(stdout, "[%s] %s: %s\n", keyval(key), name,
flagvalues(ep));
break;
/*
* A file with the same inode number, but a different
* name has been found. If the other name has not already
* been found (indicated by the KEEP flag, see above) then
* this must be a new name for the file, and it is renamed.
* If the other name has been found then this must be a
* link to the file. Hard links to directories are not
* permitted, and are either deleted or converted to
* symbolic links. Finally, if the file is on the tape,
* a request is made to extract it.
*/
case ONTAPE|INOFND:
if (type == LEAF && (ip->e_flags & KEEP) == 0)
ip->e_flags |= EXTRACT;
/* FALLTHROUGH */
case INOFND:
if ((ip->e_flags & KEEP) == 0) {
renameit(myname(ip), name);
moveentry(ip, name);
ip->e_flags |= KEEP;
dprintf(stdout, "[%s] %s: %s\n", keyval(key), name,
flagvalues(ip));
break;
}
if (ip->e_type == NODE) {
descend = FAIL;
fprintf(stderr,
"deleted hard link %s to directory %s\n",
name, myname(ip));
break;
}
ep = addentry(name, ino, type|LINK);
ep->e_flags |= NEW;
dprintf(stdout, "[%s] %s: %s|LINK\n", keyval(key), name,
flagvalues(ep));
break;
/*
* A previously known file which is to be updated. If it is a link,
* then all names referring to the previous file must be removed
* so that the subset of them that remain can be recreated.
*/
case ONTAPE|INOFND|NAMEFND:
if (lookuptype == LINK) {
removeleaf(np);
freeentry(np);
ep = addentry(name, ino, type|LINK);
if (type == NODE)
newnode(ep);
ep->e_flags |= NEW|KEEP;
dprintf(stdout, "[%s] %s: %s|LINK\n", keyval(key), name,
flagvalues(ep));
break;
}
if (type == LEAF && lookuptype != LINK)
np->e_flags |= EXTRACT;
np->e_flags |= KEEP;
dprintf(stdout, "[%s] %s: %s\n", keyval(key), name,
flagvalues(np));
break;
/*
* An inode is being reused in a completely different way.
* Normally an extract can simply do an "unlink" followed
* by a "creat". Here we must do effectively the same
* thing. The complications arise because we cannot really
* delete a directory since it may still contain files
* that we need to rename, so we delete it from the symbol
* table, and put it on the list to be deleted eventually.
* Conversely if a directory is to be created, it must be
* done immediately, rather than waiting until the
* extraction phase.
*/
case ONTAPE|INOFND|MODECHG:
case ONTAPE|INOFND|NAMEFND|MODECHG:
if (ip->e_flags & KEEP) {
badentry(ip, "cannot KEEP and change modes");
break;
}
if (ip->e_type == LEAF) {
/* changing from leaf to node */
for (ip = lookupino(ino); ip != NULL; ip = ip->e_links) {
if (ip->e_type != LEAF)
badentry(ip, "NODE and LEAF links to same inode");
removeleaf(ip);
freeentry(ip);
}
ip = addentry(name, ino, type);
newnode(ip);
} else {
/* changing from node to leaf */
if ((ip->e_flags & TMPNAME) == 0)
mktempname(ip);
deleteino(ip->e_ino);
ip->e_next = removelist;
removelist = ip;
ip = addentry(name, ino, type);
}
ip->e_flags |= NEW|KEEP;
dprintf(stdout, "[%s] %s: %s\n", keyval(key), name,
flagvalues(ip));
break;
/*
* A hard link to a directory that has been removed.
* Ignore it.
*/
case NAMEFND:
dprintf(stdout, "[%s] %s: Extraneous name\n", keyval(key),
name);
descend = FAIL;
break;
/*
* If we find a directory entry for a file that is not on
* the tape, then we must have found a file that was created
* while the dump was in progress. Since we have no contents
* for it, we discard the name knowing that it will be on the
* next incremental tape.
*/
case 0:
fprintf(stderr, "%s: (inode %ju) not found on tape\n",
name, (uintmax_t)ino);
break;
/*
* If any of these arise, something is grievously wrong with
* the current state of the symbol table.
*/
case INOFND|NAMEFND|MODECHG:
case NAMEFND|MODECHG:
case INOFND|MODECHG:
fprintf(stderr, "[%s] %s: inconsistent state\n", keyval(key),
name);
break;
/*
* These states "cannot" arise for any state of the symbol table.
*/
case ONTAPE|MODECHG:
case MODECHG:
default:
panic("[%s] %s: impossible state\n", keyval(key), name);
break;
}
return (descend);
}
void pdf_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
{
internal_t*i = (internal_t*)dev->internal;
int t,size=img->width*img->height;
int has_alpha=0;
for(t=0;t<size;t++) {
if(img->data[t].a!=255) {
has_alpha=1;
break;
}
}
double w = sqrt(matrix->m00*matrix->m00+matrix->m01*matrix->m01);
double h = sqrt(matrix->m10*matrix->m10+matrix->m11*matrix->m11);
double l1 = w*img->width;
double l2 = h*img->height;
double dpi_x = 72.0 / w;
double dpi_y = 72.0 / h;
double dpi = dpi_x>dpi_y?dpi_x:dpi_y;
gfximage_t*rescaled_image = 0;
if(i->config_maxdpi && dpi > i->config_maxdpi) {
int newwidth = img->width*i->config_maxdpi/dpi;
int newheight = img->height*i->config_maxdpi/dpi;
rescaled_image = gfximage_rescale(img, newwidth, newheight);
msg("<notice> Downscaling %dx%d image (dpi %f, %.0fx%.0f on page) to %dx%d (dpi %d)",
img->width, img->height, dpi, l1, l2, newwidth, newheight, i->config_maxdpi);
img = rescaled_image;
}
if(i->config_mindpi && dpi < i->config_mindpi && img->width>1 && img->height>1) {
msg("<error> Found image of size %dx%d with dpi %f, minimum allowed dpi is %d",
img->width, img->height, dpi, i->config_mindpi);
exit(1);
}
char tempfile[128];
mktempname(tempfile, "jpg");
gfximage_save_jpeg(img, tempfile, 96);
int imgid=-1;
if(has_alpha) {
char tempfile2[128];
mktempname(tempfile2, "jpg");
int t;
int size = img->width*img->height;
unsigned char*alpha = malloc(size);
for(t=0;t<size;t++) {
alpha[t] = img->data[t].a;
}
jpeg_save_gray(alpha, img->width, img->height, 97, tempfile2);
free(alpha);
int maskid = PDF_load_image(i->p, "jpeg", tempfile2, 0, "mask");
unlink(tempfile2);
char masked[80];
if(maskid<0) {
msg("<error> Couldn't process mask jpeg of size %dx%d: error code %d", img->width, img->height, maskid);
return;
}
sprintf(masked, "masked %d", maskid);
imgid = PDF_load_image(i->p, "jpeg", tempfile, 0, masked);
} else {
imgid = PDF_load_image(i->p, "jpeg", tempfile, 0, "");
}
if(imgid<0) {
msg("<error> Couldn't process jpeg of size %dx%d: error code %d, file %s", img->width, img->height, imgid, tempfile);
return;
}
unlink(tempfile);
char options[80];
set_matrix(i, matrix->m00, matrix->m01, matrix->m10, matrix->m11);
/* an image's (0,0) is at the lower left corner */
double x=matrix->tx + i->config_xpad + matrix->m10*img->height;
double y=matrix->ty + i->config_ypad + matrix->m11*img->height;
double tx,ty;
transform_back(i, x, y, &tx, &ty);
PDF_place_image(i->p, imgid, tx, ty, 1.0);
PDF_close_image(i->p, imgid);
if(rescaled_image)
gfximage_free(rescaled_image);
}
int execute( const char *command,
const char *parameters,
const char *input,
const char *output,
const KWBoolean synchronous,
const KWBoolean foreground )
{
int result;
KWBoolean useBat = (input != NULL) || (output != NULL );
char path[COMMAND_TEXT_MAX]; /* String for executable file */
char batchFile[FILENAME_MAX]; /* String for batch driver file */
char perfect[FILENAME_MAX]; /* String for results test file */
/*--------------------------------------------------------------------*/
/* Validate command redirection */
/*--------------------------------------------------------------------*/
if ( ((input != NULL) || (output != NULL)) && ! synchronous )
{
printmsg(0, "execute: Internal error, cannot redirect asynchronous"
" command %s",
command );
panic();
}
/*--------------------------------------------------------------------*/
/* Locate the command */
/*--------------------------------------------------------------------*/
if ( internal( command ) )
{
strcpy( path , command );
useBat = KWTrue;
}
else if (batch( command, path ))
{
if (useBat) /* Using redirection? */
{
printmsg(0,"Cannot use redirection with batch file %s",
path );
return -2;
}
} /* else */
else if ( !*path ) /* Error returned from search? */
return -1; /* Yes --> Error already reported */
/*--------------------------------------------------------------------*/
/* Generate a batch file for redirected DOS programs, if needed */
/*--------------------------------------------------------------------*/
if ( useBat )
{
FILE *stream ;
mktempname( batchFile, "bat");
mktempname( perfect, "tmp");
stream = FOPEN( batchFile, "w", TEXT_MODE );
if ( stream == NULL )
{
printmsg(0,"execute: Cannot generate batch file %s",
batchFile );
printerr( batchFile );
panic();
}
fprintf( stream ,
"@echo off\n%s %s",
path,
parameters == NULL ? "" : parameters );
if ( input != NULL )
fprintf( stream, " < %s", input );
if ( output != NULL )
fprintf( stream, " > %s", output );
fprintf( stream,
"\nif errorlevel 1 erase %s\n",
perfect );
fclose ( stream );
stream = FOPEN( perfect, "w", TEXT_MODE );
if ( stream == NULL )
{
printmsg(0,"Cannot generate test batch file %s", perfect );
printerr( perfect );
panic();
}
fclose( stream );
strcpy( path, batchFile ); /* Run the batch command */
} /* if ( useBat ) */
/*--------------------------------------------------------------------*/
/* Actually run the command */
/*--------------------------------------------------------------------*/
result = SpawnWait( path,
parameters,
synchronous,
foreground ? SW_MAXIMIZE : SW_SHOWMINNOACTIVE );
/*--------------------------------------------------------------------*/
/* For batch files, we can only report zero/non-zero */
/* results. Do so, and clean up our input file at the same */
/* time. */
/*--------------------------------------------------------------------*/
if ( useBat )
{
int unlinkResult = REMOVE( perfect );
if (( result == 0 ) && (unlinkResult != 0))
result = 255;
if (REMOVE( batchFile ))
{
printmsg(0,"Cannot delete batch file %s", batchFile );
printerr( batchFile );
}
} /* if ( useBat ) */
/*--------------------------------------------------------------------*/
/* Report results of command */
/*--------------------------------------------------------------------*/
printmsg( 4,"Result of spawn %s is ... %d", command, result);
return result;
} /* execute */
static int rbmail(void)
{
int hrmail, savein, r;
long len;
unsigned short crc, mycrc;
static char addrlist[1026];
char *p;
strcpy(tmpmask, tmpdir);
strcat(tmpmask, TMPUNZNAME);
debug(6, "rbmail started");
while (fgets(str, sizeof(str), stdin))
{
p=strchr(str, '\n');
if (p==NULL)
{ logwrite('!', "Bad rbmail-packet (line too long)!\n");
return 1;
}
*p='\0';
debug(18, "rbmail: readed control line \"%s\"\n");
if (sscanf(str, "%ld %hx %s", &len, &crc, addrlist)!=3)
{ logwrite('!', "Bad rbmail-packet (incorrect line format)!\n");
return 1;
}
mktempname(tmpmask, tmpname);
hrmail=open(tmpname, O_BINARY|O_RDWR|O_CREAT|O_EXCL, S_IREAD|S_IWRITE);
if (hrmail==-1)
{ logwrite('?',"Can't create %s: %s!\n", tmpname, strerror(errno));
return 1;
}
mycrc=0;
while (len)
{ int i=sizeof(str);
if (i>len) i=(int)len;
if (fread(str, i, 1, stdin)!=1)
{ close(hrmail);
unlink(tmpname);
logwrite('!', "Bad rbmail-packet (no message data)!\n");
return 1;
}
if (write(hrmail, str, i)!=i)
{ logwrite('?', "Can't write to file: %s!\n", strerror(errno));
close(hrmail);
unlink(tmpname);
return 1;
}
len-=i;
for (p=str; p-str<i; p++)
mycrc=updatecrc(*p, mycrc);
}
if (mycrc!=crc)
{ logwrite('?', "rbmail crc error: %04x!=%04x\n", mycrc, crc);
close(hrmail);
unlink(tmpname);
return 1;
}
savein=dup(fileno(stdin));
lseek(hrmail, 0, SEEK_SET);
dup2(hrmail, fileno(stdin));
close(hrmail);
r=rmailfunc(addrlist);
dup2(savein, fileno(stdin));
close(savein);
unlink(tmpname);
if (r) return r;
}
debug(6, "rbmail ok");
return 0;
}
IMFILE *imopen(const long length,
const char *mode)
{
IMFILE *imf = malloc(sizeof (IMFILE));
/*--------------------------------------------------------------------*/
/* Allocate our control structure and initialize it */
/*--------------------------------------------------------------------*/
checkref(imf);
memset(imf, 0, sizeof *imf);
/*--------------------------------------------------------------------*/
/* Determine if the file is image (binary) or text */
/*--------------------------------------------------------------------*/
if (equal(mode, TEXT_MODE))
imf->flag |= IM_FLAG_TEXT;
/*--------------------------------------------------------------------*/
/* Grab an imf buffer unless IM files are disabled, the file */
/* is too large, or we cannot allocate the buffer. */
/*--------------------------------------------------------------------*/
if (bflag[F_IMFILE] && (length <= IM_MAX_LENGTH))
{
if (length <= 0)
imf->length = IM_MAX_LENGTH / 10;
else
imf->length = (unsigned long) length;
imf->buffer = MALLOC((size_t) imf->length);
if (imf->buffer == NULL)
printerr("malloc");
} /* if (length <= IM_MAX_LENGTH) */
else
printmsg(2,"imopen: Using disk for %ld byte file (max i-m is %ld)",
length,
(long) IM_MAX_LENGTH);
/*--------------------------------------------------------------------*/
/* Open a real file if we don't have a buffer for whatever reason */
/*--------------------------------------------------------------------*/
if (imf->buffer == NULL)
{
imf->filename = mktempname(NULL, "TMP");
if (imf->flag & IM_FLAG_TEXT)
imf->stream = FOPEN(imf->filename,
"w+",
TEXT_MODE);
else
imf->stream = FOPEN(imf->filename,
"w+",
IMAGE_MODE);
if (imf->stream == NULL)
{
imclose(imf);
return NULL;
} /* if (imf->stream == NULL) */
} /* if (imf->buffer == NULL) */
/*--------------------------------------------------------------------*/
/* Return success to the caller */
/*--------------------------------------------------------------------*/
imStatus(imf);
return imf;
} /* imopen */
static int imReserve(IMFILE *imf, const unsigned long length)
{
unsigned long newLength = length + imf->position ;
/*--------------------------------------------------------------------*/
/* If we have the memory allocated, return quietly */
/*--------------------------------------------------------------------*/
if ((imf->buffer == NULL) || (newLength <= imf->length))
return 0;
/*--------------------------------------------------------------------*/
/* Attempt to allocate the longer buffer needed */
/*--------------------------------------------------------------------*/
if (newLength <= IM_MAX_LENGTH)
{
char UUFAR *newBuffer;
newLength += newLength; /* Add a 100 percent pad */
if (newLength > IM_MAX_LENGTH) /* Is the pad allowed? */
newLength = IM_MAX_LENGTH; /* No --> Just use max */
newBuffer = REALLOC(imf->buffer, (size_t) newLength);
if (newBuffer == NULL)
{
printerr("realloc");
imf->flag |= IM_FLAG_ERROR;
return -1;
}
else {
imf->length = newLength;
imf->buffer = newBuffer;
return 0;
}
} /* if (newLength <= IM_MAX_LENGTH) */
/*--------------------------------------------------------------------*/
/* For wharever reason, we need to convert processing to a */
/* file; do so. */
/*--------------------------------------------------------------------*/
imf->filename = mktempname(NULL, "TMP");
printmsg(2,"imReserve: Switching to disk file %s after %ld/%ld bytes",
imf->filename,
imf->inUse,
newLength);
if (imf->flag & IM_FLAG_TEXT)
{
/* We can't translate the position on non-binary files */
if (imf->flag & IM_FLAG_TELL)
{
printmsg(0,"imReserve: Internal error, imtell() issued on TEXT file");
panic();
}
imf->stream = FOPEN(imf->filename,
"w+",
TEXT_MODE);
}
else
imf->stream = FOPEN(imf->filename,
"w+",
IMAGE_MODE);
if (imf->stream == NULL)
{
printerr(imf->filename);
imf->flag |= IM_FLAG_ERROR;
return -1;
}
imrewind(imf);
if (imunload(imf->stream, imf))
{
printerr(imf->filename);
imf->flag |= IM_FLAG_ERROR;
return -1;
}
/*--------------------------------------------------------------------*/
/* Drop the old buffer and set pointer to NULL so routines */
/* know what sort of I/O to perform. */
/*--------------------------------------------------------------------*/
FREE(imf->buffer);
imf->buffer = NULL;
imf->length = imf->inUse = imf->position = 0;
return 0;
} /* imReserve */
int executeIMFCommand(const char *command,
IMFILE *imf,
const char *output,
const KWBoolean synchronous,
const KWBoolean foreground)
{
char tempName[ FILENAME_MAX ];
FILE *stream;
int status;
/*--------------------------------------------------------------------*/
/* If we are using a disk based work file, we close the file */
/* (to prevent sharing errors) and then pass the file name */
/* directly into executeCommand. */
/* */
/* Note that we reopen the file, we open for append to avoid */
/* clobbering the contents. Since the open should _never_ */
/* fail, we halt if it does. */
/*--------------------------------------------------------------------*/
if (imf->buffer == NULL)
{
int result;
fclose(imf->stream);
result = executeCommand(command,
imf->filename,
output,
synchronous,
foreground);
if (imf->flag & IM_FLAG_TEXT)
imf->stream = FOPEN(imf->filename,
"a+",
TEXT_MODE);
else
imf->stream = FOPEN(imf->filename,
"a+",
IMAGE_MODE);
if (imf->stream == NULL)
{
perror(imf->filename);
panic();
}
return result;
} /* if (imf->buffer == NULL) */
/*--------------------------------------------------------------------*/
/* The data is in memory, we need to write it out an */
/* external program to see it. */
/*--------------------------------------------------------------------*/
mktempname(tempName, "TMP");
stream = FOPEN(tempName,
"w+",
TEXT_MODE);
if (stream == NULL)
{
printerr(tempName);
return -1;
}
if (imunload(stream, imf))
{
printerr(tempName);
return -1;
}
fclose(stream);
status = executeCommand(command,
tempName,
output,
synchronous,
foreground);
REMOVE(tempName);
return status;
} /* executeIMFCommand */
