utf8.c

来自「支持SSL v2/v3, TLS, PKCS #5, PKCS #7, PKCS」· C语言 代码 · 共 2,062 行 · 第 1/5 页

    }

    result = sec_port_ucs4_utf8_conversion_function(PR_TRUE,
      utf8, len, (unsigned char *)&back32, sizeof(back32), &len);

    if( 4 != len ) {
      fprintf(stdout, "Failed to convert UTF-16 0x%04.4x 0x%04.4x to UTF-8: "
              "unexpected len %d\n", e->w[0], e->w[1], len);
      rv = PR_FALSE;
      continue;
    }

    utf8[len] = '\0'; /* null-terminate for printing */

    if( !result ) {
      dump_utf8("Failed to convert UTF-8", utf8, "to UCS-4 (utf-16 test)\n");
      rv = PR_FALSE;
      continue;
    }

    if( (sizeof(back32) != len) || (e->c != back32) ) {
      fprintf(stdout, "Wrong conversion of UTF-16 0x%04.4x 0x%04.4x ", 
              e->w[0], e->w[1]);
      dump_utf8("to UTF-8", utf8, "and then to UCS-4: ");
      if( sizeof(back32) != len ) {
        fprintf(stdout, "len is %d\n", len);
      } else {
        fprintf(stdout, "expected 0x%08.8x, received 0x%08.8x\n", e->c, back32);
      }
      rv = PR_FALSE;
      continue;
    }

    (void)memset(utf8, 0, sizeof(utf8));
    back[0] = back[1] = 0;

    result = sec_port_ucs4_utf8_conversion_function(PR_FALSE,
      (unsigned char *)&e->c, sizeof(e->c), utf8, sizeof(utf8), &len);

    if( !result ) {
      fprintf(stdout, "Failed to convert UCS-4 0x%08.8x to UTF-8 (utf-16 test)\n",
              e->c);
      rv = PR_FALSE;
      continue;
    }

    result = sec_port_ucs2_utf8_conversion_function(PR_TRUE,
      utf8, len, (unsigned char *)&back[0], sizeof(back), &len);

    if( 4 != len ) {
      fprintf(stdout, "Failed to convert UCS-4 0x%08.8x to UTF-8: "
              "unexpected len %d\n", e->c, len);
      rv = PR_FALSE;
      continue;
    }

    utf8[len] = '\0'; /* null-terminate for printing */

    if( !result ) {
      dump_utf8("Failed to convert UTF-8", utf8, "to UTF-16\n");
      rv = PR_FALSE;
      continue;
    }

    if( (sizeof(back) != len) || (e->w[0] != back[0]) || (e->w[1] != back[1]) ) {
      fprintf(stdout, "Wrong conversion of UCS-4 0x%08.8x to UTF-8", e->c);
      dump_utf8("", utf8, "and then to UTF-16:");
      if( sizeof(back) != len ) {
        fprintf(stdout, "len is %d\n", len);
      } else {
        fprintf(stdout, "expected 0x%04.4x 0x%04.4x, received 0x%04.4x 0x%04.4xx\n",
                e->w[0], e->w[1], back[0], back[1]);
      }
      rv = PR_FALSE;
      continue;
    }
  }

  return rv;
}
#endif /* UTF16 */

static PRBool
test_zeroes
(
  void
)
{
  PRBool rv = PR_TRUE;
  PRBool result;
  PRUint32 lzero = 0;
  PRUint16 szero = 0;
  unsigned char utf8[8];
  unsigned int len = 0;
  PRUint32 lback = 1;
  PRUint16 sback = 1;

  (void)memset(utf8, 1, sizeof(utf8));

  result = sec_port_ucs4_utf8_conversion_function(PR_FALSE, 
    (unsigned char *)&lzero, sizeof(lzero), utf8, sizeof(utf8), &len);

  if( !result ) {
    fprintf(stdout, "Failed to convert UCS-4 0x00000000 to UTF-8\n");
    rv = PR_FALSE;
  } else if( 1 != len ) {
    fprintf(stdout, "Wrong conversion of UCS-4 0x00000000: len = %d\n", len);
    rv = PR_FALSE;
  } else if( '\0' != *utf8 ) {
    fprintf(stdout, "Wrong conversion of UCS-4 0x00000000: expected 00 ,"
            "received %02.2x\n", (unsigned int)*utf8);
    rv = PR_FALSE;
  }

  result = sec_port_ucs4_utf8_conversion_function(PR_TRUE,
    "", 1, (unsigned char *)&lback, sizeof(lback), &len);

  if( !result ) {
    fprintf(stdout, "Failed to convert UTF-8 00 to UCS-4\n");
    rv = PR_FALSE;
  } else if( 4 != len ) {
    fprintf(stdout, "Wrong conversion of UTF-8 00 to UCS-4: len = %d\n", len);
    rv = PR_FALSE;
  } else if( 0 != lback ) {
    fprintf(stdout, "Wrong conversion of UTF-8 00 to UCS-4: "
            "expected 0x00000000, received 0x%08.8x\n", lback);
    rv = PR_FALSE;
  }

  (void)memset(utf8, 1, sizeof(utf8));

  result = sec_port_ucs2_utf8_conversion_function(PR_FALSE, 
    (unsigned char *)&szero, sizeof(szero), utf8, sizeof(utf8), &len);

  if( !result ) {
    fprintf(stdout, "Failed to convert UCS-2 0x0000 to UTF-8\n");
    rv = PR_FALSE;
  } else if( 1 != len ) {
    fprintf(stdout, "Wrong conversion of UCS-2 0x0000: len = %d\n", len);
    rv = PR_FALSE;
  } else if( '\0' != *utf8 ) {
    fprintf(stdout, "Wrong conversion of UCS-2 0x0000: expected 00 ,"
            "received %02.2x\n", (unsigned int)*utf8);
    rv = PR_FALSE;
  }

  result = sec_port_ucs2_utf8_conversion_function(PR_TRUE,
    "", 1, (unsigned char *)&sback, sizeof(sback), &len);

  if( !result ) {
    fprintf(stdout, "Failed to convert UTF-8 00 to UCS-2\n");
    rv = PR_FALSE;
  } else if( 2 != len ) {
    fprintf(stdout, "Wrong conversion of UTF-8 00 to UCS-2: len = %d\n", len);
    rv = PR_FALSE;
  } else if( 0 != sback ) {
    fprintf(stdout, "Wrong conversion of UTF-8 00 to UCS-2: "
            "expected 0x0000, received 0x%04.4x\n", sback);
    rv = PR_FALSE;
  }

  return rv;
}

static PRBool
test_multichars
(
  void
)
{
  int i;
  unsigned int len, lenout;
  PRUint32 *ucs4s;
  char *ucs4_utf8;
  PRUint16 *ucs2s;
  char *ucs2_utf8;
  void *tmp;
  PRBool result;

  ucs4s = (PRUint32 *)calloc(sizeof(ucs4)/sizeof(ucs4[0]), sizeof(PRUint32));
  ucs2s = (PRUint16 *)calloc(sizeof(ucs2)/sizeof(ucs2[0]), sizeof(PRUint16));

  if( ((PRUint32 *)NULL == ucs4s) || ((PRUint16 *)NULL == ucs2s) ) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  len = 0;
  for( i = 0; i < sizeof(ucs4)/sizeof(ucs4[0]); i++ ) {
    ucs4s[i] = ucs4[i].c;
    len += strlen(ucs4[i].utf8);
  }

  ucs4_utf8 = (char *)malloc(len);

  len = 0;
  for( i = 0; i < sizeof(ucs2)/sizeof(ucs2[0]); i++ ) {
    ucs2s[i] = ucs2[i].c;
    len += strlen(ucs2[i].utf8);
  }

  ucs2_utf8 = (char *)malloc(len);

  if( ((char *)NULL == ucs4_utf8) || ((char *)NULL == ucs2_utf8) ) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  *ucs4_utf8 = '\0';
  for( i = 0; i < sizeof(ucs4)/sizeof(ucs4[0]); i++ ) {
    strcat(ucs4_utf8, ucs4[i].utf8);
  }

  *ucs2_utf8 = '\0';
  for( i = 0; i < sizeof(ucs2)/sizeof(ucs2[0]); i++ ) {
    strcat(ucs2_utf8, ucs2[i].utf8);
  }

  /* UTF-8 -> UCS-4 */
  len = sizeof(ucs4)/sizeof(ucs4[0]) * sizeof(PRUint32);
  tmp = calloc(len, 1);
  if( (void *)NULL == tmp ) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  result = sec_port_ucs4_utf8_conversion_function(PR_TRUE,
    ucs4_utf8, strlen(ucs4_utf8), tmp, len, &lenout);
  if( !result ) {
    fprintf(stdout, "Failed to convert much UTF-8 to UCS-4\n");
    goto done;
  }

  if( lenout != len ) {
    fprintf(stdout, "Unexpected length converting much UTF-8 to UCS-4\n");
    goto loser;
  }

  if( 0 != memcmp(ucs4s, tmp, len) ) {
    fprintf(stdout, "Wrong conversion of much UTF-8 to UCS-4\n");
    goto loser;
  }

  free(tmp); tmp = (void *)NULL;

  /* UCS-4 -> UTF-8 */
  len = strlen(ucs4_utf8);
  tmp = calloc(len, 1);
  if( (void *)NULL == tmp ) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  result = sec_port_ucs4_utf8_conversion_function(PR_FALSE,
    (unsigned char *)ucs4s, sizeof(ucs4)/sizeof(ucs4[0]) * sizeof(PRUint32), 
    tmp, len, &lenout);
  if( !result ) {
    fprintf(stdout, "Failed to convert much UCS-4 to UTF-8\n");
    goto done;
  }

  if( lenout != len ) {
    fprintf(stdout, "Unexpected length converting much UCS-4 to UTF-8\n");
    goto loser;
  }

  if( 0 != strncmp(ucs4_utf8, tmp, len) ) {
    fprintf(stdout, "Wrong conversion of much UCS-4 to UTF-8\n");
    goto loser;
  }

  free(tmp); tmp = (void *)NULL;

  /* UTF-8 -> UCS-2 */
  len = sizeof(ucs2)/sizeof(ucs2[0]) * sizeof(PRUint16);
  tmp = calloc(len, 1);
  if( (void *)NULL == tmp ) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  result = sec_port_ucs2_utf8_conversion_function(PR_TRUE,
    ucs2_utf8, strlen(ucs2_utf8), tmp, len, &lenout);
  if( !result ) {
    fprintf(stdout, "Failed to convert much UTF-8 to UCS-2\n");
    goto done;
  }

  if( lenout != len ) {
    fprintf(stdout, "Unexpected length converting much UTF-8 to UCS-2\n");
    goto loser;
  }

  if( 0 != memcmp(ucs2s, tmp, len) ) {
    fprintf(stdout, "Wrong conversion of much UTF-8 to UCS-2\n");
    goto loser;
  }

  free(tmp); tmp = (void *)NULL;

  /* UCS-2 -> UTF-8 */
  len = strlen(ucs2_utf8);
  tmp = calloc(len, 1);
  if( (void *)NULL == tmp ) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  result = sec_port_ucs2_utf8_conversion_function(PR_FALSE,
    (unsigned char *)ucs2s, sizeof(ucs2)/sizeof(ucs2[0]) * sizeof(PRUint16), 
    tmp, len, &lenout);
  if( !result ) {
    fprintf(stdout, "Failed to convert much UCS-2 to UTF-8\n");
    goto done;
  }

  if( lenout != len ) {
    fprintf(stdout, "Unexpected length converting much UCS-2 to UTF-8\n");
    goto loser;
  }

  if( 0 != strncmp(ucs2_utf8, tmp, len) ) {
    fprintf(stdout, "Wrong conversion of much UCS-2 to UTF-8\n");
    goto loser;
  }

#ifdef UTF16
  /* implement me */
#endif /* UTF16 */

  result = PR_TRUE;
  goto done;

 loser:
  result = PR_FALSE;
 done:
  free(ucs4s);
  free(ucs4_utf8);
  free(ucs2s);
  free(ucs2_utf8);
  if( (void *)NULL != tmp ) free(tmp);
  return result;
}

void
byte_order
(
  void
)
{
  /*
   * The implementation (now) expects the 16- and 32-bit characters
   * to be in network byte order, not host byte order.  Therefore I
   * have to byteswap all those test vectors above.  hton[ls] may be
   * functions, so I have to do this dynamically.  If you want to 
   * use this code to do host byte order conversions, just remove
   * the call in main() to this function.
   */

  int i;

  for( i = 0; i < sizeof(ucs4)/sizeof(ucs4[0]); i++ ) {
    struct ucs4 *e = &ucs4[i];
    e->c = htonl(e->c);
  }

  for( i = 0; i < sizeof(ucs2)/sizeof(ucs2[0]); i++ ) {
    struct ucs2 *e = &ucs2[i];
    e->c = htons(e->c);
  }

#ifdef UTF16
  for( i = 0; i < sizeof(utf16)/sizeof(utf16[0]); i++ ) {
    struct utf16 *e = &utf16[i];
    e->c = htonl(e->c);
    e->w[0] = htons(e->w[0]);
    e->w[1] = htons(e->w[1]);
  }
#endif /* UTF16 */

  return;
}

int
main
(
  int argc,
  char *argv[]
)
{
  byte_order();

  if( test_ucs4_chars() &&
      test_ucs2_chars() &&
#ifdef UTF16
      test_utf16_chars() &&
#endif /* UTF16 */
      test_zeroes() &&
      test_multichars() &&
      PR_TRUE ) {
    fprintf(stderr, "PASS\n");
    return 1;
  } else {
    fprintf(stderr, "FAIL\n");
    return 0;
  }
}

#endif /* TEST_UTF8 */