arjsfxjr.c

open arj source

 sfxjr_puts(M_VD_SPACE);
 if(file_type!=ARJT_DIR)
 {
  if(method>0)
   decode();
  else
   unstore();
  if(!test_mode)
   _close(atstream);
 }
 if(!test_mode)
 {
  #if TARGET==UNIX
   {
    struct utimbuf ut;

    ut.actime=ut.modtime=ftime_stamp;
    utime(filename, &ut);
   }
  #elif TARGET==WIN32
   file_setftime(filename, ftime_stamp);
  #else
   if((atstream=_open(filename, O_BINARY|O_RDWR))>0)
   {
    file_setftime_on_hf(atstream, ftime_stamp);
    _close(atstream);
   }
  #endif
  #if COMPILER==BCC
   _chmod(filename, 1, file_mode&STD_ATTRS);
  #elif COMPILER==MSC||COMPILER==MSVC
   #if TARGET==DOS
    _dos_setfileattr(filename, file_mode&STD_ATTRS);
   #elif TARGET==OS2
    DosSetFileMode(filename, file_mode&STD_ATTRS, 0L);
   #elif TARGET==WIN32
    SetFileAttributes(filename, file_mode&STD_ATTRS);
   #endif
  #endif
 }
 atstream=0;
 unpack_in_progress=0;
 if((crc32term^CRC_MASK)==file_crc)
  sfxjr_puts(M_OK);
 else
 {
  sfxjr_puts(M_CRC_ERROR);
  errors++;
 }
 nputlf();
 return(1);
}

/* Analyzes command-line parameters */

static int analyze_arg(char *arg)
{
 if(arg[0]=='-')
 {
  switch(arg[1])
  {
   case 'n':
   case 'N':
    allow_skipping=1;
    return(0);
   case 'o':
   case 'O':
    overwrite_existing=1;
    return(0);
   case 't':
   case 'T':
    test_mode=1;
    return(0);
   case '*':
    return(0);
   default:
    return(1);
  }
 }
 else
 {
  if(dest_dir[0]!='\0'||strchr(pathsep_sfxjr, arg[strlen(arg)-1])==NULL)
   return(1);
  dest_dir=arg;
 }
 return(0);
}

/* ARJSFXJR allows comment preprocessing, too... */

static char *preprocess_comment(char *comment)
{
 int arg_rc;
 char ctr;
 char *aptr, *endptr;

 if(comment[0]==')'&&comment[1]==')')
 {
  comment+=2;
  arg_rc=0;
  aptr=cmd_args;
  for(ctr=1; ctr<sizeof(cmd_args)&&*comment!='\0'&&*comment!='}'; ctr++)
  {
   *aptr=*comment;
   if(*aptr==' ')
    *aptr='\0';
   comment++;
   aptr++;
  }
  *aptr='\0';
  endptr=aptr;
  aptr=cmd_args;

  while((endptr-aptr)>0)
  {
   while(*aptr=='\0')
    aptr++;
   if((endptr-aptr)>0)
   {
    arg_rc=analyze_arg(aptr);
    while(*aptr!='\0'&&(endptr-aptr)>0)
     aptr++;
   }
  }
  if(arg_rc)
   error(M_INVALID_SWITCH);
  if(*comment=='\n')
   comment++;
 }
 return(comment);
}

/* SFX opening routine */

static void process_archive()
{
 char *cmt_ptr;
 char numfiles[10];

 if((aistream=_open(archive_name, O_BINARY|O_RDONLY))<0)
 {
  sfxjr_puts(M_CANTOPEN);
  sfxjr_puts((FMSG *)archive_name);
  nputlf();
  exit(ARJSFXJR_ERL_FATAL);
 }
 sfxjr_puts(M_PROCESSING_ARCHIVE);
 sfxjr_puts((FMSG *)archive_name);
 nputlf();
 find_sfx_header();
 get_reg_id();
 if(reg_id!=REG_ID)
  reg_id=0;
 if(!read_header())
  error(M_BAD_HEADER);
 cmt_ptr=comment;
 if(st_argc==1)
  cmt_ptr=preprocess_comment(cmt_ptr);
 sfxjr_puts((FMSG *)cmt_ptr);
 while(read_header())
  if(unpack_file())
   total_files++;
 numtostr(total_files, numfiles);
 /* German NLS fix -- ASR 12/10/2000 */
 #if LOCALE==LANG_de
  sfxjr_puts(numfiles);
  sfxjr_puts(M_FILES);
  sfxjr_puts(M_EXTRACTED);
 #else
  sfxjr_puts(M_EXTRACTED);
  sfxjr_puts(numfiles);
  sfxjr_puts(M_FILES);
 #endif
 nputlf();
 _close(aistream);
}

/* Ctrl+Break handler */

#if COMPILER==BCC
static int ctrlc_handler()
#else
static void ctrlc_handler(int sig)
#endif
{
 sfxjr_puts(M_BREAK_SIGNALED);
 exit(ARJSFXJR_ERL_FATAL);
 #if COMPILER==BCC
  return(0);
 #endif
}

/* Pre-exit cleanup routine */

static void final_cleanup(void)
{
 if(atstream!=0)
  _close(atstream);
 if(unpack_in_progress)
  unlink(filename);
}

/* Main routine */

int main(int argc, char **argv)
{
 int arg_rc;
 unsigned int i;

 st_argc=argc;
 arg_rc=0;
 for(i=1; i<argc; i++)
  arg_rc=analyze_arg(argv[i]);
 sfxjr_puts(M_ARJSFX_BANNER);
 nputlf();
 if(arg_rc)
  error(M_INVALID_SWITCH);
 build_crc32_table();
 #ifndef SKIP_GET_EXE_NAME
  get_exe_name(archive_name);
 #else
  get_exe_name(archive_name, argv[0]);
 #endif
 atexit(final_cleanup);
 #if COMPILER==BCC
  ctrlbrk(ctrlc_handler);
 #else
  signal(SIGINT, ctrlc_handler);
 #endif
 process_archive();
 if(errors!=0)
  error(M_FOUND_ERRORS);
 return((warnings>0)?ARJSFXJR_ERL_ERROR:ARJSFXJR_ERL_SUCCESS);
}

/* Creates a table for decoding */

static void NEAR make_table(int nchar, unsigned char *bitlen, int tablebits, unsigned short *table, int tablesize)
{
 unsigned short count[17], weight[17], start[18];
 unsigned short *p;
 unsigned int i, k, len, ch, jutbits, avail, nextcode, mask;

 for(i=1; i<=16; i++)
  count[i]=0;
 for(i=0; (int)i<nchar; i++)
  count[bitlen[i]]++;
 start[1]=0;
 for(i=1; i<=16; i++)
  start[i+1]=start[i]+(count[i]<<(16-i));
 if(start[17]!=(unsigned short)(1<<16))
  error(M_BADTABLE);
 jutbits=16-tablebits;
 for(i=1; (int)i<=tablebits; i++)
 {
  start[i]>>=jutbits;
  weight[i]=1<<(tablebits-i);
 }
 while(i<=16)
 {
  weight[i]=1<<(16-i);
  i++;
 }
 i=start[tablebits+1]>>jutbits;
 if(i!=(unsigned short)(1<<16))
 {
  k=1<<tablebits;
  while(i!=k)
   table[i++]=0;
 }
 avail=nchar;
 mask=1<<(15-tablebits);
 for(ch=0; (int)ch<nchar; ch++)
 {
  if((len=bitlen[ch])!=0)
  {
   k=start[len];
   nextcode=k+weight[len];
   if((int)len<=tablebits)
   {
    if(nextcode>(unsigned int)tablesize)
     error(M_BADTABLE);
    for(i=start[len]; i<nextcode; i++)
     table[i]=ch;
   }
   else
   {
    p=&table[k>>jutbits];
    i=len-tablebits;
    while(i!=0)
    {
     if(*p==0)
     {
      right[avail]=left[avail]=0;
      *p=avail++;
     }
     if(k&mask)
      p=&right[*p];
     else
      p=&left[*p];
     k<<=1;
     i--;
    }
    *p=ch;
   }
   start[len]=nextcode;
  }
 }
}

/* Reads length of data pending */

void read_pt_len(int nn, int nbit, int i_special)
{
 int i, n;
 short c;
 unsigned short mask;

 n=getbits(nbit);
 if(n==0)
 {
  c=getbits(nbit);
  for(i=0; i<nn; i++)
   pt_len[i]=0;
  for(i=0; i<PTABLESIZE; i++)
   pt_table[i]=c;
 }
 else
 {
  i=0;
  if(n>=NPT)                            /* ASR fix to prevent overrun */
   n=NPT;
  while(i<n)
  {
   c=bitbuf>>13;
   if(c==7)
   {
    mask=1<<12;
    while(mask&bitbuf)
    {
     mask>>=1;
     c++;
    }
   }
   fillbuf((c<7)?3:(int)(c-3));
   pt_len[i++]=(unsigned char)c;
   if(i==i_special)
   {
    c=getbits(2);
    while(--c>=0)
     pt_len[i++]=0;
   }
  }
  while(i<nn)
   pt_len[i++]=0;
  make_table(nn, pt_len, 8, pt_table, sizeof(pt_table));
 }
}

/* Reads a character table */

void read_c_len()
{
 short i, c, n;
 unsigned short mask;

 n=getbits(CBIT);
 if(n==0)
 {
  c=getbits(CBIT);
  for(i=0; i<NC; i++)
   c_len[i]=0;
  for(i=0; i<CTABLESIZE; i++)
   c_table[i]=c;
 }
 else
 {
  i=0;
  while(i<n)
  {
   c=pt_table[bitbuf>>8];
   if(c>=NT)
   {
    mask=1<<7;
    do
    {
     if(bitbuf&mask)
      c=right[c];
     else
      c=left[c];
     mask>>=1;
    } while(c>=NT);
   }
   fillbuf((int)(pt_len[c]));
   if(c<=2)
   {
    if(c==0)
     c=1;
    else if(c==1)
     c=getbits(4)+3;
    else
     c=getbits(CBIT)+20;
    while(--c>=0)
     c_len[i++]=0;
   }
   else
    c_len[i++]=(unsigned char)(c-2);
  }
  while(i<NC)
   c_len[i++]=0;
  make_table(NC, c_len, 12, c_table, sizeof(c_table));
 }
}

/* Decodes a single character */

static unsigned short decode_c()
{
 unsigned short j, mask;

 if(blocksize==0)
 {
  blocksize=getbits(16);
  read_pt_len(NT, TBIT, 3);
  read_c_len();
  read_pt_len(NP, PBIT, -1);
 }
 blocksize--;
 j=c_table[bitbuf>>4];
 if(j>=NC)
 {
  mask=1<<3;
  do
  {
   j=(bitbuf&mask)?right[j]:left[j];
   mask>>=1;
  } while(j>=NC);
 }
 fillbuf((int)(c_len[j]));
 return(j);
}

/* Decodes a pointer to already decoded data */

static unsigned short decode_p()
{
 unsigned short j, mask;

 j=pt_table[bitbuf>>8];
 if(j>=NP)
 {
  mask=1<<7;
  do
  {
   j=(bitbuf&mask)?right[j]:left[j];
   mask>>=1;
  } while(j>=NP);
 }
 fillbuf((int)(pt_len[j]));
 if(j!=0)
 {
  j--;
  j=(1<<j)+getbits((int)j);
 }
 return(j);
}

/* Initiates the decoding */

static void decode_start()
{
 blocksize=0;
 init_getbits();
}

/* Decodes the entire file */

static void decode()
{
 short i;
 short r;
 short c;
 static short j;
 unsigned long count;

 decode_start();
 count=origsize;
 r=0;
 while(count>0L)
 {
  if((c=decode_c())<=UCHAR_MAX)
  {
   dec_text[r]=(unsigned char)c;
   count--;
   if(++r>=DICSIZ)
   {
    r=0;
    sfxjr_puts(M_SFXJR_TICKER);
    fwrite_crc(dec_text, DICSIZ);
   }
  }
  else
  {
   j=c-(UCHAR_MAX+1-THRESHOLD);
   count-=(unsigned long)j;
   i=r-decode_p()-1;
   if(i<0)
    i+=DICSIZ;
   if(r>i&&r<DICSIZ-MAXMATCH-1)
   {
    while(--j>=0)
     dec_text[r++]=dec_text[i++];
   }
   else
   {
    while(--j>=0)
    {
     dec_text[r]=dec_text[i];
     if(++r>=DICSIZ)
     {
      r=0;
      sfxjr_puts(M_SFXJR_TICKER);
      fwrite_crc(dec_text, DICSIZ);
     }
     if(++i>=DICSIZ)
      i=0;
    }
   }
  }
 }
 if(r>0)
  fwrite_crc(dec_text, r);
}