Aren/kolibrios
1
0
Fork 0
mirror of https://github.com/KolibriOS/kolibrios.git synced 2024-12-02 21:37:34 +03:00
Code Issues Packages Projects Releases Wiki Activity
672bbcf6a0
kolibrios/programs/fs/unzip60/tandem/tandem.c
siemargl e9b1c1bac6 unzip initial commit 
git-svn-id: svn://kolibrios.org@6725 a494cfbc-eb01-0410-851d-a64ba20cac60
2016-11-18 13:40:05 +00:00

890 lines
24 KiB
C
Raw Blame History

/*
Copyright (c) 1990-2002 Info-ZIP. All rights reserved.
See the accompanying file LICENSE, version 2000-Apr-09 or later
(the contents of which are also included in zip.h) for terms of use.
If, for some reason, all these files are missing, the Info-ZIP license
also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
*/
/*
* routines common to TANDEM (ZIP and UNZIP)
*/
#include "zip.h" /* This sets up ZIP / UNZIP define */
#include <tal.h>
#include "$system.zsysdefs.zsysc" nolist
#include <cextdecs> nolist
#include "tannsk.h"
static time_t gmt_to_time_t (long long *);
int isatty (fnum)
int fnum;
{
return 1;
}
/********************/
/* Function in2ex() */
/********************/
#ifdef UNZIP
char *in2ex(__G__ n)
__GDEF
#else
char *in2ex(n)
#endif
char *n; /* internal file name */
/* Convert the zip file name to an external file name, returning the malloc'ed
string or NULL if not enough memory. */
{
char *x; /* external file name buffer */
char *y; /* pointer to external buffer */
char *max; /* pointer to max end of next file part */
char *t; /* pointer to internal - start of substring */
char *p; /* pointer to internal - TANDEM delimiter */
char *e; /* pointer to internal - DOS extension delimiter */
char *z; /* pointer to internal - end of substring */
int len; /* length of substring to copy to external name */
int allow_dollar; /* $ symbol allowed as next character */
if ((x = malloc(strlen(n) + 4)) == NULL) /* + 4 for safety */
return NULL;
*x = '\0';
/* Junk pathname as requested */
#ifdef UNZIP
if (uO.jflag && (t = strrchr(n, INTERNAL_DELIMITER)) != NULL)
++t;
else
t = n;
#endif /* UNZIP */
#ifdef ZIP
if (!pathput)
t = last(n, INTERNAL_DELIMITER);
else
t = n;
#endif /* ZIP */
allow_dollar = TRUE;
while (*t != '\0') { /* File part could be sys, vol, subvol or file */
if (*t == INTERNAL_DELIMITER) { /* System, Volume or Subvol Name */
t++;
if (*t == INTERNAL_DELIMITER) { /* System */
strcat(x, TANDEM_NODE_STR);
t++;
}
else {
strcat(x, TANDEM_DELIMITER_STR);
allow_dollar = FALSE;
}
}
/* Work out where end of current external string is */
y = x + strlen(x);
/* Work out substring to copy and externalise */
p = strchr(t, INTERNAL_DELIMITER);
e = strchr(t, DOS_EXTENSION);
if (p != NULL) {
if (e > p)
e = NULL;
}
z = e;
if (z == NULL)
z = p;
if (z == NULL)
z = t + strlen(t);
/* can't have Tandem name longer than 8 characters */
max = y + MAXFILEPARTLEN;
/* Allow $ symbol as first character in some cases */
if (*t == '$') {
if (allow_dollar)
*y++ = *t++;
else;
*t++;
}
/* Make sure first real character is alpha */
if (! isalpha(*t) )
*y++ = 'A';
/* Characters left to process */
len = z - t;
while ( len > 0 ) {
if ( isalnum(*t) ) {
*y++ = toupper(*t++);
if (y >= max)
break;
}
else
t++;
len--;
}
*y = '\0';
t = p;
if (p == NULL) {
/* Last part of filename, store pseudo extension if available */
if (e != NULL) {
strcat(x, TANDEM_EXTENSION_STR);
y = x + strlen(x);
/* no restriction on extension length as its virtual */
z = e + 1;
while ( *z != '\0' ) {
*y++ = toupper(*z++);
}
*y = '\0';
}
break;
}
}
return x;
}
void zexit(status)
int status;
{
/* Exit(>0) creates saveabend files */
terminate_program (0,0,(short)status,,,);
}
/************************/
/* Function zputc() */
/************************/
#ifdef putc
# undef putc
#endif
int zputc(ch, fptr)
int ch;
FILE *fptr;
{
int err;
err = putc(ch,fptr);
fflush(fptr);
return err;
}
#define putc zputc
#ifdef LICENSED
_tal _priv short FILE_CHANGELABEL_ (
short, /* IN */
short, /* IN */
const short _far * /* IN */
);
_c _callable int changelabel OF((short, const short *, const short *));
_c _callable int changelabel(fnum, modtime, actime)
short fnum;
const short *modtime;
const short *actime;
{
int err;
err = FILE_CHANGELABEL_(fnum, 16, modtime);
if (!err)
err = FILE_CHANGELABEL_(fnum, 17, actime);
return err;
}
int islicensed(void)
{
#define plist_items 1
#define plist_size 10
short myphandle[ZSYS_VAL_PHANDLE_WLEN];
short licensetag[plist_items] = {37};
short licensed[plist_size];
short maxlen = plist_size;
short items = plist_items;
short resultlen[1], err;
err = PROCESSHANDLE_NULLIT_(myphandle);
if (!err)
err = PROCESS_GETINFO_(myphandle);
if (!err)
err = PROCESS_GETINFOLIST_(/*cpu*/,
/*pin*/,
/*nodename*/,
/*nodenamelen*/,
myphandle,
licensetag,
items,
licensed,
maxlen,
resultlen
);
if (err != 0)
return 0;
else
return licensed[0];
}
#endif /* LICENSED */
int utime(file, time)
const char *file;
const ztimbuf *time;
{
#ifdef LICENSED
int result, err;
union timestamp_ov {
long long fulltime;
short wordtime[4];
};
union timestamp_ov lasttime, opentime;
struct tm *modt, *opent;
short datetime[8], errormask[1];
short len, fnum, access, exclus, options;
char fname[FILENAME_MAX + 1];
short extension;
char ext[EXTENSION_MAX + 1];
if (islicensed() ) {
/* Attempt to update file label */
modt = gmtime( &time->modtime );
datetime[0] = modt->tm_year + 1900;
datetime[1] = modt->tm_mon + 1;
datetime[2] = modt->tm_mday;
datetime[3] = modt->tm_hour;
datetime[4] = modt->tm_min;
datetime[5] = modt->tm_sec;
datetime[6] = datetime[7] = 0;
errormask[0] = 0;
lasttime.fulltime = COMPUTETIMESTAMP (datetime, errormask);
opent = gmtime( &time->actime );
datetime[0] = opent->tm_year + 1900;
datetime[1] = opent->tm_mon + 1;
datetime[2] = opent->tm_mday;
datetime[3] = opent->tm_hour;
datetime[4] = opent->tm_min;
datetime[5] = opent->tm_sec;
datetime[6] = datetime[7] = 0;
errormask[0] = 0;
opentime.fulltime = COMPUTETIMESTAMP (datetime, errormask);
/* Remove any (pseudo) file extension */
extension = parsename (file,fname,ext);
len = strlen(fname);
access = NSK_WRONLY;
exclus = NSK_SHARED;
options = NSK_NOUPDATEOPENTIME;
extension = parsename (file,fname,ext);
len = strlen(fname);
err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
result = changelabel(fnum,lasttime.wordtime,opentime.wordtime);
err = FILE_CLOSE_(fnum);
return result;
}
return -1;
#else /* !LICENSED */
return 0; /* "no error", to suppress annoying failure messages */
#endif /* ?LICENSED */
}
/* TANDEM version of chmod() function */
int chmod(file, unix_sec)
const char *file;
mode_t unix_sec;
{
FILE *stream;
struct nsk_sec_type {
unsigned progid : 1;
unsigned clear : 1;
unsigned null : 2;
unsigned read : 3;
unsigned write : 3;
unsigned execute: 3;
unsigned purge : 3;
};
union nsk_sec_ov {
struct nsk_sec_type bit_ov;
short int_ov;
};
union nsk_sec_ov nsk_sec;
short fnum, err, nsk_sec_int;
short len, access, exclus, extension, options;
char fname[FILENAME_MAX + 1];
char ext[EXTENSION_MAX + 1];
nsk_sec.bit_ov.progid = 0;
nsk_sec.bit_ov.clear = 0;
nsk_sec.bit_ov.null = 0;
/* 4="N", 5="C", 6="U", 7="-" */
if (unix_sec & S_IROTH) nsk_sec.bit_ov.read = 4;
else if (unix_sec & S_IRGRP) nsk_sec.bit_ov.read = 5;
else if (unix_sec & S_IRUSR) nsk_sec.bit_ov.read = 6;
else nsk_sec.bit_ov.read = 7;
if (unix_sec & S_IWOTH) nsk_sec.bit_ov.write = 4;
else if (unix_sec & S_IWGRP) nsk_sec.bit_ov.write = 5;
else if (unix_sec & S_IWUSR) nsk_sec.bit_ov.write = 6;
else nsk_sec.bit_ov.write = 7;
if (unix_sec & S_IXOTH) nsk_sec.bit_ov.execute = 4;
else if (unix_sec & S_IXGRP) nsk_sec.bit_ov.execute = 5;
else if (unix_sec & S_IXUSR) nsk_sec.bit_ov.execute = 6;
else nsk_sec.bit_ov.execute = 7;
nsk_sec.bit_ov.purge = nsk_sec.bit_ov.write;
nsk_sec_int = nsk_sec.int_ov;
access = NSK_RDONLY;
exclus = NSK_SHARED;
options = NSK_NOUPDATEOPENTIME;
extension = parsename (file,fname,ext);
len = strlen(fname);
err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
err = (SETMODE(fnum, SET_FILE_SECURITY, nsk_sec_int) != CCE);
err = FILE_CLOSE_(fnum);
return (err != 0 ? -1 : 0);
}
/* TANDEM version of chown() function */
int chown(file, uid, gid)
const char *file;
uid_t uid;
gid_t gid;
{
FILE *stream;
struct nsk_own_type {
unsigned group : 8;
unsigned user : 8;
};
union nsk_own_ov {
struct nsk_own_type bit_ov;
short int_ov;
};
union nsk_own_ov nsk_own;
short fnum, err, nsk_own_int;
short len, access, exclus, extension, options;
char fname[FILENAME_MAX + 1];
char ext[EXTENSION_MAX + 1];
nsk_own.bit_ov.group = gid;
nsk_own.bit_ov.user = uid;
nsk_own_int = nsk_own.int_ov;
access = NSK_RDONLY;
exclus = NSK_SHARED;
options = NSK_NOUPDATEOPENTIME;
extension = parsename (file,fname,ext);
len = strlen(fname);
err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
err = (SETMODE(fnum, SET_FILE_OWNER, nsk_own_int) != CCE);
err = FILE_CLOSE_(fnum);
return (err != 0 ? -1 : 0);
}
/* TANDEM version of getch() - non-echo character reading */
int zgetch(void)
{
char ch;
short f, err, count, fnum, rlen;
rlen = 1;
f = (short)fileno(stdin);
fnum = fdtogfn (f);
#define ECHO_MODE 20
err = (SETMODE(fnum, ECHO_MODE, 0) != CCE);
err = (READX(fnum, &ch, rlen, (short *) &count) != CCE);
err = (SETMODE(fnum, ECHO_MODE, 1) != CCE);
if (err)
if (err != 1)
return EOF;
else
ch = 'q';
else
if (count == 0)
ch = '\r';
return (int)ch;
}
short parsename(srce, fname, ext)
const char *srce;
char *fname;
char *ext;
{
/* As a way of supporting DOS extensions from Tandem we look for a space
separated extension string after the Guardian filename
e.g. ZIP ZIPFILE "$DATA4.TESTING.INVOICE TXT"
*/
char *fstart;
char *fptr;
short extension = 0;
*fname = *ext = '\0'; /* set to null string */
fstart = (char *) srce;
if ((fptr = strrchr(fstart, TANDEM_EXTENSION)) != NULL) {
extension = 1;
fptr++;
strncat(ext, fptr, _min(EXTENSION_MAX, strlen(fptr)));
fptr = strchr(fstart, TANDEM_EXTENSION); /* End of filename */
strncat(fname, fstart, _min(FILENAME_MAX, (fptr - fstart)));
}
else {
/* just copy string */
strncat(fname, srce, _min(FILENAME_MAX, strlen(srce)));
}
return extension;
}
static time_t gmt_to_time_t (gmt)
long long *gmt;
{
#define GMT_TO_LCT 0
#define GMT_TO_LST 1
struct tm temp_tm;
short date_time[8];
long julian_dayno;
long long lct, lst, itime;
short err[1], type;
type = GMT_TO_LCT;
lct = CONVERTTIMESTAMP(*gmt, type,, err);
if (!err[0]) {
type = GMT_TO_LST;
lst = CONVERTTIMESTAMP(*gmt, type,, err);
}
itime = (err[0] ? *gmt : lct);
/* If we have no DST in force then make sure we give it a value,
else mktime screws up if we set the isdst flag to -1 */
temp_tm.tm_isdst = (err[0] ? 0 : ((lct == lst) ? 0 : 1));
julian_dayno = INTERPRETTIMESTAMP(itime, date_time);
temp_tm.tm_sec = date_time[5];
temp_tm.tm_min = date_time[4];
temp_tm.tm_hour = date_time[3];
temp_tm.tm_mday = date_time[2];
temp_tm.tm_mon = date_time[1] - 1; /* C's so sad */
temp_tm.tm_year = date_time[0] - 1900; /* it's almost funny */
return (mktime(&temp_tm));
}
/* TANDEM version of stat() function */
int stat(n, s)
const char *n;
struct stat *s;
{
#define ilist_items 26
#define klist_items 4
#define slist_items 3
#define ulist_items 1
#define flist_size 100
short err, i, extension;
char fname[FILENAME_MAX + 1];
short fnamelen;
char ext[EXTENSION_MAX + 1];
/* #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 */
short ilist[ilist_items]={56,144, 54,142, 58, 62, 60, 41, 42, 44,
50, 51, 52, 61, 63, 66, 67, 70, 72, 73,
74, 75, 76, 77, 78, 79 };
short ilen[ilist_items] ={ 4, 4, 4, 2, 1, 2, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1 };
short ioff[ilist_items];
/* #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 */
short klist[klist_items]={45, 46, 68, 69 };
short klen[klist_items] ={ 1, 1, 1, 1 };
short koff[klist_items];
/* #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 */
short slist[slist_items]={43, 80, 90 };
short slen[slist_items] ={ 1, 1, 1 };
short soff[slist_items];
/* #0 #1 #2 #3 #4 #5 #6 #7 #8 #9 */
short ulist[ulist_items]={65 };
short ulen[ulist_items] ={ 1 };
short uoff[ulist_items];
short flist[flist_size];
short extra[2];
short *rlen=&extra[0];
short *err_item=&extra[1];
unsigned short *fowner;
unsigned short *fprogid;
char *fsec;
nsk_stat_ov *nsk_ov;
nsk_file_attrs *nsk_attr;
short end, count, kind, level, options, searchid;
short info[5];
/* Initialise stat structure */
s->st_dev = _S_GUARDIANOBJECT;
s->st_ino = 0;
s->st_nlink = 0;
s->st_rdev = 0;
s->st_uid = s->st_gid = 0;
s->st_size = 0;
s->st_atime = s->st_ctime = s->st_mtime = 0;
s->st_reserved[0] = 0;
s->st_reserved[1] = 0;
s->st_reserved[2] = 0;
nsk_ov = (nsk_stat_ov *)&s->st_reserved[0];
nsk_attr = (nsk_file_attrs *)&nsk_ov->ov.nsk_ef_region;
/* Check to see if name contains a (pseudo) file extension */
extension = parsename (n,fname,ext);
fnamelen = strlen(fname);
options = 3; /* Allow Subvols and Templates */
err = FILENAME_SCAN_( fname,
fnamelen,
&count,
&kind,
&level,
options
);
/* allow kind == 2 (DEFINE names) */
if (err != 0) return -1;
if (kind == 1 || (kind == 0 && level < 2)) {
/* Pattern, Subvol Name or One part Filename - lets see if it exists */
err = FILENAME_FINDSTART_ ( &searchid,
fname,
fnamelen,
,
DISK_DEVICE
);
if (err != 0) {
end = FILENAME_FINDFINISH_ ( searchid );
return -1;
}
err = FILENAME_FINDNEXT_ ( searchid,
fname,
FILENAME_MAX,
&fnamelen,
info
);
end = FILENAME_FINDFINISH_ ( searchid );
if (err != 0)
return -1; /* Non existing template, subvol or file */
if (kind == 1 || info[2] == -1) {
s->st_mode = S_IFDIR; /* Its an existing template or directory */
return 0;
}
/* Must be a real file so drop to code below to get info on it */
}
err = FILE_GETINFOLISTBYNAME_( fname,
fnamelen,
ilist,
ilist_items,
flist,
flist_size,
rlen,
err_item
);
if (err != 0) return -1;
ioff[0] = 0;
/* Build up table of offets into result list */
for (i=1; i < ilist_items; i++)
ioff[i] = ioff[i-1] + ilen[i-1];
/* Set up main stat fields */
/* Setup timestamps */
s->st_atime = gmt_to_time_t ((long long *)&flist[ioff[0]]);
s->st_mtime = s->st_ctime = gmt_to_time_t ((long long *)&flist[ioff[1]]);
nsk_ov->ov.creation_time = gmt_to_time_t ((long long *)&flist[ioff[2]]);
s->st_size = *(off_t *)&flist[ioff[3]];
fowner = (unsigned short *)&flist[ioff[4]];
s->st_uid = *fowner & 0x00ff;
s->st_gid = *fowner >> 8;
/* Note that Purge security (fsec[3]) in NSK has no relevance to stat() */
fsec = (char *)&flist[ioff[5]];
fprogid = (unsigned short *)&flist[ioff[6]];
s->st_mode = S_IFREG | /* Regular File */
/* Parse Read Flag */
((fsec[0] & 0x03) == 0x00 ? S_IROTH : 0) |
((fsec[0] & 0x02) == 0x00 ? S_IRGRP : 0) |
((fsec[0] & 0x03) != 0x03 ? S_IRUSR : 0) |
/* Parse Write Flag */
((fsec[1] & 0x03) == 0x00 ? S_IWOTH : 0) |
((fsec[1] & 0x02) == 0x00 ? S_IWGRP : 0) |
((fsec[1] & 0x03) != 0x03 ? S_IWUSR : 0) |
/* Parse Execute Flag */
((fsec[2] & 0x03) == 0x00 ? S_IXOTH : 0) |
((fsec[2] & 0x02) == 0x00 ? S_IXGRP : 0) |
((fsec[2] & 0x03) != 0x03 ? S_IXUSR : 0) |
/* Parse Progid */
(*fprogid == 1 ? (S_ISUID | S_ISGID) : 0) ;
/* Set up NSK additional stat fields */
nsk_attr->progid = (unsigned) flist[ioff[6]];
nsk_attr->filetype = (unsigned) flist[ioff[7]];
nsk_attr->filecode = (unsigned) flist[ioff[8]];
nsk_attr->block = (unsigned short) flist[ioff[9]];
nsk_attr->priext = (unsigned short) flist[ioff[10]];
nsk_attr->secext = (unsigned short) flist[ioff[11]];
nsk_attr->maxext = (unsigned short) flist[ioff[12]];
nsk_attr->flags.clearonpurge = (unsigned) flist[ioff[13]];
nsk_attr->licensed = (unsigned) flist[ioff[14]];
nsk_attr->flags.audited = (unsigned) flist[ioff[15]];
nsk_attr->flags.acompress = (unsigned) flist[ioff[16]];
nsk_attr->flags.refresheof = (unsigned) flist[ioff[17]];
nsk_attr->flags.buffered = (unsigned) (flist[ioff[18]] == 0 ? 1 : 0);
nsk_attr->flags.verified = (unsigned) flist[ioff[19]];
nsk_attr->flags.serial = (unsigned) flist[ioff[20]];
nsk_attr->flags.crashopen = (unsigned) flist[ioff[22]];
nsk_attr->flags.rollforward = (unsigned) flist[ioff[23]];
nsk_attr->flags.broken = (unsigned) flist[ioff[24]];
nsk_attr->flags.corrupt = (unsigned) flist[ioff[25]];
nsk_attr->fileopen = (unsigned) flist[ioff[21]];
if (nsk_attr->filetype == NSK_UNSTRUCTURED) {
/* extra info for Unstructured files */
err = FILE_GETINFOLISTBYNAME_( fname,
fnamelen,
ulist,
ulist_items,
flist,
flist_size,
rlen,
err_item
);
if (err != 0) return -1;
uoff[0] = 0;
/* Build up table of offets into result list */
for (i=1; i < ulist_items; i++)
uoff[i] = uoff[i-1] + ulen[i-1];
}
else {
/* extra info for Structured files */
err = FILE_GETINFOLISTBYNAME_( fname,
fnamelen,
slist,
slist_items,
flist,
flist_size,
rlen,
err_item
);
if (err != 0) return -1;
soff[0] = 0;
/* Build up table of offets into result list */
for (i=1; i < slist_items; i++)
soff[i] = soff[i-1] + slen[i-1];
nsk_attr->reclen = (unsigned) flist[soff[0]];
nsk_attr->flags.secpart = (unsigned) flist[soff[1]];
nsk_attr->flags.primpart = (unsigned)
( (flist[soff[2]] > 0 && nsk_attr->flags.secpart == 0) ? 1 : 0 );
if (nsk_attr->filetype == NSK_KEYSEQUENCED) {
/* extra info for Key Sequenced files */
err = FILE_GETINFOLISTBYNAME_( fname,
fnamelen,
klist,
klist_items,
flist,
flist_size,
rlen,
err_item
);
if (err != 0) return -1;
koff[0] = 0;
/* Build up table of offets into result list */
for (i=1; i < klist_items; i++)
koff[i] = koff[i-1] + klen[i-1];
nsk_attr->keyoff = (unsigned) flist[koff[0]];
nsk_attr->keylen = (unsigned) flist[koff[1]];
nsk_attr->flags.dcompress = (unsigned) flist[koff[2]];
nsk_attr->flags.icompress = (unsigned) flist[koff[3]];
}
}
return 0;
}
#ifndef SFX
/* TANDEM Directory processing */
DIR *opendir(const char *dirname)
{
short i, resolve;
char sname[FILENAME_MAX + 1];
short snamelen;
char fname[FILENAME_MAX + 1];
short fnamelen;
char *p;
short searchid, err, end;
struct dirent *entry;
DIR *dirp;
char ext[EXTENSION_MAX + 1];
short extension;
extension = parsename(dirname, sname, ext);
snamelen = strlen(sname);
/* First we work out how detailed the template is...
* e.g. If the template is DAVES*.* we want the search result
* in the same format
*/
p = sname;
i = 0;
while ((p = strchr(p, TANDEM_DELIMITER)) != NULL){
i++;
p++;
};
resolve = 2 - i;
/* Attempt to start a filename template */
err = FILENAME_FINDSTART_ ( &searchid,
sname,
snamelen,
resolve,
DISK_DEVICE
);
if (err != 0) {
end = FILENAME_FINDFINISH_(searchid);
return NULL;
}
/* Create DIR structure */
if ((dirp = malloc(sizeof(DIR))) == NULL ) {
end = FILENAME_FINDFINISH_(searchid);
return NULL;
}
dirp->D_list = dirp->D_curpos = NULL;
strcpy(dirp->D_path, dirname);
while ((err = FILENAME_FINDNEXT_(searchid,
fname,
FILENAME_MAX,
&fnamelen
)
) == 0 ){
/* Create space for entry */
if ((entry = malloc (sizeof(struct dirent))) == NULL) {
end = FILENAME_FINDFINISH_(searchid);
return NULL;
}
/* Link to last entry */
if (dirp->D_curpos == NULL)
dirp->D_list = dirp->D_curpos = entry; /* First name */
else {
dirp->D_curpos->d_next = entry; /* Link */
dirp->D_curpos = entry;
};
/* Add directory entry */
*dirp->D_curpos->d_name = '\0';
strncat(dirp->D_curpos->d_name,fname,fnamelen);
if (extension) {
strcat(dirp->D_curpos->d_name,TANDEM_EXTENSION_STR);
strcat(dirp->D_curpos->d_name,ext);
};
dirp->D_curpos->d_next = NULL;
};
end = FILENAME_FINDFINISH_(searchid);
if (err == 1) { /* Should return EOF at end of search */
dirp->D_curpos = dirp->D_list; /* Set current pos to start */
return dirp;
}
else
return NULL;
}
struct dirent *readdir(DIR *dirp)
{
struct dirent *cur;
cur = dirp->D_curpos;
dirp->D_curpos = dirp->D_curpos->d_next;
return cur;
}
void rewinddir(DIR *dirp)
{
dirp->D_curpos = dirp->D_list;
}
int closedir(DIR *dirp)
{
struct dirent *node;
while (dirp->D_list != NULL) {
node = dirp->D_list;
dirp->D_list = dirp->D_list->d_next;
free( node );
}
free( dirp );
return 0;
}
#endif /* !SFX */
Reference in New Issue View Git Blame Copy Permalink