Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/ssh.c

Diff of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/ssh.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 4530 by doda, Tue Jul 26 08:18:19 2011 UTC revision 4546 by maya, Thu Jul 28 08:58:28 2011 UTC
# Line 1704  static void init_protocol(PTInstVar pvar Line 1704  static void init_protocol(PTInstVar pvar
1704    
1705  BOOL SSH_handle_server_ID(PTInstVar pvar, char FAR * ID, int ID_len)  BOOL SSH_handle_server_ID(PTInstVar pvar, char FAR * ID, int ID_len)
1706  {  {
1707          static const char prefix[] = "Received server prologue string: ";          static char prefix[64];
1708    
1709          // initialize SSH2 memory dump (2005.3.7 yutaka)          // initialize SSH2 memory dump (2005.3.7 yutaka)
1710          init_memdump();          init_memdump();
# Line 1713  BOOL SSH_handle_server_ID(PTInstVar pvar Line 1713  BOOL SSH_handle_server_ID(PTInstVar pvar
1713          if (ID_len <= 0) {          if (ID_len <= 0) {
1714                  return FALSE;                  return FALSE;
1715          } else {          } else {
1716                  int buf_len = ID_len + NUM_ELEM(prefix);                  int buf_len;
1717                  char FAR *buf = (char FAR *) malloc(buf_len);                  char FAR *buf;
1718    
1719                    strncpy_s(prefix, sizeof(prefix), "Received server identification string: ", _TRUNCATE);
1720                    buf_len = strlen(prefix) + ID_len + 1;
1721                    buf = (char FAR *) malloc(buf_len);
1722                  strncpy_s(buf, buf_len, prefix, _TRUNCATE);                  strncpy_s(buf, buf_len, prefix, _TRUNCATE);
1723                  strncat_s(buf, buf_len, ID, _TRUNCATE);                  strncat_s(buf, buf_len, ID, _TRUNCATE);
1724                  chop_newlines(buf);                  chop_newlines(buf);
   
1725                  notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);                  notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
   
1726                  free(buf);                  free(buf);
1727    
1728    
# Line 1789  BOOL SSH_handle_server_ID(PTInstVar pvar Line 1790  BOOL SSH_handle_server_ID(PTInstVar pvar
1790                                          // 改行コードの除去 (2004.8.4 yutaka)                                          // 改行コードの除去 (2004.8.4 yutaka)
1791                                          pvar->client_version_string[--TTSSH_ID_len] = 0;                                          pvar->client_version_string[--TTSSH_ID_len] = 0;
1792    
1793                                            strncpy_s(prefix, sizeof(prefix), "Sent client identification string: ", _TRUNCATE);
1794                                            buf_len = strlen(prefix) + strlen(pvar->client_version_string) + 1;
1795                                            buf = (char FAR *) malloc(buf_len);
1796                                            strncpy_s(buf, buf_len, prefix, _TRUNCATE);
1797                                            strncat_s(buf, buf_len, pvar->client_version_string, _TRUNCATE);
1798                                            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
1799                                            free(buf);
1800    
1801                                          push_memdump("server ID", NULL, pvar->server_version_string, strlen(pvar->server_version_string));                                          push_memdump("server ID", NULL, pvar->server_version_string, strlen(pvar->server_version_string));
1802                                          push_memdump("client ID", NULL, pvar->client_version_string, strlen(pvar->client_version_string));                                          push_memdump("client ID", NULL, pvar->client_version_string, strlen(pvar->client_version_string));
1803    
# Line 4431  void SSH2_send_kexinit(PTInstVar pvar) Line 4440  void SSH2_send_kexinit(PTInstVar pvar)
4440          buffer_t *msg;          buffer_t *msg;
4441          unsigned char *outmsg;          unsigned char *outmsg;
4442          int len, i;          int len, i;
4443            char log[1024];
4444    
4445          msg = buffer_init();          msg = buffer_init();
4446          if (msg == NULL) {          if (msg == NULL) {
# Line 4456  void SSH2_send_kexinit(PTInstVar pvar) Line 4466  void SSH2_send_kexinit(PTInstVar pvar)
4466          buffer_put_char(msg, 0);          buffer_put_char(msg, 0);
4467          buffer_put_int(msg, 0);          buffer_put_int(msg, 0);
4468    
4469    
4470            _snprintf_s(log, sizeof(log), _TRUNCATE,
4471                        "client proposal: KEX algorithm: %s",
4472                        myproposal[0]);
4473            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4474    
4475            _snprintf_s(log, sizeof(log), _TRUNCATE,
4476                        "client proposal: server host key algorithm: %s",
4477                        myproposal[1]);
4478            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4479    
4480            _snprintf_s(log, sizeof(log), _TRUNCATE,
4481                        "client proposal: encryption algorithm client to server: %s",
4482                        myproposal[2]);
4483            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4484    
4485            _snprintf_s(log, sizeof(log), _TRUNCATE,
4486                        "client proposal: encryption algorithm server to client: %s",
4487                        myproposal[3]);
4488            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4489    
4490            _snprintf_s(log, sizeof(log), _TRUNCATE,
4491                        "client proposal: MAC algorithm client to server: %s",
4492                        myproposal[4]);
4493            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4494    
4495            _snprintf_s(log, sizeof(log), _TRUNCATE,
4496                        "client proposal: MAC algorithm server to client: %s",
4497                        myproposal[5]);
4498            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4499    
4500            _snprintf_s(log, sizeof(log), _TRUNCATE,
4501                        "client proposal: compression algorithm client to server: %s",
4502                        myproposal[6]);
4503            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4504    
4505            _snprintf_s(log, sizeof(log), _TRUNCATE,
4506                        "client proposal: compression algorithm server to client: %s",
4507                        myproposal[7]);
4508            notify_verbose_message(pvar, log, LOG_LEVEL_VERBOSE);
4509    
4510    
4511          len = buffer_len(msg);          len = buffer_len(msg);
4512          outmsg = begin_send_packet(pvar, SSH2_MSG_KEXINIT, len);          outmsg = begin_send_packet(pvar, SSH2_MSG_KEXINIT, len);
4513          memcpy(outmsg, buffer_ptr(msg), len);          memcpy(outmsg, buffer_ptr(msg), len);
# Line 4713  static BOOL handle_SSH2_kexinit(PTInstVa Line 4765  static BOOL handle_SSH2_kexinit(PTInstVa
4765          // get rid of Cookie length          // get rid of Cookie length
4766          offset += SSH2_COOKIE_LENGTH;          offset += SSH2_COOKIE_LENGTH;
4767    
4768    
4769            // KEXの決定。判定順をmyproposal[PROPOSAL_KEX_ALGS]の並びと合わせること。
4770            // サーバは、クライアントから送られてきた myproposal[PROPOSAL_KEX_ALGS] のカンマ文字列のうち、
4771            // 先頭から自分の myproposal[] と比較を行い、最初にマッチしたものがKEXアルゴリズムとして
4772            // 選択される。(2004.10.30 yutaka)
4773    
4774          // キー交換アルゴリズムチェック          // キー交換アルゴリズムチェック
4775          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
4776          offset += 4;          offset += 4;
# Line 4722  static BOOL handle_SSH2_kexinit(PTInstVa Line 4780  static BOOL handle_SSH2_kexinit(PTInstVa
4780          buf[i] = '\0'; // null-terminate          buf[i] = '\0'; // null-terminate
4781          offset += size;          offset += size;
4782    
4783          // KEXの決定。判定順をmyproposal[PROPOSAL_KEX_ALGS]の並びと合わせること。          _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: KEX algorithm: %s", buf);
4784          // サーバは、クライアントから送られてきた myproposal[PROPOSAL_KEX_ALGS] のカンマ文字列のうち、          notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4785          // 先頭から自分の myproposal[] と比較を行い、最初にマッチしたものがKEXアルゴリズムとして  
         // 選択される。(2004.10.30 yutaka)  
4786          pvar->kex_type = choose_SSH2_kex_algorithm(buf, myproposal[PROPOSAL_KEX_ALGS]);          pvar->kex_type = choose_SSH2_kex_algorithm(buf, myproposal[PROPOSAL_KEX_ALGS]);
4787          if (pvar->kex_type == KEX_DH_UNKNOWN) { // not match          if (pvar->kex_type == KEX_DH_UNKNOWN) { // not match
4788                  strncpy_s(tmp, sizeof(tmp), "unknown KEX algorithm: ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown KEX algorithm: ", _TRUNCATE);
# Line 4734  static BOOL handle_SSH2_kexinit(PTInstVa Line 4791  static BOOL handle_SSH2_kexinit(PTInstVa
4791                  goto error;                  goto error;
4792          }          }
4793    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE, "KEX algorithm: %s", get_kex_algorithm_name(pvar->kex_type));  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4794    
4795          // ホストキーアルゴリズムチェック          // ホストキーアルゴリズムチェック
4796          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
# Line 4745  static BOOL handle_SSH2_kexinit(PTInstVa Line 4800  static BOOL handle_SSH2_kexinit(PTInstVa
4800          }          }
4801          buf[i] = 0;          buf[i] = 0;
4802          offset += size;          offset += size;
4803    
4804            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: server host key algorithm: %s", buf);
4805            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4806    
4807          pvar->hostkey_type = KEY_UNSPEC;          pvar->hostkey_type = KEY_UNSPEC;
4808          choose_SSH2_proposal(buf, myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS], str_keytype, sizeof(str_keytype));          choose_SSH2_proposal(buf, myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS], str_keytype, sizeof(str_keytype));
4809          if (strlen(str_keytype) == 0) { // not match          if (strlen(str_keytype) == 0) { // not match
# Line 4761  static BOOL handle_SSH2_kexinit(PTInstVa Line 4820  static BOOL handle_SSH2_kexinit(PTInstVa
4820                  goto error;                  goto error;
4821          }          }
4822    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE,  
                     "server host key algorithm: %s", str_keytype);  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4823    
4824          // クライアント -> サーバ暗号アルゴリズムチェック          // クライアント -> サーバ暗号アルゴリズムチェック
4825          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
# Line 4773  static BOOL handle_SSH2_kexinit(PTInstVa Line 4829  static BOOL handle_SSH2_kexinit(PTInstVa
4829          }          }
4830          buf[i] = 0;          buf[i] = 0;
4831          offset += size;          offset += size;
4832    
4833            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: encryption algorithm client to server: %s", buf);
4834            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4835    
4836          pvar->ctos_cipher = choose_SSH2_cipher_algorithm(buf, myproposal[PROPOSAL_ENC_ALGS_CTOS]);          pvar->ctos_cipher = choose_SSH2_cipher_algorithm(buf, myproposal[PROPOSAL_ENC_ALGS_CTOS]);
4837          if (pvar->ctos_cipher == SSH_CIPHER_NONE) {          if (pvar->ctos_cipher == SSH_CIPHER_NONE) {
4838                  strncpy_s(tmp, sizeof(tmp), "unknown Encrypt algorithm(ctos): ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown Encrypt algorithm(ctos): ", _TRUNCATE);
# Line 4781  static BOOL handle_SSH2_kexinit(PTInstVa Line 4841  static BOOL handle_SSH2_kexinit(PTInstVa
4841                  goto error;                  goto error;
4842          }          }
4843    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE,  
                     "encryption algorithm client to server: %s",  
                     get_cipher_string(pvar->ctos_cipher));  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4844    
4845          // サーバ -> クライアント暗号アルゴリズムチェック          // サーバ -> クライアント暗号アルゴリズムチェック
4846          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
# Line 4794  static BOOL handle_SSH2_kexinit(PTInstVa Line 4850  static BOOL handle_SSH2_kexinit(PTInstVa
4850          }          }
4851          buf[i] = 0;          buf[i] = 0;
4852          offset += size;          offset += size;
4853    
4854            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: encryption algorithm server to client: %s", buf);
4855            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4856    
4857          pvar->stoc_cipher = choose_SSH2_cipher_algorithm(buf, myproposal[PROPOSAL_ENC_ALGS_STOC]);          pvar->stoc_cipher = choose_SSH2_cipher_algorithm(buf, myproposal[PROPOSAL_ENC_ALGS_STOC]);
4858          if (pvar->stoc_cipher == SSH_CIPHER_NONE) {          if (pvar->stoc_cipher == SSH_CIPHER_NONE) {
4859                  strncpy_s(tmp, sizeof(tmp), "unknown Encrypt algorithm(stoc): ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown Encrypt algorithm(stoc): ", _TRUNCATE);
# Line 4802  static BOOL handle_SSH2_kexinit(PTInstVa Line 4862  static BOOL handle_SSH2_kexinit(PTInstVa
4862                  goto error;                  goto error;
4863          }          }
4864    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE,  
                     "encryption algorithm server to client: %s",  
                     get_cipher_string(pvar->stoc_cipher));  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4865    
4866          // HMAC(Hash Message Authentication Code)アルゴリズムの決定 (2004.12.17 yutaka)          // HMAC(Hash Message Authentication Code)アルゴリズムの決定 (2004.12.17 yutaka)
4867          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
# Line 4815  static BOOL handle_SSH2_kexinit(PTInstVa Line 4871  static BOOL handle_SSH2_kexinit(PTInstVa
4871          }          }
4872          buf[i] = 0;          buf[i] = 0;
4873          offset += size;          offset += size;
4874    
4875            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: MAC algorithm client to server: %s", buf);
4876            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4877    
4878          pvar->ctos_hmac = choose_SSH2_hmac_algorithm(buf, myproposal[PROPOSAL_MAC_ALGS_CTOS]);          pvar->ctos_hmac = choose_SSH2_hmac_algorithm(buf, myproposal[PROPOSAL_MAC_ALGS_CTOS]);
4879          if (pvar->ctos_hmac == HMAC_UNKNOWN) { // not match          if (pvar->ctos_hmac == HMAC_UNKNOWN) { // not match
4880                  strncpy_s(tmp, sizeof(tmp), "unknown HMAC algorithm: ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown HMAC algorithm: ", _TRUNCATE);
# Line 4823  static BOOL handle_SSH2_kexinit(PTInstVa Line 4883  static BOOL handle_SSH2_kexinit(PTInstVa
4883                  goto error;                  goto error;
4884          }          }
4885    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE,  
                     "MAC algorithm client to server: %s",  
                     get_ssh2_mac_name(pvar->ctos_hmac));  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4886    
4887          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
4888          offset += 4;          offset += 4;
# Line 4835  static BOOL handle_SSH2_kexinit(PTInstVa Line 4891  static BOOL handle_SSH2_kexinit(PTInstVa
4891          }          }
4892          buf[i] = 0;          buf[i] = 0;
4893          offset += size;          offset += size;
4894    
4895            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: MAC algorithm server to client: %s", buf);
4896            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4897    
4898          pvar->stoc_hmac = choose_SSH2_hmac_algorithm(buf, myproposal[PROPOSAL_MAC_ALGS_STOC]);          pvar->stoc_hmac = choose_SSH2_hmac_algorithm(buf, myproposal[PROPOSAL_MAC_ALGS_STOC]);
4899          if (pvar->stoc_hmac == HMAC_UNKNOWN) { // not match          if (pvar->stoc_hmac == HMAC_UNKNOWN) { // not match
4900                  strncpy_s(tmp, sizeof(tmp), "unknown HMAC algorithm: ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown HMAC algorithm: ", _TRUNCATE);
# Line 4843  static BOOL handle_SSH2_kexinit(PTInstVa Line 4903  static BOOL handle_SSH2_kexinit(PTInstVa
4903                  goto error;                  goto error;
4904          }          }
4905    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE,  
                     "MAC algorithm server to client: %s",  
                     get_ssh2_mac_name(pvar->stoc_hmac));  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4906    
4907          // 圧縮アルゴリズムの決定          // 圧縮アルゴリズムの決定
4908          // pvar->ssh_state.compressing = FALSE; として下記メンバを使用する。          // pvar->ssh_state.compressing = FALSE; として下記メンバを使用する。
# Line 4858  static BOOL handle_SSH2_kexinit(PTInstVa Line 4914  static BOOL handle_SSH2_kexinit(PTInstVa
4914          }          }
4915          buf[i] = 0;          buf[i] = 0;
4916          offset += size;          offset += size;
4917    
4918            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: compression algorithm client to server: %s", buf);
4919            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4920    
4921          pvar->ctos_compression = choose_SSH2_compression_algorithm(buf, myproposal[PROPOSAL_COMP_ALGS_CTOS]);          pvar->ctos_compression = choose_SSH2_compression_algorithm(buf, myproposal[PROPOSAL_COMP_ALGS_CTOS]);
4922          if (pvar->ctos_compression == COMP_UNKNOWN) { // not match          if (pvar->ctos_compression == COMP_UNKNOWN) { // not match
4923                  strncpy_s(tmp, sizeof(tmp), "unknown Packet Compression algorithm: ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown Packet Compression algorithm: ", _TRUNCATE);
# Line 4866  static BOOL handle_SSH2_kexinit(PTInstVa Line 4926  static BOOL handle_SSH2_kexinit(PTInstVa
4926                  goto error;                  goto error;
4927          }          }
4928    
         _snprintf_s(buf, sizeof(buf), _TRUNCATE,  
                     "compression algorithm client to server: %s",  
                     get_ssh2_comp_name(pvar->ctos_compression));  
         notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);  
4929    
4930          size = get_payload_uint32(pvar, offset);          size = get_payload_uint32(pvar, offset);
4931          offset += 4;          offset += 4;
# Line 4878  static BOOL handle_SSH2_kexinit(PTInstVa Line 4934  static BOOL handle_SSH2_kexinit(PTInstVa
4934          }          }
4935          buf[i] = 0;          buf[i] = 0;
4936          offset += size;          offset += size;
4937    
4938            _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "server proposal: compression algorithm server to client: %s", buf);
4939            notify_verbose_message(pvar, tmp, LOG_LEVEL_VERBOSE);
4940    
4941          pvar->stoc_compression = choose_SSH2_compression_algorithm(buf, myproposal[PROPOSAL_COMP_ALGS_STOC]);          pvar->stoc_compression = choose_SSH2_compression_algorithm(buf, myproposal[PROPOSAL_COMP_ALGS_STOC]);
4942          if (pvar->stoc_compression == COMP_UNKNOWN) { // not match          if (pvar->stoc_compression == COMP_UNKNOWN) { // not match
4943                  strncpy_s(tmp, sizeof(tmp), "unknown Packet Compression algorithm: ", _TRUNCATE);                  strncpy_s(tmp, sizeof(tmp), "unknown Packet Compression algorithm: ", _TRUNCATE);
# Line 4886  static BOOL handle_SSH2_kexinit(PTInstVa Line 4946  static BOOL handle_SSH2_kexinit(PTInstVa
4946                  goto error;                  goto error;
4947          }          }
4948    
4949    
4950            // 決定
4951            _snprintf_s(buf, sizeof(buf), _TRUNCATE, "KEX algorithm: %s",
4952                        get_kex_algorithm_name(pvar->kex_type));
4953            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4954    
4955            _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4956                        "server host key algorithm: %s",
4957                        get_ssh_keytype_name(pvar->hostkey_type));
4958            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4959    
4960            _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4961                        "encryption algorithm client to server: %s",
4962                        get_cipher_string(pvar->ctos_cipher));
4963            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4964    
4965            _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4966                        "encryption algorithm server to client: %s",
4967                        get_cipher_string(pvar->stoc_cipher));
4968            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4969    
4970            _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4971                        "MAC algorithm client to server: %s",
4972                        get_ssh2_mac_name(pvar->ctos_hmac));
4973            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4974    
4975            _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4976                        "MAC algorithm server to client: %s",
4977                        get_ssh2_mac_name(pvar->stoc_hmac));
4978            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4979    
4980            _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4981                        "compression algorithm client to server: %s",
4982                        get_ssh2_comp_name(pvar->ctos_compression));
4983            notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4984    
4985          _snprintf_s(buf, sizeof(buf), _TRUNCATE,          _snprintf_s(buf, sizeof(buf), _TRUNCATE,
4986                      "compression algorithm server to client: %s",                      "compression algorithm server to client: %s",
4987                      get_ssh2_comp_name(pvar->stoc_compression));                      get_ssh2_comp_name(pvar->stoc_compression));
4988          notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);          notify_verbose_message(pvar, buf, LOG_LEVEL_VERBOSE);
4989    
4990    
4991          // we_needの決定 (2004.11.6 yutaka)          // we_needの決定 (2004.11.6 yutaka)
4992          // キー再作成の場合はスキップする。          // キー再作成の場合はスキップする。
4993          if (pvar->rekeying == 0) {          if (pvar->rekeying == 0) {
Legend:
Removed from v.4530  
changed lines
  Added in v.4546
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help