logging.c

是一个手机功能的模拟程序

                  wtls_log_bulk_cipher_algorithm_to_string (ch->cipher_suites[i]),
                  wtls_log_MAC_algorithm_to_string (ch->cipher_suites[i + 1]));
  wtls_log_msg (2, "\n");

  wtls_log_msg (2, "Compression Methods:");
  for (i = 0; i < ch->num_compression_methods; i++)
    wtls_log_msg (0, " %02x", ch->compression_methods[i]);
  wtls_log_msg (2, "\n");
  wtls_log_msg (2, "Sequence Number Mode: %d\n", ch->seqnum_mode);
  wtls_log_msg (2, "Key Refresh Rate: %d\n", ch->key_refresh_rate);
  wtls_log_msg (1, "]\n");
}

void
wtls_log_server_hello (wtls_server_hello *sh)
{
  INT16 i;

  wtls_log_msg (1, "SERVER HELLO[\n");
  wtls_log_msg (2, "Server Version: %d\n", sh->server_version);
  wtls_log_msg (2, "Random:");
  for (i = 0; i < 16; i++)
    wtls_log_msg (0, " %02x", sh->random[i]);
  wtls_log_msg (0, "\n");
  wtls_log_msg (2, "Session Id:");
  for (i = 0; i < sh->session_id.length; i++)
    wtls_log_msg (0, " %02x", sh->session_id.id[i]);
  wtls_log_msg (0, "\n");
  wtls_log_msg (2, "Client Key Id: %d\n", sh->client_key_id);
  wtls_log_msg (2, "Cipher Suite: <%s, %s>\n",
          wtls_log_bulk_cipher_algorithm_to_string (sh->cipher_suite.bulk_cipher_alg),
          wtls_log_MAC_algorithm_to_string (sh->cipher_suite.mac_alg));
  wtls_log_msg (2, "Compression Method: %d\n", sh->compression_method);
  wtls_log_msg (2, "Sequence number mode: %d\n", sh->seqnum_mode);
  wtls_log_msg (2, "Key Refresh Rate: %d\n", sh->key_refresh_rate);
  wtls_log_msg (1, "]\n");
}

void
wtls_log_server_key_exchange (wtls_server_key_exchange *ske)
{
  wtls_log_msg (1, "SERVER KEY EXCHANGE[\n");
  wtls_log_msg (2, "Parameter index: %d\n",
                ske->parameter_specifier.parameterIndex);
  if (ske->parameter_specifier.parameterIndex == 255) {
    wtls_log_msg (3, "");
    wtls_log_bytevector (ske->parameter_specifier.params,
                         ske->parameter_specifier.paramLen);
  }
  wtls_log_msg (2, "Public key:\n");
#if 0
  wtls_log_bytevector (ske->public_key._u.dh_key.y,
                       ske->public_key._u.dh_key.len);
#endif
  wtls_log_msg (1, "]\n");
}


#ifdef LOG_WTLS_CERT
void
wtls_log_certificate (wtls_certificate_t *cert)
{
  wtls_cert_log_certificate (cert);
}
#endif

void
wtls_log_handshake_msg (wtls_record_t *rec)
{
  wap_cvt_t cvt_obj;

  wap_cvt_init (&cvt_obj, WAP_CVT_DECODE_STATIC, rec->fragment, rec->length);

  switch (rec->fragment[0]) {
  case HANDSHK_HELLO_REQUEST:
    wtls_log_msg (1, "HELLO REQUEST []\n");
    break;

  case HANDSHK_CLIENT_HELLO:
    {
      wtls_client_hello ch;

      wtls_cvt_client_hello (&cvt_obj, &ch);
      wtls_log_client_hello (&ch);
    }
    break;

  case HANDSHK_SERVER_HELLO:
    {
      wtls_server_hello sh;

      wtls_cvt_server_hello (&cvt_obj, &sh);
      wtls_log_server_hello (&sh);
    }
    break;

  case HANDSHK_CERTIFICATE:
#ifdef LOG_WTLS_CERT
    {
      wtls_certificate_t      cert;
      wtls_client_certificate ccert;

      wtls_log_msg (1, "CERTIFICATE [\n");
      wtls_cvt_client_certificate (&cvt_obj, &ccert);
      wap_cvt_init (&cvt_obj, WAP_CVT_DECODE_STATIC, ccert.buf, ccert.buflen);
      if (ccert.buflen > 0) {
        wtls_cvt_certificate (&cvt_obj, &cert);
        wtls_log_certificate (&cert);
      }
      wtls_log_msg (1, "]\n");
    }
#else
    wtls_log_msg (1, "CERTIFICATE [...]\n");
#endif
    break;

  case HANDSHK_SERVER_KEY_EXCHANGE:
    {
      wtls_server_key_exchange ske;

      /* TODO: where do we get the key exchange algorithm from? */
      wtls_cvt_server_key_exchange (&cvt_obj, 0, &ske);
      wtls_log_server_key_exchange (&ske);
    }
    break;

  case HANDSHK_CERTIFICATE_REQUEST:
    wtls_log_msg (1, "CERTIFICATE REQUEST []\n");
    break;

  case HANDSHK_SERVER_HELLO_DONE:
    wtls_log_msg (1, "SERVER HELLO DONE []\n");
    break;

  case HANDSHK_CERTIFICATE_VERIFY:
    wtls_log_msg (1, "CERTIFICATE VERIFY []\n");
    break;

  case HANDSHK_CLIENT_KEY_EXCHANGE:
    wtls_log_msg (1, "CLIENT KEY EXCHANGE []\n");
    break;

  case HANDSHK_FINISHED:
    {
      wtls_finished f;
      int           i;

      wtls_cvt_finished (&cvt_obj, &f);
      wtls_log_msg (1, "FINISHED[\n");
      wtls_log_msg (2, "<");
      for (i = 0; i < 12; i++) {
        wtls_log_msg (0, "%02x ", f.verify_data[i]);
      }
      wtls_log_msg (0, ">\n");
      wtls_log_msg (1, "]\n");
    }
    break;

  default:
    wtls_log_msg (1, "Handshake message type: %d\n", rec->fragment[0]);
    break;
  }
}

void
wtls_log_data (wtls_record_t *rec)
{
  INT16 i;
  INT16 len = rec->length;

  wtls_log_msg (1, "\"");
  for (i = 0; i < len; i++)
    wtls_log_msg (0, "%c", rec->fragment[i]);
  wtls_log_msg (0, "\"\n");
}

void
wtls_log_alert (wtls_record_t *rec)
{
  wtls_log_msg (1, "%s, %s, (%02x%02x%02x%02x)\n",
                wtls_log_alert_level_to_string (rec->fragment[0]),
                wtls_log_alert_desc_to_string (rec->fragment[1]),
                rec->fragment[2], rec->fragment[3],
                rec->fragment[4], rec->fragment[5]);
}

void
wtls_log_record (wtls_record_t *rec, BYTE direction)
{
  wtls_log_msg (0, "RECORD[ %s\n", (direction == LOG_OUTBOUND ? "=>" : "<="));
  wtls_log_msg (1, "%s", wtls_log_content_type_to_string (rec->rec_type));
  if (rec->rec_type & RECTYPE_USE_CS)
    wtls_log_msg (0, " CS");
  if (rec->rec_type & RECTYPE_SEQNUM)
    wtls_log_msg (0, " S(%d)", rec->seqnum);
  if (rec->rec_type & RECTYPE_LENGTH_FIELD)
    wtls_log_msg (0, " L(%d)", rec->length);
  wtls_log_msg (0, "\n");

  switch (rec->rec_type & RECTYPE_CONTENT_TYPE) {
  case CONTENT_TYPE_DATA:
    if (rec->rec_type & RECTYPE_USE_CS)
      wtls_log_msg (1, "<ENCRYPTED DATA...>\n");
    else
      wtls_log_data (rec);
    break;

  case CONTENT_TYPE_ALERT:
    if (rec->rec_type & RECTYPE_USE_CS)
      wtls_log_msg (1, "<ENCRYPTED ALERT...>\n");
    else
      wtls_log_alert (rec);
    break;

  case CONTENT_TYPE_HANDSHAKE:
    if (rec->rec_type & RECTYPE_USE_CS)
      wtls_log_msg (1, "<ENCRYPTED HANDSHAKE MESSAGE...>\n");
    else
      wtls_log_handshake_msg (rec);
    break;
  }
  wtls_log_msg (0, "]\n");
}

void
wtls_log_record_brief (wtls_record_t *rec)
{
  wtls_log_msg (1, "RECORD[ ");
  wtls_log_msg (0, "%s", wtls_log_content_type_to_string (rec->rec_type));
  if (rec->rec_type & RECTYPE_USE_CS)
    wtls_log_msg (0, " CS");
  if (rec->rec_type & RECTYPE_SEQNUM)
    wtls_log_msg (0, " S(%d)", rec->seqnum);
  if (rec->rec_type & RECTYPE_LENGTH_FIELD)
    wtls_log_msg (0, " L(%d)", rec->length);
  wtls_log_msg (0, " ]\n");
}

void
wtls_log_bytevector (BYTE *buf, UINT16 buflen)
{
  INT16 i;

  wtls_log_msg (0, "<");
  for (i = 0; i < buflen; i++) {
    if ((i > 0) && ((i & 0xf) == 0))
      wtls_log_msg (0, "\n");
    if (i > 0)
      wtls_log_msg (0, " ");
    wtls_log_msg (0, "%02x", buf[i]);
  }
  wtls_log_msg (0, ">\n");
}

#endif