mimedecode.c

一个UTF的源代码,可以提供参考

	      {
		/* *retp++ = c; */
		if (action == DECODE)
		  PUTC_IN_UTF8 (c);
		if (!(c == ' ' || c == '\t' || c == '('))
		  state = HUNT;
		continue;
	      }

	    if (state == CHARS)
	      {
		if (charp - charset_name < 79)
		  *charp++ = c;
		else
		  {
		  it_is_not_charset_name:
		    if (action == DECODE)
		      {
			*charp = '\0';
			charset_name_length = charp - charset_name;
			Output_consumed_chars (space_between_enc_words, charset_name, charset_name_length, NULL);
		      }
		    charp = charset_name;
		    state = HUNT;
		  }
		continue;
	      }

	    if (state == ENCD)
	      {
		if (encp - encoding < max_encoding_length)
		  *encp++ = c;
		else
		  {
		    if (action == DECODE)
		      {
			*encp = '\0';
			Output_consumed_chars (space_between_enc_words, charset_name, charset_name_length, encoding);
		      }
		    charp = charset_name;
		    encp = encoding;
		    state = HUNT;
		  }
		continue;
	      }

	    if ((state == Q_FIELD) && (c == '_'))
	      {
		/* *retp++ = ' '; */
		PUTC_IN_UTF8 (' ');
		continue;
	      }

	    if (state == DEC1)
	      {
		if (isxdigit (c))
		  {
		    c1 = c;
		    c = toupper (c1);
		    b1 = binhex (c);
		    state = DEC2;
		    continue;
		  }
		else
		  {
		    /* *retp++ = '='; */
		    PUTC_IN_UTF8 ('=');
		    state = Q_FIELD;
		  }
		break;
	      }

	    if (state == DEC2)
	      {
		if (isxdigit (c))
		  {
		    c2 = toupper (c);
		    b2 = binhex (c2);
		    c = b1 << 4 | b2;
		    /* *retp++ = c; */
		    PUTC_IN_UTF8 (c);
		    state = Q_FIELD;
		    continue;
		  }
		else
		  {
		    /* *retp++ = c1; */
		    PUTC_IN_UTF8 (c1);
		    state = Q_FIELD;
		  }
		break;
	      }

	    if (state == END)
	      {
		fprintf (stderr, "END reached");
		state = HUNT;
	      }
	  }
	  break;
	}
      /* *retp++ = c; */
      if (action == DECODE)
	PUTC_IN_UTF8 (c);
    }

  if (state == CHARS)
    {
      *charp = '\0';
      charset_name_length = charp - charset_name;
      Output_consumed_chars (space_between_enc_words, charset_name, charset_name_length, NULL);
    }
  else if (state == ENCD)
    {
      *encp = '\0';
      encp = encoding;

      if (action == DECODE)
	{
	  *encp = '\0';
	  Output_consumed_chars (space_between_enc_words, charset_name, charset_name_length, encoding);
	}
    }
  /* *retp++ = c; *//* remember the '\0' terminator */
  if (action == QUERY_CHARSET_NAME)
    return (NULL);
  /*FLUSH_OUTPUT(charset_p);*/
  return (rendered_charset_name);
}



/*******************************************************************/
void
print_state (state)
/*******************************************************************/
     int state;
{
  switch (state)
    {
    case HUNT:
      fprintf (stderr, " state HUNT");
      break;

    case START:
      fprintf (stderr, " state START");
      break;

    case CHARS:
      fprintf (stderr, " state CHARS");
      break;

    case ENCD:
      fprintf (stderr, " state ENCD");
      break;

    case Q_FIELD:
      fprintf (stderr, " state Q_FIELD");
      break;

    case B_FIELD:
      fprintf (stderr, " state B_FIELD");
      break;

    case DEC1:
      fprintf (stderr, " state DEC1");
      break;

    case DEC2:
      fprintf (stderr, " state DEC2");
      break;

    case END:
      fprintf (stderr, " state END");
      break;

    default:
      fprintf (stderr, " unknown state; %d", state);
      break;
    }
}



/******************************************************************* 
int
casncmp (s1, s2, n)
 ******************************************************************* 
     register const char *s1, *s2;
     register n;
{
  if (s1 == s2)
    return (0);
  while ((--n >= 0) && (lower (*s1) == lower (*s2)))
    {
      s2++;
      if (*s1++ == '\0')
	return (0);
    }
  return ((n < 0) ? 0 : (lower (*s1) - lower (*s2)));
}
*/


/*******************************************************************/
int
decode_quoted_printable (infp, outfp, boundary)
/*******************************************************************/
     FILE *infp;
     FILE *outfp;
     char *boundary;
{
  unsigned char *lbp = line.buf;
  int c, length, ret;

  if (Debug)
    fprintf (stderr, " --- Entry decode_quoted_print --- \n");
  if (boundary && (Debug >= 2))
    fprintf (stderr, " --- with boundary: %s\n", boundary);

  while ((length = Getline (&line.buf, &line.length, infp)) != -1)
/*  while ((c = getc (infp)) != EOF) */
    {
      lbp = line.buf;

      if (boundary && (line.buf[0] == '-') && (line.buf[1] == '-'))
	{
	  if ((ret = Str_is_boundary (line.buf+2, boundary, FALSE)))
	    {
	      if (ret < OUTER_BOUNDARY) {
		EMPTY_BUFFERS(charset_p);
		fputs (line.buf, outfp);
	      }
	      return (ret);
	    }
	}

      while (lbp - line.buf < length)
	{
	  if ((c = *lbp++) == '=')
	    {			/* c == '=' */
	      int c1 = *lbp++;
	      int c2;

	      if (!(lbp - line.buf < length))
		/*        if (c1 == '\0') */
		break;

	      c2 = *lbp++;
	      /*        if (c2 == '\0')
	         break; */


	      /* check for soft CRLF */
	      if (c1 == '\r')
		{
		  /* this is an error? : c2 = getc(infp); */
		  if (c2 != '\n')	/* not a CRLF */
		    lbp--;	/* put back the char after the =<CR> */
		  continue;
		}

	      /* check for soft newline */
	      if (c1 == '\n')
		{
		  lbp--;	/* put back the char after the newline */
		  continue;
		}

	      /* check for == -> = */
	      if (c1 == '=')
		{
		  putc (c1, outfp);
		  lbp--;	/* put back the char after the == */
		  continue;
		}

	      /* make sure it's =XX */
	      if (!isxdigit (c1) || !isxdigit (c2))
		continue;

	      /* we have two hex digits, so decode them */
	      if (isdigit (c1))
		c1 -= '0';
	      else if (islower (c1))
		{
		  c1 -= 'a';
		  c1 += 10;
		}
	      else
		{
		  c1 -= 'A';
		  c1 += 10;
		}
	      if (isdigit (c2))
		c2 -= '0';
	      else if (islower (c2))
		{
		  c2 -= 'a';
		  c2 += 10;
		}
	      else
		{
		  c2 -= 'A';
		  c2 += 10;
		}
	      PUTC_IN_UTF8 (((c1 << 4) | c2));
	    }
	  else
	    PUTC_IN_UTF8 (c);
	    /* putc (c, outfp); */
	}			/* end while */
      lbp = line.buf;
    }
  /* FLUSH_OUTPUT(charset_p); */
  return (boundary ? FALSE : END_BOUNDARY);
}





/*******************************************************************/
int
nextgetc (infp)
/*******************************************************************/
     FILE *infp;
{
  int c;

  while ((c = getc (infp)) != EOF)
    {
      if (c == '-')
	{
	  c = getc (infp);
	  if (c == '-')
	    {
	      /* Two '-'s in a row - must be a boundary! */
	      if (Debug >= 2)
		fprintf (stderr, " ----- boundary line prefix found\n");
	      return (127);
	    }
	}

      if (b64_map[c] != UN)
	break;
    }
  return c;
}



/*******************************************************************/
int
decode_base64 (infp, outfp, boundary)
/*******************************************************************/
     FILE *infp;
     FILE *outfp;
     char *boundary;
{
  int c1, c2, c3, c4;
  int ret;
  ssize_t length;

  c1 = c2 = c3 = c4 = 0;

  if (Debug)
    fprintf (stderr, " --- Entry decode_base64 --- \n");

  for (;;)
    {
      ret = 0;

      if (((c1 = nextgetc (infp)) == 127)
	  || ((c2 = nextgetc (infp)) == 127)
	  || ((c3 = nextgetc (infp)) == 127)
	  || ((c4 = nextgetc (infp)) == 127))
	{
	  if (Debug >= 2)
	    fprintf (stderr, " --- boundary line prefix found: %d\n", ret);
	  EMPTY_BUFFERS(charset_p);
	  putc ('\n', outfp);/*7*/
	  putc ('-', outfp);
	  putc ('-', outfp);
	  if (!boundary || -1 == (length = Getline (&line.buf, &line.length, infp)))
	    return (FALSE);
	  if ((ret = Str_is_boundary (line.buf, boundary, FALSE)))
	    {
	      if (ret < OUTER_BOUNDARY)
		fprintf (outfp, "%s", line.buf);
	      return (ret);
	    }
	  return (Seek_boundary (infp, boundary, FALSE));
	}

      if ((c1 == '=') || (c2 == '=') || (c1 == EOF) || (c2 == EOF))
	{
	  break;
	}

      PUTC_IN_UTF8 ((((unsigned int) b64_map[c1] << 2) | (((unsigned int) b64_map[c2] & 0x30) >> 4)));
      if ((c3 == '=') || (c3 == EOF))
	{
	  break;
	}

      PUTC_IN_UTF8 (((((unsigned int) b64_map[c2] & 0XF) << 4) | (((unsigned int) b64_map[c3] & 0x3C) >> 2)));

      if ((c4 == '=') || (c4 == EOF))
	{
	  break;
	}

      PUTC_IN_UTF8 (((((unsigned int) b64_map[c3] & 0x03) << 6) | (unsigned int) b64_map[c4]));
    }
  if (Debug >= 2)
    fprintf (stderr, " --- end of base64 \n");
  EMPTY_BUFFERS(charset_p);
  putc ('\n', outfp);/*7*/
  if (boundary)
    return (Seek_boundary (infp, boundary, 0));
  else
    while ((getc (infp)) != EOF);
/*      putc (c, outfp); */
  return (END_BOUNDARY);
}



/*******************************************************************/
void
write_cte (headers_buffer_p, transfer_encoding, content_type)
/*******************************************************************/
     struct buffer_type *headers_buffer_p;
     int transfer_encoding, content_type;
{
  if (content_type == TEXT)
    {
      switch (transfer_encoding)
	{
	case QP:
	  Add_to_buffer (headers_buffer_p, "X-2UTF-Content-transfer-encoding: fixed from quoted-printable\n");
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: 8bit\n");
	  break;

	case B64:
	  Add_to_buffer (headers_buffer_p, "X-2UTF-Content-transfer-encoding: fixed from base64\n");
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: 8bit\n");
	  break;

	case BIT7:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: 7bit\n");
	  break;

	case BIT8:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: 8bit\n");
	  break;

	case BINARY:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: binary\n");
	  break;

	default:
	  if (Debug >= 3)
	    fprintf (stderr, "Transfer-encoding is UNKNOWN\n");
	  break;
	}
    }
  else
    /* ! TEXT */
    {
      /* remember to output the Content-transfer-encoding
       * header field in case type is NOT text.
       */
      switch (transfer_encoding)
	{
	case QP:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: quoted-printable\n");
	  break;

	case B64:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: base64\n");
	  break;

	case BIT7:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: 7bit\n");
	  break;

	case BIT8:
	  Add_to_buffer (headers_buffer_p, "Content-Transfer-Encoding: 8bit\n");
	  break;
	}
    }
  headers_buffer_p->header_start = headers_buffer_p->next;
}