/*
* -----------------------------------------------------------------
* cfsd_fscache_destroy
*
* Description:
* Arguments:
* Returns:
* Preconditions:
*/
void
cfsd_fscache_destroy(cfsd_fscache_object_t *fscache_object_p)
{
int xx;
dbug_enter("cfsd_fscache_destroy");
dbug_precond(fscache_object_p);
/* dbug_assert(fscache_object_p->i_refcnt == 0); */
/* close down the message file descriptor */
if (fscache_object_p->i_ofd >= 0) {
if (close(fscache_object_p->i_ofd))
dbug_print(("error", "cannot close fscache fd error %d",
errno));
fscache_object_p->i_ofd = -1;
}
/* destroy the locking mutex */
xx = mutex_destroy(&fscache_object_p->i_lock);
dbug_assert(xx == 0);
/* destroy the conditional variable */
xx = cond_destroy(&fscache_object_p->i_cvwait);
dbug_assert(xx == 0);
cfsd_free(fscache_object_p);
dbug_leave("cfsd_fscache_destroy");
}
/*
* fscache_fsproblem
*
* Description:
* Arguments:
* kmodp
* Returns:
* Preconditions:
* precond(kmodp)
*/
void
fscache_fsproblem(cfsd_fscache_object_t *fscache_object_p,
cfsd_kmod_object_t *kmod_object_p)
{
#if 0
int xx;
#endif
dbug_enter("fscache_fsproblem");
dbug_precond(fscache_object_p);
dbug_precond(kmod_object_p);
#if 0
/* first try to put all modified files in lost+found */
xx = kmod_lostfoundall(kmod_object_p);
if (xx) {
/* if that failed, put file system in read-only mode */
kmod_rofs(kmod_object_p);
#endif
fscache_lock(fscache_object_p);
fscache_object_p->i_disconnectable = 0;
fscache_object_p->i_modify++;
fscache_unlock(fscache_object_p);
#if 0
}
#endif
dbug_leave("fscache_fsproblem");
}
/*
* logfile_dumpstats
*
* Description:
* Prints out various stats about the hashing.
* Arguments:
* Returns:
* Preconditions:
*/
void
logfile_dumpstats(cfsd_logfile_object_t *logfile_object_p)
{
int xx;
double dd;
dbug_enter("logfile_dumpstats");
dbug_print(("dump", "Request - next %d",
logfile_object_p->i_stat_nextcnt));
dbug_print(("dump", "Request - offset %d",
logfile_object_p->i_stat_offcnt));
dbug_print(("dump", "Map Moves %d", logfile_object_p->i_stat_mapmove));
dbug_print(("dump", "Mapping Size %d", logfile_object_p->i_maplen));
dbug_print(("dump", "Item Size %d", logfile_object_p->i_maxmap));
dbug_print(("dump", "File Size %d", logfile_object_p->i_size));
if (logfile_object_p->i_stat_mapmove == 0) {
dbug_leave("logfile_dumpstats");
return;
}
dd = (double)logfile_object_p->i_stat_mapmove /
(logfile_object_p->i_stat_nextcnt +
logfile_object_p->i_stat_offcnt);
dbug_print(("dump", "Mmap moves per Request %.2f", dd));
xx = logfile_object_p->i_stat_mapdist /
logfile_object_p->i_stat_mapmove;
dbug_print(("dump", "Average distance per mmap moves %d", xx));
dbug_leave("logfile_dumpstats");
}
static void
rdbuf_bop(PLStream *pls)
{
dbug_enter("rdbuf_bop");
pls->nplwin = 0;
}
void
plD_bop_plm(PLStream *pls)
{
PLmDev *dev = (PLmDev *) pls->dev;
int isfile = (pls->output_type == 0);
FPOS_T pp_offset = dev->lp_offset;;
dbug_enter("plD_bop_plm");
dev->xold = PL_UNDEFINED;
dev->yold = PL_UNDEFINED;
/* Update previous page header */
if (isfile)
UpdatePrevPagehdr(pls);
/* Start next family file if necessary. */
pls->bytecnt = pls->pdfs->bp;
plGetFam(pls);
/* Update page counter */
pls->page++;
/* Update table of contents info & write new page header. */
WritePageInfo(pls, pp_offset);
}
void
plio_fgets( char *buf, int size, FILE *stream )
{
char *s;
dbug_enter( "plio_fgets" );
// If the buffer has a size of zero, we should complain
if ( size == 0 )
{
plwarn( "Zero length buffer size in plio_fgets, returning" );
return;
}
// Clear the error flag for this steam
clearerr( stream );
s = fgets( buf, size, stream );
if ( s == NULL && ferror( stream ) )
{
// The read resulted in an error
plabort( "Error reading from file" );
}
}
/*
* logfile_getaddr
*
* Description:
* Returns an address of a particular offset in the file.
* The size of the item to map is i_maxmap
* This routine assumes that if we have to remap that i_maxmap
* will fit inside the default mapping size.
* Arguments:
* start offset in the file to map
* map 0 means use map_entry, 1 means use map_offset
* Returns:
* Returns NULL for a failure with the mapping file.
* Preconditions:
*/
caddr_t
logfile_getaddr(cfsd_logfile_object_t *logfile_object_p, off_t start, int map)
{
mmap_info_t *mmp;
caddr_t pa;
off_t end;
dbug_enter("logfile_getaddr");
mmp = (map == 0) ?
&logfile_object_p->i_map_entry :
&logfile_object_p->i_map_offset;
/* determine the end of the item */
end = start + logfile_object_p->i_maxmap - 1;
/* map the entry in if necessary */
if ((start < mmp->i_paoff) || (mmp->i_paend < end)) {
if (logfile_domap(logfile_object_p,
start & logfile_object_p->i_pagemask, map)) {
dbug_leave("logfile_getaddr");
return (NULL);
}
dbug_assert((mmp->i_paoff <= start) && (end <= mmp->i_paend));
}
/* make an address and return it */
pa = mmp->i_pa + (start - mmp->i_paoff);
dbug_leave("logfile_getaddr");
return (pa);
}
void
plio_fread( void *buf, size_t size, size_t nmemb, FILE *stream )
{
size_t bytes;
dbug_enter( "plio_fread" );
// If the buffer has a size of zero, we should complain
if ( size == 0 || nmemb == 0 )
{
plwarn( "Zero length buffer size in plio_fread, returning" );
return;
}
// Clear the error flag for this steam
clearerr( stream );
bytes = fread( buf, size, nmemb, stream );
if ( ( bytes < nmemb ) && ferror( stream ) )
{
// The read resulted in an error
plabort( "Error reading from file" );
}
}
/*
* ------------------------------------------------------------
* cfsd_all_destroy
*
* Description:
* Arguments:
* Returns:
* Preconditions:
*/
void
cfsd_all_destroy(cfsd_all_object_t *all_object_p)
{
cfsd_cache_object_t *cache_object_p;
cfsd_cache_object_t *tmp_cache_object_p;
int xx;
dbug_enter("cfsd_all_destroy");
/* dbug_assert(all_object_p->i_hoardp == NULL); */
/* get rid of any cache objects */
cache_object_p = all_object_p->i_cachelist;
while (cache_object_p != NULL) {
tmp_cache_object_p = cache_object_p->i_next;
cfsd_cache_destroy(cache_object_p);
cache_object_p = tmp_cache_object_p;
}
/* destroy the locking mutex */
xx = mutex_destroy(&all_object_p->i_lock);
dbug_assert(xx == 0);
cfsd_free(all_object_p);
dbug_leave("cfsd_all_destroy");
}
/*
* ------------------------------------------------------------
* all_cachefstab_update
*
* Description:
* Arguments:
* Returns:
* Preconditions:
*/
void
all_cachefstab_update(cfsd_all_object_t *all_object_p)
{
cfsd_cache_object_t *cache_object_p;
FILE *fout;
dbug_enter("all_cachefstab_update");
fout = fopen(CACHEFSTAB, "w");
if (fout == NULL) {
dbug_print(("error", "cannot write %s", CACHEFSTAB));
} else {
cache_object_p = all_object_p->i_cachelist;
while (cache_object_p != NULL) {
dbug_assert(cache_object_p);
fprintf(fout, "%s\n", cache_object_p->i_cachedir);
cache_object_p = cache_object_p->i_next;
}
if (fclose(fout))
dbug_print(("error", "cannot close %s error %d",
CACHEFSTAB, errno));
}
dbug_leave("all_cachefstab_update");
}
/*
* ------------------------------------------------------------
* all_unlock
*
* Description:
* Arguments:
* Returns:
* Preconditions:
*/
void
all_unlock(cfsd_all_object_t *all_object_p)
{
dbug_enter("all_unlock");
mutex_unlock(&all_object_p->i_lock);
dbug_leave("all_unlock");
}
/*
* fscache_changes
*
* Description:
* Used to specify whether or not there are changes to roll to the
* server.
* Arguments:
* tt
* Returns:
* Preconditions:
*/
void
fscache_changes(cfsd_fscache_object_t *fscache_object_p, int tt)
{
dbug_enter("fscache_changes");
dbug_precond(fscache_object_p);
fscache_object_p->i_changes = tt;
fscache_object_p->i_modify++;
dbug_leave("fscache_changes");
}
/*
* cfsd_logfile_destroy
*
* Description:
* Arguments:
* Returns:
* Preconditions:
*/
void
cfsd_logfile_destroy(cfsd_logfile_object_t *logfile_object_p)
{
dbug_enter("cfsd_logfile_destroy");
logfile_sync(logfile_object_p);
logfile_teardown(logfile_object_p);
cfsd_free(logfile_object_p);
dbug_leave("cfsd_logfile_destroy");
}
/*
* -----------------------------------------------------------------
* fscache_unlock
*
* Description:
* Arguments:
* Returns:
* Preconditions:
*/
void
fscache_unlock(cfsd_fscache_object_t *fscache_object_p)
{
dbug_enter("fscache_unlock");
dbug_precond(fscache_object_p);
mutex_unlock(&fscache_object_p->i_lock);
dbug_leave("fscache_unlock");
}
void
plD_init_plm(PLStream *pls)
{
PLmDev *dev;
U_CHAR c = (U_CHAR) INITIALIZE;
dbug_enter("plD_init_plm");
pls->color = 1; /* Is a color device */
pls->dev_fill0 = 1; /* Handle solid fills */
pls->dev_fill1 = 1; /* Handle pattern fills */
/* Initialize family file info */
plFamInit(pls);
/* Prompt for a file name if not already set */
plOpenFile(pls);
pls->pdfs = pdf_finit(pls->OutFile);
/* Allocate and initialize device-specific data */
pls->dev = calloc(1, (size_t) sizeof(PLmDev));
if (pls->dev == NULL)
plexit("plD_init_plm: Out of memory.");
dev = (PLmDev *) pls->dev;
dev->xold = PL_UNDEFINED;
dev->yold = PL_UNDEFINED;
dev->xmin = 0;
dev->xmax = PIXELS_X - 1;
dev->ymin = 0;
dev->ymax = PIXELS_Y - 1;
dev->pxlx = (double) PIXELS_X / (double) LPAGE_X;
dev->pxly = (double) PIXELS_Y / (double) LPAGE_Y;
plP_setpxl(dev->pxlx, dev->pxly);
plP_setphy(dev->xmin, dev->xmax, dev->ymin, dev->ymax);
/* Write Metafile header. */
WriteFileHeader(pls);
/* Write color map state info */
plD_state_plm(pls, PLSTATE_CMAP0);
plD_state_plm(pls, PLSTATE_CMAP1);
/* Write initialization command. */
DEBUG_PRINT_LOCATION("before init");
plm_wr( pdf_wr_1byte(pls->pdfs, c) );
}
static void
plbuf_fill(PLStream *pls)
{
dbug_enter("plbuf_fill");
fwrite(&pls->dev_npts, sizeof(PLINT), 1, pls->plbufFile);
fwrite(pls->dev_x, sizeof(short), pls->dev_npts, pls->plbufFile);
fwrite(pls->dev_y, sizeof(short), pls->dev_npts, pls->plbufFile);
}
void
plbuf_init(PLStream *pls)
{
dbug_enter("plbuf_init");
pls->plbuf_read = FALSE;
if (pls->plbufFile != NULL)
pls->plbuf_write = FALSE;
}
/*
* logfile_domap
*
* Description:
* Maps in the specified section of the file.
* Arguments:
* off The offset to map in. Must be i_pagesize aligned.
* map 0 means use map_entry, 1 means use map_offset
* Returns:
* Returns 0 for success or an errno value on failure.
* Preconditions:
*/
int
logfile_domap(cfsd_logfile_object_t *logfile_object_p, off_t off, int map)
{
int xx;
int len;
mmap_info_t *mmp;
dbug_enter("logfile_domap");
dbug_precond(logfile_object_p->i_fid >= 0);
len = logfile_object_p->i_maplen;
mmp = (map == 0) ?
&logfile_object_p->i_map_entry :
&logfile_object_p->i_map_offset;
logfile_object_p->i_stat_mapmove++;
/* destroy old mapping if it exists */
if (mmp->i_pa) {
/* determine how far we have to move the map */
logfile_object_p->i_stat_mapdist += abs(mmp->i_paoff - off);
/* remove the map */
xx = munmap(mmp->i_pa, mmp->i_palen);
if (xx == -1) {
xx = errno;
dbug_print(("error", "Could not unmap %s, %d, %p, %d",
logfile_object_p->i_name, xx, mmp->i_pa,
mmp->i_palen));
}
mmp->i_pa = NULL;
mmp->i_palen = 0;
mmp->i_paoff = 0;
mmp->i_paend = 0;
}
/* do the mapping */
mmp->i_pa = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED,
logfile_object_p->i_fid, off);
if (mmp->i_pa == MAP_FAILED) {
xx = errno;
dbug_print(("error",
"Could not map %s, error %d, off %d, len %d",
logfile_object_p->i_name, xx, off, len));
mmp->i_pa = NULL;
dbug_leave("logfile_domap");
return (xx);
}
mmp->i_palen = len;
mmp->i_paoff = off;
mmp->i_paend = off + len - 1;
dbug_leave("logfile_domap");
return (0);
}
/*
* logfile_entry
*
* Description:
* Sets addrp to the address of the log entry at offset
* The mapping remains in effect until:
* a) this routine is called again
* b) logfile_teardown is called
* c) this object is destroyed
* Arguments:
* offset offset to start of entry
* entpp place to store address
* Returns:
* Returns 0 for success, 1 for EOF, -1 if a fatal error occurs.
* Preconditions:
* precond(addrp)
*/
int
logfile_entry(cfsd_logfile_object_t *logfile_object_p,
off_t offset,
cfs_dlog_entry_t **entpp)
{
cfs_dlog_entry_t *entp;
dbug_enter("logfile_entry");
dbug_precond(entpp);
dbug_precond(offset >= sizeof (long));
logfile_object_p->i_stat_nextcnt++;
/* check for eof */
if (offset >= logfile_object_p->i_size) {
dbug_leave("logfile_entry");
return (1);
}
dbug_assert((offset & 3) == 0);
/* get the address of the entry */
entp = (cfs_dlog_entry_t *)logfile_getaddr(logfile_object_p, offset, 0);
if (entp == NULL) {
dbug_leave("logfile_entry");
return (-1);
}
/* sanity check, record should be alligned */
if (entp->dl_len & 3) {
dbug_print(("error",
"Record at offset %d length is not alligned %d",
offset, entp->dl_len));
dbug_leave("logfile_entry");
return (-1);
}
/* sanity check record should a reasonable size */
if ((entp->dl_len < CFS_DLOG_ENTRY_MINSIZE) ||
(entp->dl_len > CFS_DLOG_ENTRY_MAXSIZE)) {
dbug_print(("error",
"Record at offset %d has an invalid size %d", offset,
entp->dl_len));
dbug_leave("logfile_entry");
return (-1);
}
/* preserve offset and pointer */
logfile_object_p->i_cur_offset = offset;
logfile_object_p->i_cur_entry = entp;
/* return success */
*entpp = entp;
dbug_leave("logfile_entry");
return (0);
}
void
plD_tidy_plm(PLStream *pls)
{
U_CHAR c = (U_CHAR) CLOSE;
dbug_enter("plD_tidy_plm");
plm_wr( pdf_wr_1byte(pls->pdfs, c) );
pdf_close(pls->pdfs);
free_mem(pls->dev);
}
void
plD_state_plm(PLStream *pls, PLINT op)
{
U_CHAR c = (U_CHAR) CHANGE_STATE;
int i;
dbug_enter("plD_state_plm");
plm_wr( pdf_wr_1byte(pls->pdfs, c) );
plm_wr( pdf_wr_1byte(pls->pdfs, op) );
switch (op) {
case PLSTATE_WIDTH:
plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) (pls->width)) );
break;
case PLSTATE_COLOR0:
plm_wr( pdf_wr_2bytes(pls->pdfs, (short) pls->icol0) );
if (pls->icol0 == PL_RGB_COLOR) {
plm_wr( pdf_wr_1byte(pls->pdfs, pls->curcolor.r) );
plm_wr( pdf_wr_1byte(pls->pdfs, pls->curcolor.g) );
plm_wr( pdf_wr_1byte(pls->pdfs, pls->curcolor.b) );
}
break;
case PLSTATE_COLOR1:
plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->icol1) );
break;
case PLSTATE_FILL:
plm_wr( pdf_wr_1byte(pls->pdfs, (U_CHAR) pls->patt) );
break;
case PLSTATE_CMAP0:
plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->ncol0) );
for (i = 0; i < pls->ncol0; i++) {
plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap0[i].r) );
plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap0[i].g) );
plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap0[i].b) );
}
break;
case PLSTATE_CMAP1:
plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->ncol1) );
for (i = 0; i < pls->ncol1; i++) {
plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap1[i].r) );
plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap1[i].g) );
plm_wr( pdf_wr_1byte(pls->pdfs, pls->cmap1[i].b) );
}
break;
}
}
void
plbuf_polyline(PLStream *pls, short *xa, short *ya, PLINT npts)
{
dbug_enter("plbuf_polyline");
wr_command(pls, (U_CHAR) POLYLINE);
fwrite(&npts, sizeof(PLINT), 1, pls->plbufFile);
fwrite(xa, sizeof(short), npts, pls->plbufFile);
fwrite(ya, sizeof(short), npts, pls->plbufFile);
}
void
plbuf_tidy(PLStream *pls)
{
dbug_enter("plbuf_tidy");
if (pls->plbufFile == NULL)
return;
fclose(pls->plbufFile);
pls->plbufFile = NULL;
}
static void
rdbuf_line(PLStream *pls)
{
short xpl[2], ypl[2];
PLINT npts = 2;
dbug_enter("rdbuf_line");
fread(xpl, sizeof(short), npts, pls->plbufFile);
fread(ypl, sizeof(short), npts, pls->plbufFile);
plP_line(xpl, ypl);
}
/*
* ------------------------------------------------------------
* all_cachelist_add
*
* Description:
* Arguments:
* cachep
* Returns:
* Preconditions:
* precond(cachep)
*/
void
all_cachelist_add(cfsd_all_object_t *all_object_p,
cfsd_cache_object_t *cache_object_p)
{
dbug_enter("all_cachelist_add");
dbug_precond(cache_object_p);
cache_object_p->i_next = all_object_p->i_cachelist;
all_object_p->i_cachelist = cache_object_p;
all_object_p->i_modify++;
all_object_p->i_cachecount++;
dbug_leave("all_cachelist_add");
}
static void
rdbuf_fill(PLStream *pls)
{
short xpl[PL_MAXPOLY], ypl[PL_MAXPOLY];
PLINT npts;
dbug_enter("rdbuf_fill");
fread(&npts, sizeof(PLINT), 1, pls->plbufFile);
fread(xpl, sizeof(short), npts, pls->plbufFile);
fread(ypl, sizeof(short), npts, pls->plbufFile);
plP_fill(xpl, ypl, npts);
}
/*
* logfile_teardown
*
* Description:
* Uninitializes the object.
* Call logfile_setup before using this object again.
* Arguments:
* Returns:
* Preconditions:
*/
void
logfile_teardown(cfsd_logfile_object_t *logfile_object_p)
{
int xx;
dbug_enter("logfile_teardown");
if (logfile_object_p->i_map_entry.i_pa) {
xx = munmap(logfile_object_p->i_map_entry.i_pa,
logfile_object_p->i_map_entry.i_palen);
if (xx == -1) {
xx = errno;
dbug_print(("error", "Could not unmap %s, %d, %p, %d",
logfile_object_p->i_name, xx,
logfile_object_p->i_map_entry.i_pa,
logfile_object_p->i_map_entry.i_palen));
}
logfile_object_p->i_map_entry.i_pa = NULL;
}
logfile_object_p->i_map_entry.i_paoff = 0;
logfile_object_p->i_map_entry.i_paend = 0;
logfile_object_p->i_map_entry.i_palen = 0;
if (logfile_object_p->i_map_offset.i_pa) {
xx = munmap(logfile_object_p->i_map_offset.i_pa,
logfile_object_p->i_map_offset.i_palen);
if (xx == -1) {
xx = errno;
dbug_print(("error", "Could not unmap %s, %d, %p, %d",
logfile_object_p->i_name, xx,
logfile_object_p->i_map_offset.i_pa,
logfile_object_p->i_map_offset.i_palen));
}
logfile_object_p->i_map_offset.i_pa = NULL;
}
logfile_object_p->i_map_offset.i_paoff = 0;
logfile_object_p->i_map_offset.i_paend = 0;
logfile_object_p->i_map_offset.i_palen = 0;
if (logfile_object_p->i_fid != -1) {
if (close(logfile_object_p->i_fid))
dbug_print(("error", "Could not close %s, %d",
logfile_object_p->i_name, errno));
logfile_object_p->i_fid = -1;
}
logfile_object_p->i_cur_offset = 0;
logfile_object_p->i_cur_entry = NULL;
dbug_leave("logfile_teardown");
}
void
plbuf_bop(PLStream *pls)
{
dbug_enter("plbuf_bop");
plbuf_tidy(pls);
pls->plbufFile = tmpfile();
if (pls->plbufFile == NULL)
plexit("plbuf_init: Error opening plot data storage file.");
wr_command(pls, (U_CHAR) BOP);
plbuf_state(pls, PLSTATE_COLOR0);
plbuf_state(pls, PLSTATE_WIDTH);
}
static void
plm_fill(PLStream *pls)
{
PLmDev *dev = (PLmDev *) pls->dev;
dbug_enter("plm_fill");
plm_wr( pdf_wr_2bytes(pls->pdfs, (U_SHORT) pls->dev_npts) );
plm_wr( pdf_wr_2nbytes(pls->pdfs, (U_SHORT *) pls->dev_x, pls->dev_npts) );
plm_wr( pdf_wr_2nbytes(pls->pdfs, (U_SHORT *) pls->dev_y, pls->dev_npts) );
dev->xold = PL_UNDEFINED;
dev->yold = PL_UNDEFINED;
}
void
plbuf_state(PLStream *pls, PLINT op)
{
dbug_enter("plbuf_state");
wr_command(pls, (U_CHAR) CHANGE_STATE);
wr_command(pls, (U_CHAR) op);
switch (op) {
case PLSTATE_WIDTH: {
U_CHAR width = pls->width;
fwrite(&width, sizeof(U_CHAR), 1, pls->plbufFile);
break;
}
case PLSTATE_COLOR0: {
U_CHAR icol0 = pls->icol0;
U_CHAR r = pls->curcolor.r;
U_CHAR g = pls->curcolor.g;
U_CHAR b = pls->curcolor.b;
fwrite(&icol0, sizeof(U_CHAR), 1, pls->plbufFile);
if (icol0 == PL_RGB_COLOR) {
fwrite(&r, sizeof(U_CHAR), 1, pls->plbufFile);
fwrite(&g, sizeof(U_CHAR), 1, pls->plbufFile);
fwrite(&b, sizeof(U_CHAR), 1, pls->plbufFile);
}
break;
}
case PLSTATE_COLOR1: {
U_CHAR icol1 = pls->icol1;
fwrite(&icol1, sizeof(U_CHAR), 1, pls->plbufFile);
break;
}
case PLSTATE_FILL:{
signed char patt = pls->patt;
fwrite(&patt, sizeof(signed char), 1, pls->plbufFile);
break;
}
}
}
