uucheck.c

来自「UUDeview是一个编码解码器」· C语言 代码 · 共 1,469 行 · 第 1/3 页

   *     (a) Not both parts have a begin line
   *     (b) Not both parts have an end line
   *     (c) Both parts don't have different MIME-IDs
   *     (d) Both parts don't encode different files
   *     (e) The other part wants to stay alone (FL_SINGLE)
   */

  /*
   * check if this part wants to be left alone. If so, don't bother
   * to do all the checks
   */

  while (iter) {
    if (data->data->flags & FL_SINGLE) {
      /* this space intentionally left blank */
    }
    else if ((data->mimeid && iter->mimeid &&
	      strcmp (data->mimeid, iter->mimeid) == 0) ||
	     (_FP_stricmp (data->subfname, iter->subfname) == 0 &&
	      !(iter->begin && data->data->begin) &&
	      !(iter->end   && data->data->end) &&
	      !(data->mimeid && iter->mimeid &&
		strcmp (data->mimeid, iter->mimeid) != 0) &&
	      !(data->filename && iter->filename &&
		strcmp (data->filename, iter->filename) != 0) &&
	      !(iter->flags & FL_SINGLE))) {

      /*
       * Don't insert a part that is already there.
       *
       * Also don't add a part beyond the "end" marker (unless we
       * have a mimeid, which screws up the marker).
       */

      for (fiter=iter->thisfile; fiter; fiter=fiter->NEXT) {
	if (data->partno == fiter->partno)
	  goto goahead;
	if (!iter->mimeid) {
	  if (data->partno > fiter->partno && fiter->data->end) {
	    goto goahead;
	  }
	}
      }

      if (iter->filename == NULL && data->filename != NULL) {
        if ((iter->filename = _FP_strdup (data->filename)) == NULL)
	  return UURET_NOMEM;
      }

      /*
       * special case when we might have tagged a part as Base64 when the
       * file was really XX
       */

      if (data->data->uudet == B64ENCODED && 
	  iter->uudet == XX_ENCODED && iter->begin) {
	data->data->uudet = XX_ENCODED;
      }
      else if (data->data->uudet == XX_ENCODED && data->data->begin &&
	       iter->uudet == B64ENCODED) {
	iter->uudet = XX_ENCODED;

	fiter = iter->thisfile;
	while (fiter) {
	  fiter->data->uudet = XX_ENCODED;
	  fiter = fiter->NEXT;
	}
      }

      /*
       * If this is from a Message/Partial, we believe only the
       * iter->uudet from the first part
       */
      if (data->data->flags & FL_PARTIAL) {
	if (data->partno == 1) {
	  iter->uudet = data->data->uudet;
	  iter->flags = data->data->flags;
	}
      }
      else {
	if (data->data->uudet) iter->uudet = data->data->uudet;
	if (data->data->flags) iter->flags = data->data->flags;
      }

      if (iter->mode == 0 && data->data->mode != 0)
        iter->mode = data->data->mode;
      if (data->data->begin) iter->begin = (data->partno)?data->partno:1;
      if (data->data->end)   iter->end   = (data->partno)?data->partno:1;

      if (data->mimetype) {
	_FP_free (iter->mimetype);
	iter->mimetype = _FP_strdup (data->mimetype);
      }

      /*
       * insert part at the beginning
       */

      if (data->partno != -1 && data->partno < iter->thisfile->partno) {
	iter->state    = UUFILE_READ;
	data->NEXT     = iter->thisfile;
	iter->thisfile = data;
	return UURET_OK;
      }

      /*
       * insert part somewhere else
       */

      iter->state = UUFILE_READ;	/* prepare for re-checking */
      fiter       = iter->thisfile;
      last        = NULL;

      while (fiter) {
	/*
	 * if we find the same part no again, check which one looks better
	 */
	if (data->partno == fiter->partno) {
          if (fiter->data->subject == NULL)
            return UURET_NODATA;
	  else if (_FP_stristr (fiter->data->subject, "repost") != NULL &&
		   _FP_stristr (data->data->subject,  "repost") == NULL)
	    return UURET_NODATA;
          else if (fiter->data->uudet && !data->data->uudet)
            return UURET_NODATA;
          else {
	    /*
	     * replace
	     */
            data->NEXT  = fiter->NEXT;
            fiter->NEXT = NULL;
            UUkillfile (fiter);

            if (last == NULL)
              iter->thisfile = data;
            else
              last->NEXT     = data;

            return UURET_OK;
          }
        }

	/*
	 * if at the end of the part list, add it
	 */

	if (fiter->NEXT == NULL || 
	    (data->partno != -1 && data->partno < fiter->NEXT->partno)) {
	  data->NEXT  = fiter->NEXT;
	  fiter->NEXT = data;

	  if (data->partno == -1)
	    data->partno = fiter->partno + 1;

	  return UURET_OK;
	}
        last  = fiter;
	fiter = fiter->NEXT;
      }
      
      return UURET_OK; /* Shouldn't get here */
    }
  goahead:
    /*
     * we need iter below
     */
    if (iter->NEXT == NULL) 
      break;

    iter = iter->NEXT;
  }
  /*
   * handle new entry
   */

  if (data->partno == -1) {
    /*
     * if it's got no part no, and it's MIME mail, then assume this is
     * part no. 1. If it's not MIME, then we can't handle it; if it
     * had a 'begin', it'd have got a part number assigned by
     * UUPreProcessPart().
     */
    if (data->data->uudet == B64ENCODED || data->data->uudet == BH_ENCODED)
      data->partno = 1;
    else
      return UURET_NODATA;
  }

  if ((unew = (uulist *) malloc (sizeof (uulist))) == NULL) {
    return UURET_NOMEM;
  }

  if ((unew->subfname = _FP_strdup (data->subfname)) == NULL) {
    _FP_free (unew);
    return UURET_NOMEM;
  }

  if (data->filename != NULL) {
    if ((unew->filename = _FP_strdup (data->filename)) == NULL) {
      _FP_free (unew->subfname);
      _FP_free (unew);
      return UURET_NOMEM;
    }
  }
  else
    unew->filename = NULL;

  if (data->mimeid != NULL) {
    if ((unew->mimeid = _FP_strdup (data->mimeid)) == NULL) {
      _FP_free (unew->subfname);
      _FP_free (unew->filename);
      _FP_free (unew);
      return UURET_NOMEM;
    }
  }
  else
    unew->mimeid = NULL;

  if (data->mimetype != NULL) {
    if ((unew->mimetype = _FP_strdup (data->mimetype)) == NULL) {
      _FP_free (unew->mimeid);
      _FP_free (unew->subfname);
      _FP_free (unew->filename);
      _FP_free (unew);
      return UURET_NOMEM;
    }
  }
  else
    unew->mimetype = NULL;

  unew->state     = UUFILE_READ;
  unew->binfile   = NULL;
  unew->thisfile  = data;
  unew->mode      = data->data->mode;
  unew->uudet     = data->data->uudet;
  unew->flags     = data->data->flags;
  unew->begin     = (data->data->begin) ? ((data->partno)?data->partno:1) : 0;
  unew->end       = (data->data->end)   ? ((data->partno)?data->partno:1) : 0;
  unew->misparts  = NULL;
  unew->haveparts = NULL;
  unew->NEXT      = NULL;

  if (iter == NULL)
    UUGlobalFileList = unew;
  else
    iter->NEXT = unew;

  return UURET_OK;
}

/*
 * At this point, all files are read in and stored in the
 * "UUGlobalFileList". Do some checking. All parts there?
 **/

uulist *
UUCheckGlobalList (void)
{
  int misparts[MAXPLIST], haveparts[MAXPLIST];
  int miscount, havecount, count, flag, part;
  uulist *liter=UUGlobalFileList, *prev;
  uufile *fiter;
  long thesize;

  while (liter) {
    miscount = 0;
    thesize  = 0;

    if (liter->state & UUFILE_OK) {
      liter = liter->NEXT;
      continue;
    }
    else if ((liter->uudet == QP_ENCODED ||
	      liter->uudet == PT_ENCODED) && 
	     (liter->flags & FL_SINGLE)) {
      if ((liter->flags&FL_PROPER)==0)
	liter->size = -1;
      else
	liter->size = liter->thisfile->data->length;

      liter->state = UUFILE_OK;
      continue;
    }
    else if ((fiter = liter->thisfile) == NULL) {
      liter->state = UUFILE_NODATA;
      liter = liter->NEXT;
      continue;
    }

    /*
     * Re-Check this file
     */

    flag      = 0;
    miscount  = 0;
    havecount = 0;
    thesize   = 0;
    liter->state = UUFILE_READ;

    /*
     * search encoded data
     */

    while (fiter && !fiter->data->uudet) {
      if (havecount<MAXPLIST) {
	haveparts[havecount++] = fiter->partno;
      }
      fiter = fiter->NEXT;
    }

    if (fiter == NULL) {
      liter->state = UUFILE_NODATA;
      liter = liter->NEXT;
      continue;
    }

    if (havecount<MAXPLIST) {
      haveparts[havecount++] = fiter->partno;
    }

    if ((part = fiter->partno) > 1) {
      if (!fiter->data->begin) {
	for (count=1; count < part && miscount < MAXPLIST; count++)
	  misparts[miscount++] = count;
      }
    }

    /*
     * don't care if so many parts are missing
     */

    if (miscount >= MAXPLIST) {
      liter->state = UUFILE_MISPART;
      liter        = liter->NEXT;
      continue;
    }

    if (liter->uudet == B64ENCODED ||
	liter->uudet == QP_ENCODED ||
	liter->uudet == PT_ENCODED)
      flag |= 3; /* Don't need begin or end with Base64 or plain text*/

    if (fiter->data->begin) flag |= 1;
    if (fiter->data->end)   flag |= 2;
    if (fiter->data->uudet) flag |= 4; 

    /*
     * guess size of part
     */

    switch (fiter->data->uudet) {
    case UU_ENCODED:
    case XX_ENCODED:
      thesize += 3*fiter->data->length/4;
      thesize -= 3*fiter->data->length/124; /* substract 2 of 62 chars */
      break;
    case B64ENCODED:
      thesize += 3*fiter->data->length/4;
      thesize -=  fiter->data->length/52;   /* substract 2 of 78 chars */
      break;
    case QP_ENCODED:
    case PT_ENCODED:
      thesize += fiter->data->length;
      break;
    }
      
    fiter = fiter->NEXT;

    while (fiter != NULL) {
      for (count=part+1; count<fiter->partno && miscount<MAXPLIST; count++)
	misparts[miscount++] = count;

      part = fiter->partno;
      
      if (havecount<MAXPLIST)
	haveparts[havecount++]=part;

      if (fiter->data->begin) flag |= 1;
      if (fiter->data->end)   flag |= 2;
      if (fiter->data->uudet) flag |= 4;

      switch (fiter->data->uudet) {
      case UU_ENCODED:
      case XX_ENCODED:
	thesize += 3*fiter->data->length/4;
	thesize -= 3*fiter->data->length/124; /* substract 2 of 62 chars */
	break;
      case B64ENCODED:
	thesize += 3*fiter->data->length/4;
	thesize -=  fiter->data->length/52;   /* substract 2 of 78 chars */
	break;
      case QP_ENCODED:
      case PT_ENCODED:
	thesize += fiter->data->length;
	break;
      }

      if (fiter->data->end)
	break;
	
      fiter = fiter->NEXT;
    }

    /*
     * if in fast mode, we don't notice an 'end'. So if its uu or xx
     * encoded, there's a begin line and encoded data, assume it's
     * there.
     */
    
    if (uu_fast_scanning && (flag & 0x01) && (flag & 0x04) &&
	(liter->uudet == UU_ENCODED || liter->uudet == XX_ENCODED))
      flag |= 2;

    /*
     * Set the parts we have and/or missing
     */

    _FP_free (liter->haveparts);
    _FP_free (liter->misparts);

    liter->haveparts = NULL;
    liter->misparts  = NULL;
    
    if (havecount) {
      if ((liter->haveparts=(int*)malloc((havecount+1)*sizeof(int)))!=NULL) {
	memcpy (liter->haveparts, haveparts, havecount*sizeof(int));
	liter->haveparts[havecount] = 0;
      }
    }
    
    if (miscount) {
      if ((liter->misparts=(int*)malloc((miscount+1)*sizeof(int)))!=NULL) {
	memcpy (liter->misparts, misparts, miscount*sizeof(int));
	liter->misparts[miscount] = 0;
      }
      liter->state |= UUFILE_MISPART;
    }

    /*
     * Finalize checking
     */

    if ((flag & 4) == 0) liter->state |= UUFILE_NODATA;
    if ((flag & 1) == 0) liter->state |= UUFILE_NOBEGIN;
    if ((flag & 2) == 0) liter->state |= UUFILE_NOEND;
    
    if ((flag & 7) == 7 && miscount==0) {
      liter->state = UUFILE_OK;
    }

    if ((uu_fast_scanning && (liter->flags&FL_PROPER)==0) || thesize<=0)
      liter->size = -1;
    else
      liter->size = thesize;

    if (liter->state==UUFILE_OK && 
        (liter->filename==NULL || liter->filename[0]=='\0')) {
      /*
       * Emergency backup if the file does not have a filename
       */
      _FP_free (liter->filename);
      if (liter->subfname && liter->subfname[0] &&
          _FP_strpbrk (liter->subfname, "()[];: ") == NULL)
        liter->filename = _FP_strdup (liter->subfname);
      else {
        sprintf (uucheck_tempname, "%s.%03d", nofname, ++nofnum);
        liter->filename = _FP_strdup (uucheck_tempname);
      }
    }
    liter = liter->NEXT;
  }

  /*
   * Sets back (PREV) links
   */

  liter = UUGlobalFileList;
  prev  = NULL;

  while (liter) {
    liter->PREV = prev;
    prev        = liter;
    liter       = liter->NEXT;
  }

  return UUGlobalFileList;
}