int set_owner(char FAR *storage, char *name, int resolve)
{
#if TARGET==UNIX
struct passwd *pw;
char tmp[256];
int l;
l=*(unsigned char FAR *)storage;
if(resolve)
{
far_memmove((char FAR *)tmp, storage+1, l);
tmp[l]='\0';
if((pw=getpwnam(tmp))==NULL)
return(-1);
return(lchown(name, pw->pw_uid, pw->pw_gid));
}
else
{
if(l!=8)
return(-1);
return(lchown(name, mget_dword(storage+1), mget_dword(storage+5)));
}
#else
return(-1);
#endif
}
int query_owner(char FAR **dest, char *name, int resolve)
{
#if TARGET==UNIX
struct passwd *pw;
struct stat st;
unsigned int l;
if(lstat(name, &st)==-1)
return(-1);
if(resolve)
{
if((pw=getpwuid(st.st_uid))==NULL)
return(-1);
l=strlen(pw->pw_name);
if(l>=256)
return(-1);
*dest=(char FAR *)farmalloc_msg(l+1);
*dest[0]=(unsigned char)l;
far_memmove(*dest+1, (char FAR *)pw->pw_name, l);
}
else
{
*dest=(char FAR *)farmalloc_msg(9);
*dest[0]=8;
mput_dword((unsigned long)st.st_uid, *dest+1);
mput_dword((unsigned long)st.st_gid, *dest+5);
}
return(0);
#else
return(-1);
#endif
}
int query_uxspecial(char FAR **dest, char *name, struct file_properties *props)
{
#if TARGET==UNIX
struct stat st;
char tmp_name[FILENAME_MAX-1];
int l;
char FAR *dptr;
int hardlink=0;
if(lstat(name, &st)==-1)
return(-1);
if(!S_ISDIR(st.st_mode)&&st.st_nlink>1&&props->islink)
hardlink=1;
if(S_ISFIFO(st.st_mode))
mput_byte(MK_UXSB(UXSB_FIFO, 0), (*dest=(char FAR *)farmalloc_msg(1)));
else if(S_ISLNK(st.st_mode)||hardlink)
{
if(hardlink)
{
retrieve_entry(tmp_name, NULL, &flist_main, props->hl_search.ref);
l=strlen(tmp_name);
}
else
{
if((l=readlink(name, tmp_name, sizeof(tmp_name)))<=0)
return(-1);
}
*dest=(char FAR *)farmalloc_msg(UXSB_CALC_SIZE(l));
dptr=fill_hdr_size(*dest, hardlink?UXSB_HLNK:UXSB_LNK, l);
far_memmove(dptr, (char FAR *)tmp_name, l);
}
else if(S_ISCHR(st.st_mode)||S_ISBLK(st.st_mode))
{
*dest=(char FAR *)farmalloc_msg(UXSB_CALC_SIZE(sizeof(st.st_rdev)));
dptr=fill_hdr_size(*dest, S_ISCHR(st.st_mode)?UXSB_CHR:UXSB_BLK, sizeof(st.st_rdev));
far_memmove(dptr, (char FAR *)&st.st_rdev, sizeof(st.st_rdev));
}
else
return(-1); /* Unusual file type, report warning */
#else
return(-1);
#endif
return(0);
}
int set_uxspecial(char FAR *storage, char *name)
{
#if TARGET==UNIX
char FAR *dptr;
int l, id;
char tmp_name[FILENAME_MAX];
int rc;
unlink(name);
l=UXSB_GET_SIZE(storage[0]);
if(l==UXSB_SIZE_THRESHOLD)
l=mget_word(storage+1);
id=UXSB_GET_ID(storage[0]);
dptr=storage+((UXSB_GET_SIZE(*storage)==UXSB_SIZE_THRESHOLD)?3:1);
switch(id)
{
case UXSB_FIFO:
rc=mkfifo(name, 0644);
return(rc?UXSPEC_RC_ERROR:0);
case UXSB_HLNK:
case UXSB_LNK:
#if SFX_LEVEL>=ARJ
if(id==UXSB_HLNK&&suppress_hardlinks)
return(UXSPEC_RC_SUPPRESSED);
#endif
if(l>=sizeof(tmp_name))
l=sizeof(tmp_name)-1;
far_memmove((char FAR *)tmp_name, dptr, l);
tmp_name[l]='\0';
rc=(id==UXSB_HLNK)?link(tmp_name, name):symlink(tmp_name, name);
if(!rc)
return;
return(errno==EPERM?UXSPEC_RC_NOLINK:UXSPEC_RC_ERROR);
case UXSB_BLK:
case UXSB_CHR:
/* Check for platform mismatch */
if(sizeof(dev_t)!=l)
return(UXSPEC_RC_FOREIGN_OS);
rc=mknod(name, 0644|((id==UXSB_BLK)?S_IFBLK:S_IFCHR), *(dev_t FAR *)dptr);
return(rc?UXSPEC_RC_ERROR:0);
}
#else
return(UXSPEC_RC_ERROR);
#endif
}
void owner_stats(char FAR *storage, int resolve)
{
char tmp[256];
int l;
l=*(unsigned char FAR *)storage;
if(resolve)
{
far_memmove((char FAR *)tmp, storage+1, l);
tmp[l]='\0';
}
else
{
if(l==8)
msg_sprintf(tmp, M_OWNER_ID, mget_dword(storage+1), mget_dword(storage+5));
else
strcpy(tmp, "???");
}
msg_sprintf(misc_buf, M_OWNER_LIST, tmp);
arj_user_msg(misc_buf);
}
void uxspecial_stats(char FAR *storage, int format)
{
#if TARGET==UNIX
FMSGP fm;
#endif
#if SFX_LEVEL>=ARJ
char tmp[FILENAME_MAX-1];
char FAR *dptr;
int i, l, m, id;
#endif
if(format==UXSTATS_SHORT)
{
/* Only relevant under UNIX when extracting the files */
#if TARGET==UNIX
switch(UXSB_GET_ID(storage[0]))
{
case UXSB_FIFO:
fm=M_UXSPECIAL_FIFO;
break;
case UXSB_HLNK:
fm=M_UXSPECIAL_HLNK;
break;
case UXSB_LNK:
fm=M_UXSPECIAL_LNK;
break;
case UXSB_CHR:
fm=M_UXSPECIAL_CHR;
break;
case UXSB_BLK:
fm=M_UXSPECIAL_BLK;
break;
default:
return;
}
msg_fprintf(new_stdout, fm);
fputc(' ', new_stdout);
#endif
}
#if SFX_LEVEL>=ARJ
else
{
l=UXSB_GET_SIZE(storage[0]);
if(l==UXSB_SIZE_THRESHOLD)
l=mget_word(storage+1);
id=UXSB_GET_ID(storage[0]);
dptr=storage+((UXSB_GET_SIZE(*storage)==UXSB_SIZE_THRESHOLD)?3:1);
switch(id)
{
case UXSB_FIFO:
arj_user_msg(M_UXLIST_FIFO);
break;
case UXSB_HLNK:
case UXSB_LNK:
if(l>=sizeof(tmp))
l=sizeof(tmp)-1;
far_memmove((char FAR *)tmp, dptr, l);
tmp[l]='\0';
msg_sprintf(misc_buf, (id==UXSB_HLNK)?M_UXLIST_HLNK:M_UXLIST_LNK, tmp);
arj_user_msg(misc_buf);
break;
case UXSB_BLK:
case UXSB_CHR:
m=0;
tmp[0]='\0';
for(i=0; i<l&&m<sizeof(tmp)-4; i++)
m+=sprintf(tmp+m, "%02x ", (unsigned char)dptr[i]);
if(m>0)
tmp[m-1]='\0';
msg_sprintf(misc_buf, (id==UXSB_BLK)?M_UXLIST_BLK:M_UXLIST_CHR, tmp);
arj_user_msg(misc_buf);
break;
}
}
#endif
}
int resolve_longname(char *dest, char *name)
{
#ifdef HAVE_EAS
unsigned char *tmp_name;
int entry, l_sel, rc;
#if TARGET==OS2
#ifdef __32BIT__
EAOP2 eaop;
PGEA2LIST pgeal;
PFEA2LIST pfeal;
#else
EAOP eaop;
PGEALIST pgeal;
PFEALIST pfeal;
#endif
#elif TARGET==WIN32
struct nt_sid *sid=NULL;
unsigned char *streambuf=NULL;
unsigned long stream_len, rem_len, fetch;
FEALIST feal;
PFEALIST pfeal;
#endif
char FAR *valptr;
unsigned int st_len;
if(name[0]=='\0'||name[0]==PATHSEP_DEFAULT&&name[1]=='\0'||name[1]==':'&&name[2]=='\0')
{
strcpy(dest, name);
return(0);
}
tmp_name=(char *)malloc_msg(FILENAME_MAX);
l_sel=entry=split_name(name, tmp_name, NULL);
if(entry>0)
{
tmp_name[entry-1]='\0';
resolve_longname(dest, tmp_name);
entry=strlen(dest);
dest[entry]=PATHSEP_DEFAULT;
dest[entry+1]='\0';
}
else
dest[0]='\0';
#if TARGET==OS2
#ifdef __32BIT__
pgeal=(PGEA2LIST)farmalloc_msg(sizeof(GEA2LIST)+sizeof(longname_ea));
pfeal=(PFEA2LIST)farmalloc_msg(sizeof(FEA2LIST)+sizeof(longname_ea)+FILENAME_MAX);
#else
pgeal=(PGEALIST)farmalloc_msg(sizeof(GEALIST)+sizeof(longname_ea));
pfeal=(PFEALIST)farmalloc_msg(sizeof(FEALIST)+sizeof(longname_ea)+FILENAME_MAX);
#endif
far_strcpy(pgeal->list[0].szName, (char FAR *)longname_ea);
#elif TARGET==WIN32
pfeal=(PFEALIST)farmalloc_msg(sizeof(FEALIST)+sizeof(longname_ea)+FILENAME_MAX);
#endif
#if TARGET==OS2
#ifdef __32BIT__
pgeal->list[0].oNextEntryOffset=0;
#endif
pgeal->list[0].cbName=sizeof(longname_ea)-1;
#ifdef __32BIT__
pgeal->cbList=sizeof(GEA2LIST)+sizeof(longname_ea)-1;
pfeal->cbList=sizeof(FEA2LIST)+sizeof(longname_ea)+FILENAME_MAX-1-entry;
eaop.fpGEA2List=pgeal;
eaop.fpFEA2List=pfeal;
#else
pgeal->cbList=sizeof(GEALIST)+sizeof(longname_ea)-1;
pfeal->cbList=sizeof(FEALIST)+sizeof(longname_ea)+FILENAME_MAX-1-entry;
eaop.fpGEAList=pgeal;
eaop.fpFEAList=pfeal;
#endif
#ifdef __32BIT__
if(DosQueryPathInfo(name, FIL_QUERYEASFROMLIST, (PBYTE)&eaop, sizeof(eaop)))
#else
if(DosQPathInfo(name, FIL_QUERYEASFROMLIST, (PBYTE)&eaop, sizeof(eaop), 0L))
#endif
rc=0;
else
{
rc=1;
#ifdef __32BIT__
valptr=(char FAR *)pfeal+sizeof(FEA2LIST)+pfeal->list[0].cbName;
#else
valptr=(char FAR *)pfeal+sizeof(FEALIST)+pfeal->list[0].cbName+1;
#endif
}
#elif TARGET==WIN32
rc=0;
if((sid=open_streams(name, 0))!=NULL&&
(stream_len=seek_stream_id(BACKUP_EA_DATA, sid))>0)
{
valptr=streambuf=(char *)farmalloc_msg(256);
pfeal=(PFEALIST)&feal;
while(read_stream((char *)pfeal, sizeof(FEALIST), sid)==sizeof(FEALIST)&&
read_stream(streambuf, pfeal->list[0].cbName+1, sid)==pfeal->list[0].cbName+1)
{
rem_len=pfeal->cbList-sizeof(FEALIST)-pfeal->list[0].cbName-1;
if(!stricmp(streambuf, longname_ea))
{
if(pfeal->list[0].cbValue<256)
{
read_stream(streambuf, pfeal->list[0].cbValue, sid);
rc=1;
break;
}
}
else
{
if(pfeal->cbList==0)
break;
/* Advance to the next EA entry */
while(rem_len>0)
{
fetch=min(256, rem_len);
read_stream(streambuf, fetch, sid);
rem_len-=fetch;
}
}
}
}
#endif
if(rc)
{
if((st_len=pfeal->list[0].cbValue)==0)
rc=0;
else
{
far_memmove((char FAR *)tmp_name, valptr, st_len);
tmp_name[st_len]='\0';
if(tmp_name[0]==0xFD&&tmp_name[1]==0xFF)
{
strcpy(tmp_name, (char *)tmp_name+4);
st_len-=4;
}
if(st_len==0||st_len+entry>=FILENAME_MAX)
rc=0;
else
{
while(st_len-->0)
{
if(tmp_name[st_len]<' '||strchr(forbidden_chars, tmp_name[st_len])!=NULL)
{
rc=0;
break;
}
}
}
}
}
if(!rc)
{
if(strlen(name)+entry+l_sel>=FILENAME_MAX)
error(M_MAXPATH_EXCEEDED, FILENAME_MAX, name);
strcat(dest, name+l_sel);
}
else
strcat(dest, (char *)tmp_name);
#if TARGET==OS2
farfree(pgeal);
farfree(pfeal);
#elif TARGET==WIN32
if(streambuf!=NULL)
farfree(streambuf);
if(sid!=NULL)
close_streams(sid);
#endif
free(tmp_name);
return(rc);
#else
return(0);
#endif
}
int set_ea(char FAR *i_eas, char *name)
{
#ifdef HAVE_EAS
int rc=0;
char FAR *eas;
unsigned int i, total;
#if TARGET==OS2
#ifdef __32BIT__
FILESTATUS4 fs;
EAOP2 eaop;
char FAR *real_pfeal;
PFEA2LIST pfeal;
PFEA2 pf, opf;
#else
EAOP eaop;
PFEALIST pfeal;
PFEA pf;
FILESTATUS2 fs;
SEL selector;
#endif
#elif TARGET==WIN32
PFEALIST pfeal0, pfeal;
PFEA pf;
struct nt_sid *sid;
unsigned char *pstreambuf, *streambuf;
WIN32_STREAM_ID w32sid;
unsigned long stream_len;
#endif
eas=i_eas;
if(discard_ea(name))
return(-1);
if((total=mget_word(eas))==0)
return(0);
#if TARGET==OS2
#ifdef __32BIT__
/* This takes the 4-byte prefixes into account (are the V1.2 EAs still
valid if they flow beyond 64K when the oNextEntryOffset is applied?).
Also, we ensure that it is aligned properly. In theory, there may be
a way to crash this (72K doesn't consider the multitude of EAs) but we
don't know/care about it -- ASR 17/10/2000 */
real_pfeal=(char FAR *)farmalloc_msg(73728);
pfeal=(PFEA2LIST)align_dword(real_pfeal);
eaop.fpFEA2List=pfeal;
#else
if(DosAllocSeg(65535U, &selector, SEG_NONSHARED))
return(-1);
pfeal=(PFEALIST)MAKEP(selector, 0);
eaop.fpFEAList=pfeal;
#endif
#elif TARGET==WIN32
pstreambuf=(char *)farmalloc_msg(65536+260*total);
pfeal=pfeal0=(PFEALIST)(streambuf=align_dword(pstreambuf));
#endif
eas+=2;
pf=&pfeal->list[0];
for(i=0; i<total; i++)
{
#if TARGET==OS2&&defined(__32BIT__)
opf=pf;
#endif
#if TARGET==WIN32
pf=&pfeal->list[0];
#endif
pf->fEA=mget_byte(eas++);
pf->cbName=mget_byte(eas++);
pf->cbValue=mget_word(eas);
eas+=2;
#if TARGET==OS2&&defined(__32BIT__)
far_memmove((char FAR *)pf+sizeof(FEA2)-1, eas, pf->cbName);
*((char FAR *)pf+sizeof(FEA2)-1+pf->cbName)='\0';
#else /* Win32 or OS/2-16 */
far_memmove((char FAR *)pf+sizeof(FEA), eas, pf->cbName);
*((char FAR *)pf+sizeof(FEA)+pf->cbName)='\0';
#endif
eas+=pf->cbName;
#if TARGET==OS2&&defined(__32BIT__)
far_memmove((char FAR *)pf+sizeof(FEA2)+pf->cbName, eas, pf->cbValue);
#else /* Win32 or OS/2-16 */
far_memmove((char FAR *)pf+sizeof(FEA)+pf->cbName+1, eas, pf->cbValue);
#endif
eas+=pf->cbValue;
#if SFX_LEVEL>=ARJ
#if TARGET==OS2&&defined(__32BIT__)
if(ea_filter((char FAR *)pf+sizeof(FEA2), 0)&&((pf->fEA&FEA_NEEDEA)||!crit_eas))
#else /* Win32 or OS/2-16 */
if(ea_filter((char FAR *)pf+sizeof(FEA), 0)&&((pf->fEA&FEA_NEEDEA)||!crit_eas))
#endif
#endif
/* Update the offsets */
#if TARGET==OS2
#ifdef __32BIT__
pf=(PFEA2)((char FAR *)pf+sizeof(FEA2)+pf->cbName+pf->cbValue);
#else
pf=(PFEA)((char FAR *)pf+sizeof(FEA)+pf->cbName+1+pf->cbValue);
#endif
/* Align at DWORD boundary and issue the list fixups */
#ifdef __32BIT__
pf=(PFEA2)align_dword((char FAR *)pf);
opf->oNextEntryOffset=(i+1==total)?0:(char FAR *)pf-(char FAR *)opf;
#endif
#elif TARGET==WIN32
pfeal=(PFEALIST)((char FAR *)pfeal+sizeof(FEALIST)+pf->cbName+1+pf->cbValue);
if(i<total-1)
pfeal=(PFEALIST)align_dword((char FAR*)pfeal);
pfeal0->cbList=(i==total-1)?
0:
(((char FAR *)pfeal)-((char FAR *)pfeal0));
pfeal0=pfeal;
#endif
}
#if TARGET==OS2
pfeal->cbList=(char FAR *)pf-(char FAR *)pfeal;
#ifdef __32BIT__
rc=DosSetPathInfo((PSZ)name, FIL_QUERYEASIZE, (PBYTE)&eaop, sizeof(eaop), 0);
farfree(real_pfeal);
#else
rc=DosSetPathInfo((PSZ)name, FIL_QUERYEASIZE, (PBYTE)&eaop, sizeof(eaop), 0, 0L);
DosFreeSeg(selector);
#endif
if(!rc)
{
#ifdef __32BIT__
if(DosQueryPathInfo(name, FIL_QUERYEASIZE, (PVOID)&fs, sizeof(fs)))
#else
if(DosQPathInfo(name, FIL_QUERYEASIZE, (PVOID)&fs, sizeof(fs), 0L))
#endif
rc=-1;
else
if(fs.cbList<=4)
rc=-1;
}
#elif TARGET==WIN32
if((sid=open_streams(name, 1))==NULL)
rc=-1;
else
{
memset(&w32sid, 0, sizeof(w32sid));
w32sid.dwStreamId=BACKUP_EA_DATA;
w32sid.Size.LowPart=stream_len=(((char FAR *)pfeal)-streambuf);
if(create_stream(&w32sid, sid)||write_stream(streambuf, stream_len, sid)<stream_len)
rc=-1;
close_streams(sid);
}
free(pstreambuf);
#endif
return(rc);
#else
return(-1);
#endif
}
int query_ea(char FAR **dest, char *name, int skip_ln)
{
#ifdef HAVE_EAS
ULONG count, j;
#if TARGET==OS2
#ifdef __32BIT__
EAOP2 eaop;
PGEA2LIST pgeal;
PFEA2LIST pfeal;
APIRET rc;
PDENA2 pdena;
FILESTATUS4 fs;
#else
EAOP eaop;
PGEALIST pgeal;
PFEALIST pfeal;
USHORT rc;
PDENA1 pdena;
FILESTATUS2 fs;
#endif
#elif TARGET==WIN32
struct nt_sid *sid;
unsigned char *streambuf;
unsigned long stream_len;
PFEALIST pfeal;
#endif
int rcode=0;
char FAR *dptr, FAR *nptr;
#if TARGET==OS2
pdena=farmalloc_msg(sizeof(*pdena)+CCHMAXPATHCOMP);
#ifdef __32BIT__
pgeal=(PGEA2LIST)farmalloc_msg(sizeof(GEA2LIST)+CCHMAXPATHCOMP);
if(DosQueryPathInfo(name, FIL_QUERYEASIZE, (PVOID)&fs, sizeof(fs)))
return(-1);
#else
pgeal=(PGEALIST)farmalloc_msg(sizeof(GEALIST)+CCHMAXPATHCOMP);
if(DosQPathInfo(name, FIL_QUERYEASIZE, (PVOID)&fs, sizeof(fs), 0L))
return(-1);
#endif
if(fs.cbList<4)
fs.cbList=4; /* Fix for Ext2FS */
/* Allocate enough space to hold EA block */
#ifdef __32BIT__
*dest=(char FAR *)farmalloc_msg((int)fs.cbList*2); /* SDK does recommend it */
#else
*dest=(char FAR *)farmalloc_msg((int)fs.cbList-2);
#endif
#elif TARGET==WIN32
if((sid=open_streams(name, 0))==NULL)
return(-1);
stream_len=seek_stream_id(BACKUP_EA_DATA, sid);
if(stream_len==0||stream_len>65535)
{
close_streams(sid);
*dest=(char FAR *)farmalloc_msg(2);
dptr=*dest;
mput_word(0, dptr);
return(0);
}
/* It's a plain FEALIST, so doesn't require much caution */
streambuf=(char FAR *)farmalloc_msg((int)stream_len);
*dest=(char FAR *)farmalloc_msg((int)stream_len);
if((stream_len=read_stream(streambuf, stream_len, sid))==0)
{
close_streams(sid);
dptr=*dest;
mput_word(0, dptr);
free(streambuf);
return(0);
}
#endif
/* Initialize storage */
dptr=*dest;
mput_word(0, dptr);
dptr+=2;
j=0L;
while(1)
{
#if TARGET==OS2
count=1L;
#ifdef __32BIT__
if(DosEnumAttribute(ENUMEA_REFTYPE_PATH, (PVOID)name, ++j, (PVOID)pdena,
sizeof(*pdena)+CCHMAXPATHCOMP, &count,
ENUMEA_LEVEL_NO_VALUE))
break;
#else
if(DosEnumAttribute(ENUMEA_REFTYPE_PATH, (PVOID)name, ++j, (PVOID)pdena,
sizeof(*pdena)+CCHMAXPATHCOMP, &count,
ENUMEA_LEVEL_NO_VALUE, 0L))
break;
#endif
if(count==0L)
break;
/* EA (pdena->szName) consumes (pdena->cbValue) bytes */
#ifdef __32BIT__
eaop.fpGEA2List=pgeal;
#else
eaop.fpGEAList=pgeal;
#endif
far_strcpy(pgeal->list[0].szName, pdena->szName);
pgeal->list[0].cbName=pdena->cbName;
#ifdef __32BIT__
pgeal->list[0].oNextEntryOffset=0;
pgeal->cbList=sizeof(GEA2LIST)+pdena->cbName;
eaop.fpGEA2List=pgeal;
pfeal=(PFEA2LIST)farmalloc_msg(sizeof(FEA2LIST)+pdena->cbName+pdena->cbValue+1);
pfeal->cbList=sizeof(FEA2LIST)+pdena->cbName+pdena->cbValue+1;
eaop.fpFEA2List=pfeal;
if((rc=DosQueryPathInfo(name, FIL_QUERYEASFROMLIST, (PBYTE)&eaop, sizeof(eaop)))!=0)
{
farfree(pfeal);
rcode=-1;
break;
}
nptr=(char FAR *)&(pfeal->list[0])+sizeof(FEA2)-1;
#else
pgeal->cbList=sizeof(GEALIST)+pdena->cbName;
eaop.fpGEAList=pgeal;
pfeal=(PFEALIST)farmalloc_msg(sizeof(FEALIST)+pdena->cbName+pdena->cbValue+1);
pfeal->cbList=sizeof(FEALIST)+pdena->cbName+pdena->cbValue+1;
eaop.fpFEAList=pfeal;
if((rc=DosQPathInfo(name, FIL_QUERYEASFROMLIST, (PBYTE)&eaop, sizeof(eaop), 0L))!=0)
{
farfree(pfeal);
rcode=-1;
break;
}
nptr=(char FAR *)&(pfeal->list[0])+sizeof(FEA);
#endif
#elif TARGET==WIN32
/* Win32 provides us with a FEALIST at our disposal. */
pfeal=(PFEALIST)streambuf;
nptr=(char FAR *)&(pfeal->list[0])+sizeof(FEA);
#endif
#if SFX_LEVEL>=ARJ
if(ea_filter(nptr, skip_ln)&&((pfeal->list[0].fEA&FEA_NEEDEA)||!crit_eas))
#endif
{
mput_word(mget_word(*dest)+1, *dest);
mput_byte(pfeal->list[0].fEA, dptr++);
mput_byte(pfeal->list[0].cbName, dptr++);
mput_word(pfeal->list[0].cbValue, dptr);
dptr+=2;
far_memmove(dptr, nptr, (int)pfeal->list[0].cbName);
dptr+=pfeal->list[0].cbName;
far_memmove(dptr, nptr+pfeal->list[0].cbName+1, pfeal->list[0].cbValue);
dptr+=pfeal->list[0].cbValue;
}
#if TARGET==OS2
farfree(pfeal);
#elif TARGET==WIN32
if(pfeal->cbList==0) /* Indicates the last EA */
break;
streambuf+=pfeal->cbList;
#endif
}
#if TARGET==OS2
farfree(pdena);
farfree(pgeal);
#endif
#if TARGET==WIN32
close_streams(sid);
#endif
return(rcode);
#else
return(-1);
#endif
}
int extraction_stub(char *block, int block_len, int action)
{
char c;
char *block_ptr;
int cn;
#if SFX_LEVEL>=ARJ
if(!debug_enabled||strchr(debug_opt, 'c')==NULL)
crc_for_block(block, block_len);
#else
crc32_for_block(block, block_len);
#endif
if(!file_packing) /* Not applicable for memory data */
{
if(encmem_limit<block_len) /* Check for overrun */
error(M_BAD_HEADER);
encmem_limit-=block_len;
far_memmove(encblock_ptr, (char FAR *)block, block_len);
encblock_ptr+=block_len;
encmem_remain+=block_len;
return(0);
}
/* Postprocessing */
#if SFX_LEVEL>=ARJ
if(action==BOP_LIST||action==BOP_SEARCH||action==BOP_COMPARE||action==BOP_DISPLAY)
return(block_op(action, block, block_len));
#endif
if(atstream==NULL)
return(0);
/* Strip high bit from files created by different OS */
if(file_type==ARJT_TEXT&&host_os!=OS
#if SFX_LEVEL>=ARJ
&&type_override!=FT_BINARY
#endif
)
{
block_ptr=block;
while(block_len-->0)
{
c=*(block_ptr++);
c&=0x7F;
if(fputc((int)c, atstream)==EOF)
error(M_DISK_FULL);
}
}
else
{
/* HACK for IBM LIBC implementations under 32-bit OS/2 */
#if SFX_LEVEL>=ARJSFXV&&TARGET==OS2&&(COMPILER==ICC||defined(LIBC))
int fn=fileno(atstream);
if(fn<6)
{
_setmode(fn, file_type?0x4000:0x8000); /* O_TEXT:O_BINARY */
cn=write(fn, block, block_len);
}
else
cn=fwrite(block, 1, block_len, atstream);
#else
cn=fwrite(block, 1, block_len, atstream);
#endif
#if SFX_LEVEL>=ARJSFXV
if(is_tty(atstream))
cn=block_len;
#endif
if(cn!=block_len)
error(M_DISK_FULL);
}
return(0);
}
