Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

Contents of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 7101 - (show annotations) (download) (as text)
Thu Apr 19 11:58:00 2018 UTC (5 years, 11 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 184401 byte(s) 
keyboard-interactive 認証の表記を修正 #38004

併せて /passwd=keyboard-interactive を追加
1 /*
2 * Copyright (c) 1998-2001, Robert O'Callahan
3 * (C) 2004-2017 TeraTerm Project
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /* Tera Term extension mechanism
31 Robert O'Callahan (roc+tt@cs.cmu.edu)
32
33 Tera Term by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
34 */
35
36 #include "ttxssh.h"
37 #include "fwdui.h"
38 #include "util.h"
39 #include "ssh.h"
40 #include "ttcommon.h"
41 #include "ttlib.h"
42 #include "keyfiles.h"
43 #include "arc4random.h"
44
45 #include <stdlib.h>
46 #include <stdio.h>
47 #include <string.h>
48 #include <io.h>
49 #include <fcntl.h>
50 #include <sys/stat.h>
51 #include <time.h>
52 #include <mbstring.h>
53
54 #include "resource.h"
55 #include <commctrl.h>
56 #include <commdlg.h>
57 #include <winsock2.h>
58 static char *ProtocolFamilyList[] = { "UNSPEC", "IPv6", "IPv4", NULL };
59
60 #include <Lmcons.h>
61
62 // include OpenSSL header file
63 #include <openssl/evp.h>
64 #include <openssl/rsa.h>
65 #include <openssl/dsa.h>
66 #include <openssl/bn.h>
67 #include <openssl/pem.h>
68 #include <openssl/rand.h>
69 #include <openssl/rc4.h>
70 #include <openssl/md5.h>
71
72 // include ZLib header file
73 #include <zlib.h>
74
75 #include "buffer.h"
76 #include "cipher.h"
77 #include "key.h"
78
79 #include "sftp.h"
80
81 #include "compat_w95.h"
82
83 #include "libputty.h"
84
85 #define MATCH_STR(s, o) strncmp((s), (o), NUM_ELEM(o) - 1)
86 #define MATCH_STR_I(s, o) _strnicmp((s), (o), NUM_ELEM(o) - 1)
87
88 /* This extension implements SSH, so we choose a load order in the
89 "protocols" range. */
90 #define ORDER 2500
91
92 static HICON SecureLargeIcon = NULL;
93 static HICON SecureSmallIcon = NULL;
94 static HICON SecureNotifyIcon = NULL;
95 static HICON OldNotifyIcon = NULL;
96
97 static HFONT DlgHostFont;
98 static HFONT DlgAboutFont;
99 static HFONT DlgAboutTextFont;
100 static HFONT DlgSetupFont;
101 static HFONT DlgKeygenFont;
102
103 static TInstVar *pvar;
104
105 typedef struct {
106 int cnt;
107 HWND dlg;
108 ssh_keytype type;
109 } cbarg_t;
110
111 /* WIN32 allows multiple instances of a DLL */
112 static TInstVar InstVar;
113
114 /*
115 This code makes lots of assumptions about the order in which Tera Term
116 does things, and how. A key assumption is that the Notification window
117 passed into WSAAsyncSelect is the main terminal window. We also assume
118 that the socket used in the first WSAconnect is the main session socket.
119 */
120
121 static void init_TTSSH(PTInstVar pvar)
122 {
123 pvar->socket = INVALID_SOCKET;
124 pvar->OldLargeIcon = NULL;
125 pvar->OldSmallIcon = NULL;
126 pvar->NotificationWindow = NULL;
127 pvar->hostdlg_activated = FALSE;
128 pvar->socket = INVALID_SOCKET;
129 pvar->NotificationWindow = NULL;
130 pvar->protocol_major = 0;
131 pvar->protocol_minor = 0;
132
133 PKT_init(pvar);
134 SSH_init(pvar);
135 CRYPT_init(pvar);
136 AUTH_init(pvar);
137 HOSTS_init(pvar);
138 FWD_init(pvar);
139 FWDUI_init(pvar);
140
141 ssh_heartbeat_lock_initialize();
142 }
143
144 static void uninit_TTSSH(PTInstVar pvar)
145 {
146 halt_ssh_heartbeat_thread(pvar);
147
148 ssh2_channel_free();
149
150 SSH_end(pvar);
151 PKT_end(pvar);
152 AUTH_end(pvar);
153 CRYPT_end(pvar);
154 HOSTS_end(pvar);
155 FWD_end(pvar);
156 FWDUI_end(pvar);
157
158 if (pvar->OldLargeIcon != NULL) {
159 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
160 (LPARAM) pvar->OldLargeIcon);
161 pvar->OldLargeIcon = NULL;
162 }
163 if (pvar->OldSmallIcon != NULL) {
164 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
165 (LPARAM) pvar->OldSmallIcon);
166 pvar->OldSmallIcon = NULL;
167 }
168 if (OldNotifyIcon) {
169 SetCustomNotifyIcon(OldNotifyIcon);
170 }
171
172 ssh_heartbeat_lock_finalize();
173 }
174
175 static void PASCAL TTXInit(PTTSet ts, PComVar cv)
176 {
177 pvar->settings = *pvar->ts_SSH;
178 pvar->ts = ts;
179 pvar->cv = cv;
180 pvar->fatal_error = FALSE;
181 pvar->showing_err = FALSE;
182 pvar->err_msg = NULL;
183
184 init_TTSSH(pvar);
185 }
186
187 static void normalize_generic_order(char *buf, char default_strings[], int default_strings_len)
188 {
189 char listed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
190 char allowed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
191 int i, j, k=-1;
192
193 memset(listed, 0, sizeof(listed));
194 memset(allowed, 0, sizeof(allowed));
195
196 // �����������������������X�g�������B
197 for (i = 0; i < default_strings_len ; i++) {
198 allowed[default_strings[i]] = 1;
199 }
200
201 // �w�����������������������A���������������������A�d���������������������B
202 //
203 // ex. (i=5 ����������������)
204 // i=012345
205 // >:=9<87;A@?B3026(\0)
206 // i+1
207 // <------------>
208 // ��
209 // >:=9<7;A@?B3026(\0)
210 //
211 for (i = 0; buf[i] != 0; i++) {
212 int num = buf[i] - '0';
213
214 if (num < 0 || num > default_strings_len
215 || !allowed[num]
216 || listed[num]) {
217 memmove(buf + i, buf + i + 1, strlen(buf + i + 1) + 1);
218 i--;
219 } else {
220 listed[num] = 1;
221 }
222
223 // disabled line���������A���u���o���������B
224 if (num == 0) {
225 k = i;
226 }
227 }
228
229 // �w���������������������������Adisabled line�����O���}�������B
230 //
231 // ex. (Z���}������)
232 // k
233 // >:=9<87;A@?B3026(\0)
234 // k+1
235 // <---->
236 // �� k
237 // >:=9<87;A@?B30026(\0)
238 // �� k
239 // >:=9<87;A@?B3Z026(\0)
240 //
241 for (j = 0; j < default_strings_len && default_strings[j] != 0; j++) {
242 int num = default_strings[j];
243
244 if (!listed[num] && k >= 0) {
245 int copylen = strlen(buf + k + 1) + 1;
246
247 memmove(buf + k + 1, buf + k, copylen);
248 buf[k + 1 + copylen] = '\0'; // �I�[���Y�������t�����B
249 buf[k] = num + '0';
250 k++;
251 i++;
252 }
253 }
254 if (k < 0) {
255 j = 0;
256 }
257 else {
258 j++;
259 }
260
261 // disabled line�������������������A�����������������������B
262 for (; j < default_strings_len ; j++) {
263 int num = default_strings[j];
264
265 if (!listed[num]) {
266 buf[i] = num + '0';
267 i++;
268 }
269 }
270
271 buf[i] = 0;
272 }
273
274 /*
275 * Remove unsupported cipher or duplicated cipher.
276 * Add unspecified ciphers at the end of list.
277 */
278 static void normalize_cipher_order(char *buf)
279 {
280 /* SSH_CIPHER_NONE means that all ciphers below that one are disabled.
281 We *never* allow no encryption. */
282 static char default_strings[] = {
283 SSH2_CIPHER_AES256_GCM,
284 SSH2_CIPHER_CAMELLIA256_CTR,
285 SSH2_CIPHER_AES256_CTR,
286 SSH2_CIPHER_CAMELLIA256_CBC,
287 SSH2_CIPHER_AES256_CBC,
288 SSH2_CIPHER_CAMELLIA192_CTR,
289 SSH2_CIPHER_AES192_CTR,
290 SSH2_CIPHER_CAMELLIA192_CBC,
291 SSH2_CIPHER_AES192_CBC,
292 SSH2_CIPHER_AES128_GCM,
293 SSH2_CIPHER_CAMELLIA128_CTR,
294 SSH2_CIPHER_AES128_CTR,
295 SSH2_CIPHER_CAMELLIA128_CBC,
296 SSH2_CIPHER_AES128_CBC,
297 SSH2_CIPHER_3DES_CTR,
298 SSH2_CIPHER_3DES_CBC,
299 SSH2_CIPHER_BLOWFISH_CTR,
300 SSH2_CIPHER_BLOWFISH_CBC,
301 SSH2_CIPHER_CAST128_CTR,
302 SSH2_CIPHER_CAST128_CBC,
303 SSH_CIPHER_3DES,
304 SSH_CIPHER_NONE,
305 SSH2_CIPHER_ARCFOUR256,
306 SSH2_CIPHER_ARCFOUR128,
307 SSH2_CIPHER_ARCFOUR,
308 SSH_CIPHER_BLOWFISH,
309 SSH_CIPHER_DES,
310 0, 0, 0 // Dummy for SSH_CIPHER_IDEA, SSH_CIPHER_TSS, SSH_CIPHER_RC4
311 };
312
313 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
314 }
315
316 static void normalize_kex_order(char *buf)
317 {
318 static char default_strings[] = {
319 KEX_ECDH_SHA2_256,
320 KEX_ECDH_SHA2_384,
321 KEX_ECDH_SHA2_521,
322 KEX_DH_GRP18_SHA512,
323 KEX_DH_GRP16_SHA512,
324 KEX_DH_GRP14_SHA256,
325 KEX_DH_GEX_SHA256,
326 KEX_DH_GEX_SHA1,
327 KEX_DH_GRP14_SHA1,
328 KEX_DH_GRP1_SHA1,
329 KEX_DH_NONE,
330 };
331
332 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
333 }
334
335 static void normalize_host_key_order(char *buf)
336 {
337 static char default_strings[] = {
338 KEY_ECDSA256,
339 KEY_ECDSA384,
340 KEY_ECDSA521,
341 KEY_ED25519,
342 KEY_RSA,
343 KEY_DSA,
344 KEY_NONE,
345 };
346
347 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
348 }
349
350 static void normalize_mac_order(char *buf)
351 {
352 static char default_strings[] = {
353 HMAC_SHA2_512_EtM,
354 HMAC_SHA2_256_EtM,
355 HMAC_SHA1_EtM,
356 HMAC_SHA2_512,
357 HMAC_SHA2_256,
358 HMAC_SHA1,
359 HMAC_RIPEMD160_EtM,
360 HMAC_RIPEMD160,
361 HMAC_MD5_EtM,
362 HMAC_MD5,
363 HMAC_NONE,
364 HMAC_SHA1_96_EtM,
365 HMAC_MD5_96_EtM,
366 HMAC_SHA1_96,
367 HMAC_MD5_96,
368 0, // Dummy for HMAC_SHA2_512_96,
369 0, // Dummy for HMAC_SHA2_256_96,
370 };
371
372 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
373 }
374
375 static void normalize_comp_order(char *buf)
376 {
377 static char default_strings[] = {
378 COMP_DELAYED,
379 COMP_ZLIB,
380 COMP_NOCOMP,
381 COMP_NONE,
382 };
383
384 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
385 }
386
387
388 /* Remove local settings from the shared memory block. */
389 static void clear_local_settings(PTInstVar pvar)
390 {
391 pvar->ts_SSH->TryDefaultAuth = FALSE;
392 }
393
394 static BOOL read_BOOL_option(PCHAR fileName, char *keyName, BOOL def)
395 {
396 char buf[1024];
397
398 buf[0] = 0;
399 GetPrivateProfileString("TTSSH", keyName, "", buf, sizeof(buf),
400 fileName);
401 if (buf[0] == 0) {
402 return def;
403 } else {
404 return atoi(buf) != 0 ||
405 _stricmp(buf, "yes") == 0 ||
406 _stricmp(buf, "y") == 0;
407 }
408 }
409
410 static void read_string_option(PCHAR fileName, char *keyName,
411 char *def, char *buf, int bufSize)
412 {
413
414 buf[0] = 0;
415 GetPrivateProfileString("TTSSH", keyName, def, buf, bufSize, fileName);
416 }
417
418 static void read_ssh_options(PTInstVar pvar, PCHAR fileName)
419 {
420 char buf[1024];
421 TS_SSH *settings = pvar->ts_SSH;
422
423 #define READ_STD_STRING_OPTION(name) \
424 read_string_option(fileName, #name, "", settings->name, sizeof(settings->name))
425
426 settings->Enabled = read_BOOL_option(fileName, "Enabled", FALSE);
427
428 buf[0] = 0;
429 GetPrivateProfileString("TTSSH", "Compression", "", buf, sizeof(buf),
430 fileName);
431 settings->CompressionLevel = atoi(buf);
432 if (settings->CompressionLevel < 0 || settings->CompressionLevel > 9) {
433 settings->CompressionLevel = 0;
434 }
435
436 READ_STD_STRING_OPTION(DefaultUserName);
437 READ_STD_STRING_OPTION(DefaultForwarding);
438 READ_STD_STRING_OPTION(DefaultRhostsLocalUserName);
439 READ_STD_STRING_OPTION(DefaultRhostsHostPrivateKeyFile);
440 READ_STD_STRING_OPTION(DefaultRSAPrivateKeyFile);
441
442 READ_STD_STRING_OPTION(CipherOrder);
443 normalize_cipher_order(settings->CipherOrder);
444
445 // KEX order
446 READ_STD_STRING_OPTION(KexOrder);
447 normalize_kex_order(settings->KexOrder);
448 // Host Key algorithm order
449 READ_STD_STRING_OPTION(HostKeyOrder);
450 normalize_host_key_order(settings->HostKeyOrder);
451 // HMAC order
452 READ_STD_STRING_OPTION(MacOrder);
453 normalize_mac_order(settings->MacOrder);
454 // Compression algorithm order
455 READ_STD_STRING_OPTION(CompOrder);
456 normalize_comp_order(settings->CompOrder);
457
458 read_string_option(fileName, "KnownHostsFiles", "ssh_known_hosts",
459 settings->KnownHostsFiles,
460 sizeof(settings->KnownHostsFiles));
461
462 buf[0] = 0;
463 GetPrivateProfileString("TTSSH", "DefaultAuthMethod", "", buf,
464 sizeof(buf), fileName);
465 settings->DefaultAuthMethod = atoi(buf);
466 if (settings->DefaultAuthMethod != SSH_AUTH_PASSWORD
467 && settings->DefaultAuthMethod != SSH_AUTH_RSA
468 && settings->DefaultAuthMethod != SSH_AUTH_TIS // add (2005.3.12 yutaka)
469 && settings->DefaultAuthMethod != SSH_AUTH_RHOSTS
470 && settings->DefaultAuthMethod != SSH_AUTH_PAGEANT) {
471 /* this default can never be SSH_AUTH_RHOSTS_RSA because that is not a
472 selection in the dialog box; SSH_AUTH_RHOSTS_RSA is automatically chosen
473 when the dialog box has rhosts selected and an host private key file
474 is supplied. */
475 settings->DefaultAuthMethod = SSH_AUTH_PASSWORD;
476 }
477
478 buf[0] = 0;
479 GetPrivateProfileString("TTSSH", "LogLevel", "", buf, sizeof(buf),
480 fileName);
481 settings->LogLevel = atoi(buf);
482
483 buf[0] = 0;
484 GetPrivateProfileString("TTSSH", "WriteBufferSize", "", buf,
485 sizeof(buf), fileName);
486 settings->WriteBufferSize = atoi(buf);
487 if (settings->WriteBufferSize <= 0) {
488 settings->WriteBufferSize = (PACKET_MAX_SIZE / 2); // 2MB
489 }
490
491 // SSH protocol version (2004.10.11 yutaka)
492 // default is SSH2 (2004.11.30 yutaka)
493 settings->ssh_protocol_version = GetPrivateProfileInt("TTSSH", "ProtocolVersion", 2, fileName);
494
495 // SSH heartbeat time(second) (2004.12.11 yutaka)
496 settings->ssh_heartbeat_overtime = GetPrivateProfileInt("TTSSH", "HeartBeat", 60, fileName);
497
498 // �p�X���[�h�F�����������J���F�����g���p�X���[�h����������������������������������
499 // �\���B(2006.8.5 yutaka)
500 settings->remember_password = GetPrivateProfileInt("TTSSH", "RememberPassword", 1, fileName);
501
502 // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
503 // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
504 settings->CheckAuthListFirst = read_BOOL_option(fileName, "CheckAuthListFirst", FALSE);
505
506 // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
507 settings->EnableRsaShortKeyServer = read_BOOL_option(fileName, "EnableRsaShortKeyServer", FALSE);
508
509 // agent forward ���L�������� (2008.11.25 maya)
510 settings->ForwardAgent = read_BOOL_option(fileName, "ForwardAgent", FALSE);
511
512 // agent forward �m�F���L��������
513 settings->ForwardAgentConfirm = read_BOOL_option(fileName, "ForwardAgentConfirm", TRUE);
514
515 // agent forward �m�F���L��������
516 settings->ForwardAgentNotify = read_BOOL_option(fileName, "ForwardAgentNotify", TRUE);
517
518 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
519 settings->VerifyHostKeyDNS = read_BOOL_option(fileName, "VerifyHostKeyDNS", TRUE);
520
521 // icon
522 GetPrivateProfileString("TTSSH", "SSHIcon", "", buf, sizeof(buf), fileName);
523 if ((_stricmp(buf, "old") == 0) ||
524 (_stricmp(buf, "yellow") == 0) ||
525 (_stricmp(buf, "securett_yellow") == 0)) {
526 settings->IconID = IDI_SECURETT_YELLOW;
527 }
528 else if ((_stricmp(buf, "green") == 0) ||
529 (_stricmp(buf, "securett_green") == 0)) {
530 settings->IconID = IDI_SECURETT_GREEN;
531 }
532 else {
533 settings->IconID = IDI_SECURETT;
534 }
535
536 // �G���[�������x�������|�b�v�A�b�v���b�Z�[�W���}�~���� (2014.6.26 yutaka)
537 settings->DisablePopupMessage = GetPrivateProfileInt("TTSSH", "DisablePopupMessage", 0, fileName);
538
539 READ_STD_STRING_OPTION(X11Display);
540
541 settings->UpdateHostkeys = GetPrivateProfileInt("TTSSH", "UpdateHostkeys", 0, fileName);
542
543 settings->GexMinimalGroupSize = GetPrivateProfileInt("TTSSH", "GexMinimalGroupSize", 0, fileName);
544
545 settings->AuthBanner = GetPrivateProfileInt("TTSSH", "AuthBanner", 1, fileName);
546
547 clear_local_settings(pvar);
548 }
549
550 static void write_ssh_options(PTInstVar pvar, PCHAR fileName,
551 TS_SSH *settings, BOOL copy_forward)
552 {
553 char buf[1024];
554
555 WritePrivateProfileString("TTSSH", "Enabled",
556 settings->Enabled ? "1" : "0", fileName);
557
558 _itoa(settings->CompressionLevel, buf, 10);
559 WritePrivateProfileString("TTSSH", "Compression", buf, fileName);
560
561 WritePrivateProfileString("TTSSH", "DefaultUserName",
562 settings->DefaultUserName, fileName);
563
564 if (copy_forward) {
565 WritePrivateProfileString("TTSSH", "DefaultForwarding",
566 settings->DefaultForwarding, fileName);
567 }
568
569 WritePrivateProfileString("TTSSH", "CipherOrder",
570 settings->CipherOrder, fileName);
571
572 WritePrivateProfileString("TTSSH", "KexOrder",
573 settings->KexOrder, fileName);
574
575 WritePrivateProfileString("TTSSH", "HostKeyOrder",
576 settings->HostKeyOrder, fileName);
577
578 WritePrivateProfileString("TTSSH", "MacOrder",
579 settings->MacOrder, fileName);
580
581 WritePrivateProfileString("TTSSH", "CompOrder",
582 settings->CompOrder, fileName);
583
584 WritePrivateProfileString("TTSSH", "KnownHostsFiles",
585 settings->KnownHostsFiles, fileName);
586
587 WritePrivateProfileString("TTSSH", "DefaultRhostsLocalUserName",
588 settings->DefaultRhostsLocalUserName,
589 fileName);
590
591 WritePrivateProfileString("TTSSH", "DefaultRhostsHostPrivateKeyFile",
592 settings->DefaultRhostsHostPrivateKeyFile,
593 fileName);
594
595 WritePrivateProfileString("TTSSH", "DefaultRSAPrivateKeyFile",
596 settings->DefaultRSAPrivateKeyFile,
597 fileName);
598
599 _itoa(settings->DefaultAuthMethod, buf, 10);
600 WritePrivateProfileString("TTSSH", "DefaultAuthMethod", buf, fileName);
601
602 _itoa(settings->LogLevel, buf, 10);
603 WritePrivateProfileString("TTSSH", "LogLevel", buf, fileName);
604
605 _itoa(settings->WriteBufferSize, buf, 10);
606 WritePrivateProfileString("TTSSH", "WriteBufferSize", buf, fileName);
607
608 // SSH protocol version (2004.10.11 yutaka)
609 WritePrivateProfileString("TTSSH", "ProtocolVersion",
610 settings->ssh_protocol_version==2 ? "2" : "1",
611 fileName);
612
613 // SSH heartbeat time(second) (2004.12.11 yutaka)
614 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
615 "%d", settings->ssh_heartbeat_overtime);
616 WritePrivateProfileString("TTSSH", "HeartBeat", buf, fileName);
617
618 // Remember password (2006.8.5 yutaka)
619 WritePrivateProfileString("TTSSH", "RememberPassword",
620 settings->remember_password ? "1" : "0",
621 fileName);
622
623 // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
624 // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
625 WritePrivateProfileString("TTSSH", "CheckAuthListFirst",
626 settings->CheckAuthListFirst ? "1" : "0", fileName);
627
628 // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
629 WritePrivateProfileString("TTSSH", "EnableRsaShortKeyServer",
630 settings->EnableRsaShortKeyServer ? "1" : "0", fileName);
631
632 // agent forward ���L�������� (2008.11.25 maya)
633 WritePrivateProfileString("TTSSH", "ForwardAgent",
634 settings->ForwardAgent ? "1" : "0", fileName);
635
636 // agent forward �m�F���L��������
637 WritePrivateProfileString("TTSSH", "ForwardAgentConfirm",
638 settings->ForwardAgentConfirm ? "1" : "0", fileName);
639
640 // agent forward ���m���L��������
641 WritePrivateProfileString("TTSSH", "ForwardAgentNotify",
642 settings->ForwardAgentNotify ? "1" : "0", fileName);
643
644 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
645 WritePrivateProfileString("TTSSH", "VerifyHostKeyDNS",
646 settings->VerifyHostKeyDNS ? "1" : "0", fileName);
647
648 // SSH �A�C�R��
649 if (settings->IconID==IDI_SECURETT_YELLOW) {
650 WritePrivateProfileString("TTSSH", "SSHIcon", "yellow", fileName);
651 }
652 else if (settings->IconID==IDI_SECURETT_GREEN) {
653 WritePrivateProfileString("TTSSH", "SSHIcon", "green", fileName);
654 }
655 else {
656 WritePrivateProfileString("TTSSH", "SSHIcon", "Default", fileName);
657 }
658
659 _itoa(settings->DisablePopupMessage, buf, 10);
660 WritePrivateProfileString("TTSSH", "DisablePopupMessage", buf, fileName);
661
662 WritePrivateProfileString("TTSSH", "X11Display", settings->X11Display, fileName);
663
664 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
665 "%d", settings->UpdateHostkeys);
666 WritePrivateProfileString("TTSSH", "UpdateHostkeys", buf, fileName);
667
668 _itoa_s(settings->GexMinimalGroupSize, buf, sizeof(buf), 10);
669 WritePrivateProfileString("TTSSH", "GexMinimalGroupSize", buf, fileName);
670
671 _itoa_s(settings->AuthBanner, buf, sizeof(buf), 10);
672 WritePrivateProfileString("TTSSH", "AuthBanner", buf, fileName);
673 }
674
675
676 /* find free port in all protocol family */
677 static unsigned short find_local_port(PTInstVar pvar)
678 {
679 int tries;
680 SOCKET connecter;
681 struct addrinfo hints;
682 struct addrinfo *res;
683 struct addrinfo *res0;
684 unsigned short port;
685 char pname[NI_MAXHOST];
686
687 if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
688 return 0;
689 }
690
691 /* The random numbers here are only used to try to get fresh
692 ports across runs (dangling ports can cause bind errors
693 if we're unlucky). They do not need to be (and are not)
694 cryptographically strong.
695 */
696 srand((unsigned) GetTickCount());
697
698 for (tries = 20; tries > 0; tries--) {
699 memset(&hints, 0, sizeof(hints));
700 hints.ai_family = pvar->ts->ProtocolFamily;
701 hints.ai_flags = AI_PASSIVE;
702 hints.ai_socktype = SOCK_STREAM;
703 port = (unsigned) rand() % 512 + 512;
704 _snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", (int) port);
705 if (getaddrinfo(NULL, pname, &hints, &res0)) {
706 return 0;
707 /* NOT REACHED */
708 }
709
710 for (res = res0; res; res = res->ai_next) {
711 if (res->ai_family == AF_INET || res->ai_family == AF_INET6)
712 continue;
713
714 connecter =
715 socket(res->ai_family, res->ai_socktype, res->ai_protocol);
716 if (connecter == INVALID_SOCKET) {
717 freeaddrinfo(res0);
718 return 0;
719 }
720
721 if (bind(connecter, res->ai_addr, res->ai_addrlen) !=
722 SOCKET_ERROR) {
723 return port;
724 freeaddrinfo(res0);
725 closesocket(connecter);
726 } else if (WSAGetLastError() != WSAEADDRINUSE) {
727 closesocket(connecter);
728 freeaddrinfo(res0);
729 return 0;
730 }
731
732 closesocket(connecter);
733 }
734 freeaddrinfo(res0);
735 }
736
737 return 0;
738 }
739
740 static int PASCAL TTXconnect(SOCKET s,
741 const struct sockaddr *name,
742 int namelen)
743 {
744 if (pvar->socket == INVALID_SOCKET || pvar->socket != s) {
745 struct sockaddr_storage ss;
746 int len;
747
748 pvar->socket = s;
749
750 memset(&ss, 0, sizeof(ss));
751 switch (pvar->ts->ProtocolFamily) {
752 case AF_INET:
753 len = sizeof(struct sockaddr_in);
754 ((struct sockaddr_in *) &ss)->sin_family = AF_INET;
755 ((struct sockaddr_in *) &ss)->sin_addr.s_addr = INADDR_ANY;
756 ((struct sockaddr_in *) &ss)->sin_port =
757 htons(find_local_port(pvar));
758 break;
759 case AF_INET6:
760 len = sizeof(struct sockaddr_in6);
761 ((struct sockaddr_in6 *) &ss)->sin6_family = AF_INET6;
762 memset(&((struct sockaddr_in6 *) &ss)->sin6_addr, 0,
763 sizeof(struct in_addr6));
764 ((struct sockaddr_in6 *) &ss)->sin6_port =
765 htons(find_local_port(pvar));
766 break;
767 default:
768 /* UNSPEC */
769 break;
770 }
771
772 bind(s, (struct sockaddr *) &ss, len);
773 }
774
775 return (pvar->Pconnect) (s, name, namelen);
776 }
777
778 static int PASCAL TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
779 long lEvent)
780 {
781 if (s == pvar->socket) {
782 pvar->notification_events = lEvent;
783 pvar->notification_msg = wMsg;
784
785 if (pvar->NotificationWindow == NULL) {
786 pvar->NotificationWindow = hWnd;
787 AUTH_advance_to_next_cred(pvar);
788 }
789 }
790
791 return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
792 }
793
794 static int PASCAL TTXrecv(SOCKET s, char *buf, int len, int flags)
795 {
796 if (s == pvar->socket) {
797 int ret;
798
799 ssh_heartbeat_lock();
800 ret = PKT_recv(pvar, buf, len);
801 ssh_heartbeat_unlock();
802 return (ret);
803
804 } else {
805 return (pvar->Precv) (s, buf, len, flags);
806 }
807 }
808
809 static int PASCAL TTXsend(SOCKET s, char const *buf, int len,
810 int flags)
811 {
812 if (s == pvar->socket) {
813 ssh_heartbeat_lock();
814 SSH_send(pvar, buf, len);
815 ssh_heartbeat_unlock();
816 return len;
817 } else {
818 return (pvar->Psend) (s, buf, len, flags);
819 }
820 }
821
822 void notify_established_secure_connection(PTInstVar pvar)
823 {
824 int fuLoad = LR_DEFAULTCOLOR;
825
826 if (IsWindowsNT4()) {
827 fuLoad = LR_VGACOLOR;
828 }
829
830 // LoadIcon �������� LoadImage ���g�����������A
831 // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
832 if (SecureLargeIcon == NULL) {
833 SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
834 IMAGE_ICON, 0, 0, fuLoad);
835 }
836 if (SecureSmallIcon == NULL) {
837 SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
838 IMAGE_ICON, 16, 16, fuLoad);
839 }
840
841 if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
842 pvar->OldLargeIcon =
843 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
844 ICON_BIG, 0);
845 pvar->OldSmallIcon =
846 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
847 ICON_SMALL, 0);
848
849 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
850 (LPARAM) SecureLargeIcon);
851 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
852 (LPARAM) SecureSmallIcon);
853 }
854
855 if (IsWindows2000()) {
856 if (SecureNotifyIcon == NULL) {
857 SecureNotifyIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
858 IMAGE_ICON, 0, 0, LR_VGACOLOR | LR_SHARED);
859 }
860 OldNotifyIcon = GetCustomNotifyIcon();
861 SetCustomNotifyIcon(SecureNotifyIcon);
862 }
863
864 logputs(LOG_LEVEL_VERBOSE, "Entering secure mode");
865 }
866
867 void notify_closed_connection(PTInstVar pvar, char *send_msg)
868 {
869 SSH_notify_disconnecting(pvar, send_msg);
870 AUTH_notify_disconnecting(pvar);
871 HOSTS_notify_disconnecting(pvar);
872
873 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
874 pvar->socket, MAKELPARAM(FD_CLOSE, 0));
875 }
876
877 static void add_err_msg(PTInstVar pvar, char *msg)
878 {
879 if (pvar->err_msg != NULL) {
880 int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
881 char *buf = (char *) malloc(buf_len);
882
883 strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
884 strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
885 strncat_s(buf, buf_len, msg, _TRUNCATE);
886 free(pvar->err_msg);
887 pvar->err_msg = buf;
888 } else {
889 pvar->err_msg = _strdup(msg);
890 }
891 }
892
893 void notify_nonfatal_error(PTInstVar pvar, char *msg)
894 {
895 if (!pvar->showing_err) {
896 // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
897 // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
898 if (pvar->NotificationWindow == NULL) {
899 UTIL_get_lang_msg("MSG_NONFATAL_ERROR", pvar,
900 "Tera Term: not fatal error");
901 MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
902 msg[0] = '\0';
903
904 } else {
905 PostMessage(pvar->NotificationWindow, WM_COMMAND,
906 ID_SSHASYNCMESSAGEBOX, 0);
907 }
908 }
909 if (msg[0] != 0) {
910 logputs(LOG_LEVEL_ERROR, msg);
911 add_err_msg(pvar, msg);
912 }
913 }
914
915 void notify_fatal_error(PTInstVar pvar, char *msg, BOOL send_disconnect)
916 {
917 if (msg[0] != 0) {
918 logputs(LOG_LEVEL_FATAL, msg);
919 add_err_msg(pvar, msg);
920 }
921
922 if (!pvar->fatal_error) {
923 pvar->fatal_error = TRUE;
924
925 if (send_disconnect) {
926 SSH_notify_disconnecting(pvar, msg);
927 }
928 AUTH_notify_disconnecting(pvar);
929 HOSTS_notify_disconnecting(pvar);
930
931 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
932 pvar->socket, MAKELPARAM(FD_CLOSE,
933 (pvar->PWSAGetLastError) ()));
934 }
935 }
936
937 void logputs(int level, char *msg)
938 {
939 if (level <= pvar->settings.LogLevel) {
940 char buf[4096];
941 int file;
942
943 get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
944 file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
945 _S_IREAD | _S_IWRITE);
946
947 if (file >= 0) {
948 char *strtime = mctimelocal("%Y-%m-%d %H:%M:%S.%NZ", TRUE);
949 DWORD processid;
950 char tmp[26];
951
952 _write(file, strtime, strlen(strtime));
953 GetWindowThreadProcessId(pvar->cv->HWin, &processid);
954 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " [%lu] ",processid);
955 _write(file, tmp, strlen(tmp));
956 _write(file, msg, strlen(msg));
957 _write(file, "\n", 1);
958 _close(file);
959 }
960 }
961 }
962
963 void logprintf(int level, char *fmt, ...)
964 {
965 char buff[4096];
966 va_list params;
967
968 if (level <= pvar->settings.LogLevel) {
969 va_start(params, fmt);
970 vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
971 va_end(params);
972
973 logputs(level, buff);
974 }
975 }
976
977 static void format_line_hexdump(char *buf, int buflen, int addr, int *bytes, int byte_cnt)
978 {
979 int i, c;
980 char tmp[128];
981
982 buf[0] = 0;
983
984 /* �������A�h���X�\�� */
985 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%08X : ", addr);
986 strncat_s(buf, buflen, tmp, _TRUNCATE);
987
988 /* �o�C�i���\���i4�o�C�g�������������}���j*/
989 for (i = 0; i < byte_cnt; i++) {
990 if (i > 0 && i % 4 == 0) {
991 strncat_s(buf, buflen, " ", _TRUNCATE);
992 }
993
994 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%02X", bytes[i]);
995 strncat_s(buf, buflen, tmp, _TRUNCATE);
996 }
997
998 /* ASCII�\���������������������� */
999 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " %*s%*s", (16 - byte_cnt) * 2 + 1, " ", (16 - byte_cnt + 3) / 4, " ");
1000 strncat_s(buf, buflen, tmp, _TRUNCATE);
1001
1002 /* ASCII�\�� */
1003 for (i = 0; i < byte_cnt; i++) {
1004 c = bytes[i];
1005 if (isprint(c)) {
1006 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%c", c);
1007 strncat_s(buf, buflen, tmp, _TRUNCATE);
1008 }
1009 else {
1010 strncat_s(buf, buflen, ".", _TRUNCATE);
1011 }
1012 }
1013
1014 //strncat_s(buf, buflen, "\n", _TRUNCATE);
1015 }
1016
1017 void logprintf_hexdump(int level, char *data, int len, char *fmt, ...)
1018 {
1019 char buff[4096];
1020 va_list params;
1021 int c, addr;
1022 int bytes[16], *ptr;
1023 int byte_cnt;
1024 int i;
1025
1026 if (level <= pvar->settings.LogLevel) {
1027 va_start(params, fmt);
1028 vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
1029 va_end(params);
1030
1031 logputs(level, buff);
1032
1033 addr = 0;
1034 byte_cnt = 0;
1035 ptr = bytes;
1036 for (i = 0; i < len; i++) {
1037 c = data[i];
1038 *ptr++ = c & 0xff;
1039 byte_cnt++;
1040
1041 if (byte_cnt == 16) {
1042 format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1043 logputs(level, buff);
1044
1045 addr += 16;
1046 byte_cnt = 0;
1047 ptr = bytes;
1048 }
1049 }
1050
1051 if (byte_cnt > 0) {
1052 format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1053 logputs(level, buff);
1054 }
1055 }
1056 }
1057
1058 static void PASCAL TTXOpenTCP(TTXSockHooks *hooks)
1059 {
1060 if (pvar->settings.Enabled) {
1061 // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
1062 pvar->origDisableTCPEchoCR = pvar->ts->DisableTCPEchoCR;
1063 pvar->ts->DisableTCPEchoCR = TRUE;
1064
1065 pvar->session_settings = pvar->settings;
1066
1067 logputs(LOG_LEVEL_VERBOSE, "---------------------------------------------------------------------");
1068 logputs(LOG_LEVEL_VERBOSE, "Initiating SSH session");
1069
1070 FWDUI_load_settings(pvar);
1071
1072 pvar->cv->TelAutoDetect = FALSE;
1073 /* This next line should not be needed because Tera Term's
1074 CommLib should find ts->Telnet == 0 ... but we'll do this
1075 just to be on the safe side. */
1076 pvar->cv->TelFlag = FALSE;
1077 pvar->cv->TelLineMode = FALSE;
1078
1079 pvar->Precv = *hooks->Precv;
1080 pvar->Psend = *hooks->Psend;
1081 pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
1082 pvar->Pconnect = *hooks->Pconnect;
1083 pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
1084
1085 *hooks->Precv = TTXrecv;
1086 *hooks->Psend = TTXsend;
1087 *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
1088 *hooks->Pconnect = TTXconnect;
1089
1090 SSH_open(pvar);
1091 HOSTS_open(pvar);
1092 FWDUI_open(pvar);
1093
1094 // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
1095 SSH2_update_cipher_myproposal(pvar);
1096 SSH2_update_kex_myproposal(pvar);
1097 SSH2_update_host_key_myproposal(pvar);
1098 SSH2_update_hmac_myproposal(pvar);
1099 SSH2_update_compression_myproposal(pvar);
1100 }
1101 }
1102
1103 static void PASCAL TTXCloseTCP(TTXSockHooks *hooks)
1104 {
1105 if (pvar->session_settings.Enabled) {
1106 pvar->socket = INVALID_SOCKET;
1107
1108 logputs(LOG_LEVEL_VERBOSE, "Terminating SSH session...");
1109
1110 *hooks->Precv = pvar->Precv;
1111 *hooks->Psend = pvar->Psend;
1112 *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
1113 *hooks->Pconnect = pvar->Pconnect;
1114
1115 pvar->ts->DisableTCPEchoCR = pvar->origDisableTCPEchoCR;
1116 }
1117
1118 uninit_TTSSH(pvar);
1119 init_TTSSH(pvar);
1120 }
1121
1122 static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
1123 {
1124 for (; from <= to; from++) {
1125 EnableWindow(GetDlgItem(dlg, from), enabled);
1126 }
1127 }
1128
1129 // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
1130 // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
1131 // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
1132 // �T�u�N���X�������������E�C���h�E�v���V�[�W��
1133 WNDPROC OrigHostnameEditProc; // Original window procedure
1134 LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
1135 WPARAM wParam, LPARAM lParam)
1136 {
1137 HWND parent;
1138 int max, select, len;
1139 char *str, *orgstr;
1140
1141 switch (msg) {
1142 // �L�[�����������������m����
1143 case WM_KEYDOWN:
1144 if (GetKeyState(VK_CONTROL) < 0) {
1145 switch (wParam) {
1146 case 0x50: // Ctrl+p ... up
1147 parent = GetParent(dlg);
1148 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1149 if (select > 0) {
1150 PostMessage(parent, CB_SETCURSEL, select - 1, 0);
1151 }
1152 return 0;
1153 case 0x4e: // Ctrl+n ... down
1154 parent = GetParent(dlg);
1155 max = SendMessage(parent, CB_GETCOUNT, 0, 0);
1156 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1157 if (select < max - 1) {
1158 PostMessage(parent, CB_SETCURSEL, select + 1, 0);
1159 }
1160 return 0;
1161 case 0x42: // Ctrl+b ... left
1162 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1163 PostMessage(dlg, EM_SETSEL, select-1, select-1);
1164 return 0;
1165 case 0x46: // Ctrl+f ... right
1166 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1167 max = GetWindowTextLength(dlg) ;
1168 PostMessage(dlg, EM_SETSEL, select+1, select+1);
1169 return 0;
1170 case 0x41: // Ctrl+a ... home
1171 PostMessage(dlg, EM_SETSEL, 0, 0);
1172 return 0;
1173 case 0x45: // Ctrl+e ... end
1174 max = GetWindowTextLength(dlg) ;
1175 PostMessage(dlg, EM_SETSEL, max, max);
1176 return 0;
1177
1178 case 0x44: // Ctrl+d
1179 case 0x4b: // Ctrl+k
1180 case 0x55: // Ctrl+u
1181 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1182 max = GetWindowTextLength(dlg);
1183 max++; // '\0'
1184 orgstr = str = malloc(max);
1185 if (str != NULL) {
1186 len = GetWindowText(dlg, str, max);
1187 if (select >= 0 && select < len) {
1188 if (wParam == 0x44) { // �J�[�\���z����������������������
1189 memmove(&str[select], &str[select + 1], len - select - 1);
1190 str[len - 1] = '\0';
1191
1192 } else if (wParam == 0x4b) { // �J�[�\�������s��������������
1193 str[select] = '\0';
1194
1195 }
1196 }
1197
1198 if (wParam == 0x55) { // �J�[�\����������������������
1199 if (select >= len) {
1200 str[0] = '\0';
1201 } else {
1202 str = &str[select];
1203 }
1204 select = 0;
1205 }
1206
1207 SetWindowText(dlg, str);
1208 SendMessage(dlg, EM_SETSEL, select, select);
1209 free(orgstr);
1210 return 0;
1211 }
1212 break;
1213 }
1214 }
1215 break;
1216
1217 // �����L�[��������������������������������������������
1218 case WM_CHAR:
1219 switch (wParam) {
1220 case 0x01:
1221 case 0x02:
1222 case 0x04:
1223 case 0x05:
1224 case 0x06:
1225 case 0x0b:
1226 case 0x0e:
1227 case 0x10:
1228 case 0x15:
1229 return 0;
1230 }
1231 }
1232
1233 return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
1234 }
1235
1236 static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
1237 LPARAM lParam)
1238 {
1239 static char *ssh_version[] = {"SSH1", "SSH2", NULL};
1240 PGetHNRec GetHNRec;
1241 char EntName[128];
1242 char TempHost[HostNameMaxLength + 1];
1243 WORD i, j, w;
1244 WORD ComPortTable[MAXCOMPORT];
1245 static char *ComPortDesc[MAXCOMPORT];
1246 int comports;
1247 BOOL Ok;
1248 LOGFONT logfont;
1249 HFONT font;
1250 char uimsg[MAX_UIMSG];
1251 static HWND hwndHostname = NULL; // HOSTNAME dropdown
1252 static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
1253
1254 switch (msg) {
1255 case WM_INITDIALOG:
1256 GetHNRec = (PGetHNRec) lParam;
1257 SetWindowLong(dlg, DWL_USER, lParam);
1258
1259 GetWindowText(dlg, uimsg, sizeof(uimsg));
1260 UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
1261 SetWindowText(dlg, pvar->ts->UIMsg);
1262 GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
1263 UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
1264 SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
1265 GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
1266 UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
1267 SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
1268 GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
1269 UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
1270 SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
1271 GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
1272 UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
1273 SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
1274 GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
1275 UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
1276 SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
1277 GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
1278 UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
1279 SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
1280 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
1281 UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
1282 SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
1283 GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
1284 UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
1285 SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
1286 GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
1287 UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
1288 SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
1289 GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
1290 UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
1291 SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
1292 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1293 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1294 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1295 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1296 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1297 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1298
1299 // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
1300 if (pvar->ts->HistoryList > 0) {
1301 SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
1302 } else {
1303 SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
1304 }
1305
1306 // �t�@�C�����������O�t���p�C�v�������ATCP/IP�����������B
1307 if (GetHNRec->PortType == IdFile ||
1308 GetHNRec->PortType == IdNamedPipe
1309 )
1310 GetHNRec->PortType = IdTCPIP;
1311
1312 strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
1313
1314 i = 1;
1315 do {
1316 _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
1317 GetPrivateProfileString("Hosts", EntName, "",
1318 TempHost, sizeof(TempHost),
1319 GetHNRec->SetupFN);
1320 if (strlen(TempHost) > 0)
1321 SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1322 0, (LPARAM) TempHost);
1323 i++;
1324 } while (i <= MAXHOSTLIST);
1325
1326 SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1327 HostNameMaxLength - 1, 0);
1328
1329 SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1330
1331 // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1332 hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1333 hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1334 OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1335 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1336
1337 CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1338 pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1339 Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1340 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1341 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1342 for (i = 0; ProtocolFamilyList[i]; ++i) {
1343 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1344 0, (LPARAM) ProtocolFamilyList[i]);
1345 }
1346 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1347 ProtocolFamilyMaxLength - 1, 0);
1348 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1349
1350 /////// SSH version
1351 for (i = 0; ssh_version[i]; ++i) {
1352 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1353 0, (LPARAM) ssh_version[i]);
1354 }
1355 SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1356 NUM_ELEM(ssh_version) - 1, 0);
1357
1358 if (pvar->settings.ssh_protocol_version == 1) {
1359 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1360 } else {
1361 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1362 }
1363
1364 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1365 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1366 } else {
1367 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1368 }
1369 /////// SSH version
1370
1371
1372 j = 0;
1373 w = 1;
1374 if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1375 for (i=0; i<comports; i++) {
1376 // MaxComPort ���z�����|�[�g���\��������
1377 if (ComPortTable[i] > GetHNRec->MaxComPort) {
1378 continue;
1379 }
1380
1381 // �g�p�����|�[�g���\��������
1382 if (CheckCOMFlag(ComPortTable[i]) == 1) {
1383 continue;
1384 }
1385
1386 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1387 if (ComPortDesc[i] != NULL) {
1388 strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1389 strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1390 }
1391 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1392 0, (LPARAM)EntName);
1393 j++;
1394 if (GetHNRec->ComPort == ComPortTable[i])
1395 w = j;
1396 }
1397
1398 } else {
1399 for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1400 // �g�p�����|�[�g���\��������
1401 if (CheckCOMFlag(i) == 1) {
1402 continue;
1403 }
1404
1405 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1406 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1407 0, (LPARAM) EntName);
1408 j++;
1409 if (GetHNRec->ComPort == i)
1410 w = j;
1411 }
1412 }
1413
1414 if (j > 0)
1415 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1416 else { /* All com ports are already used */
1417 GetHNRec->PortType = IdTCPIP;
1418 enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1419 }
1420
1421 CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1422 IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1423
1424 if (GetHNRec->PortType == IdTCPIP) {
1425 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1426
1427 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1428 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1429
1430 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // enabled
1431 }
1432 else {
1433 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1434 FALSE);
1435 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1436 IDC_HOSTTCPPROTOCOL, FALSE);
1437
1438 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1439 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1440
1441 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1442 }
1443
1444 // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1445 if (GetHNRec->PortType == IdTCPIP) {
1446 HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1447 SetFocus(hwnd);
1448 } else {
1449 HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1450 SetFocus(hwnd);
1451 }
1452
1453 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1454 GetObject(font, sizeof(LOGFONT), &logfont);
1455 if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
1456 SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1457 SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1458 SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1459 SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1460 SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1461 SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1462 SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1463 SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1464 SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1465 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1466 SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1467 SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1468 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1469 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1470 SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1471 SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1472 SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1473 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1474 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1475 SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1476 }
1477 else {
1478 DlgHostFont = NULL;
1479 }
1480
1481 // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1482 // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1483 // (2004.11.23 yutaka)
1484 return FALSE;
1485 //return TRUE;
1486
1487 case WM_COMMAND:
1488 switch (LOWORD(wParam)) {
1489 case IDOK:
1490 GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1491 if (GetHNRec != NULL) {
1492 if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1493 char afstr[BUFSIZ];
1494 i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1495 if (Ok) {
1496 GetHNRec->TCPPort = i;
1497 } else {
1498 UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1499 "The TCP port must be a number.");
1500 MessageBox(dlg, pvar->ts->UIMsg,
1501 "Tera Term", MB_OK | MB_ICONEXCLAMATION);
1502 return TRUE;
1503 }
1504 #define getaf(str) \
1505 ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1506 ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1507 memset(afstr, 0, sizeof(afstr));
1508 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1509 sizeof(afstr));
1510 GetHNRec->ProtocolFamily = getaf(afstr);
1511 GetHNRec->PortType = IdTCPIP;
1512 GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1513 HostNameMaxLength);
1514 pvar->hostdlg_activated = TRUE;
1515 pvar->hostdlg_Enabled = FALSE;
1516 if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1517 GetHNRec->Telnet = TRUE;
1518 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1519 pvar->hostdlg_Enabled = TRUE;
1520
1521 // check SSH protocol version
1522 memset(afstr, 0, sizeof(afstr));
1523 GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1524 if (_stricmp(afstr, "SSH1") == 0) {
1525 pvar->settings.ssh_protocol_version = 1;
1526 } else {
1527 pvar->settings.ssh_protocol_version = 2;
1528 }
1529 }
1530 else { // IDC_HOSTOTHER
1531 GetHNRec->Telnet = FALSE;
1532 }
1533
1534 // host history check button
1535 if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1536 pvar->ts->HistoryList = 1;
1537 } else {
1538 pvar->ts->HistoryList = 0;
1539 }
1540
1541 } else {
1542 GetHNRec->PortType = IdSerial;
1543 GetHNRec->HostName[0] = 0;
1544 memset(EntName, 0, sizeof(EntName));
1545 GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1546 sizeof(EntName) - 1);
1547 if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1548 GetHNRec->ComPort = atoi(&EntName[3]);
1549 if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1550 GetHNRec->ComPort = 1;
1551 } else {
1552 GetHNRec->ComPort = 1;
1553 }
1554 }
1555 }
1556 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1557 EndDialog(dlg, 1);
1558
1559 if (DlgHostFont != NULL) {
1560 DeleteObject(DlgHostFont);
1561 }
1562
1563 return TRUE;
1564
1565 case IDCANCEL:
1566 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1567 EndDialog(dlg, 0);
1568
1569 if (DlgHostFont != NULL) {
1570 DeleteObject(DlgHostFont);
1571 }
1572
1573 return TRUE;
1574
1575 case IDC_HOSTTCPIP:
1576 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1577 TRUE);
1578 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1579 IDC_HOSTTCPPROTOCOL, TRUE);
1580 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1581
1582 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1583 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1584 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1585 } else {
1586 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1587 }
1588
1589 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1590
1591 return TRUE;
1592
1593 case IDC_HOSTSERIAL:
1594 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1595 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1596 FALSE);
1597 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1598 IDC_HOSTTCPPROTOCOL, FALSE);
1599 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1600 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1601
1602 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1603
1604 return TRUE;
1605
1606 case IDC_HOSTSSH:
1607 enable_dlg_items(dlg, IDC_SSH_VERSION,
1608 IDC_SSH_VERSION, TRUE);
1609 goto hostssh_enabled;
1610
1611 case IDC_HOSTTELNET:
1612 case IDC_HOSTOTHER:
1613 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1614 hostssh_enabled:
1615
1616 GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1617
1618 if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1619 if (GetHNRec != NULL)
1620 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1621 FALSE);
1622 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1623 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1624 }
1625 return TRUE;
1626
1627 case IDC_HOSTCOM:
1628 if(HIWORD(wParam) == CBN_DROPDOWN) {
1629 HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1630 int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1631 int i, len, max_len = 0;
1632 char *lbl;
1633 HDC TmpDC = GetDC(hostcom);
1634 SIZE s;
1635 for (i=0; i<count; i++) {
1636 len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1637 lbl = (char *)calloc(len+1, sizeof(char));
1638 SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1639 GetTextExtentPoint32(TmpDC, lbl, len, &s);
1640 if (s.cx > max_len)
1641 max_len = s.cx;
1642 free(lbl);
1643 }
1644 SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1645 max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1646 }
1647 break;
1648
1649 case IDC_HOSTHELP:
1650 PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1651 }
1652 }
1653 return FALSE;
1654 }
1655
1656 static BOOL PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1657 {
1658 return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1659 parent, TTXHostDlg, (LONG) rec);
1660 }
1661
1662 static void PASCAL TTXGetUIHooks(TTXUIHooks *hooks)
1663 {
1664 *hooks->GetHostName = TTXGetHostName;
1665 }
1666
1667 static void PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1668 {
1669 (pvar->ReadIniFile) (fileName, ts);
1670 read_ssh_options(pvar, fileName);
1671 pvar->settings = *pvar->ts_SSH;
1672 logputs(LOG_LEVEL_VERBOSE, "Reading INI file");
1673 FWDUI_load_settings(pvar);
1674 }
1675
1676 static void PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1677 {
1678 (pvar->WriteIniFile) (fileName, ts);
1679 *pvar->ts_SSH = pvar->settings;
1680 clear_local_settings(pvar);
1681 logputs(LOG_LEVEL_VERBOSE, "Writing INI file");
1682 write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1683 }
1684
1685 static void read_ssh_options_from_user_file(PTInstVar pvar,
1686 char *user_file_name)
1687 {
1688 if (user_file_name[0] == '.') {
1689 read_ssh_options(pvar, user_file_name);
1690 } else {
1691 char buf[1024];
1692
1693 get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1694 read_ssh_options(pvar, buf);
1695 }
1696
1697 pvar->settings = *pvar->ts_SSH;
1698 FWDUI_load_settings(pvar);
1699 }
1700
1701 // Percent-encode������������src���f�R�[�h����dst���R�s�[�����B
1702 // dstlen��dst���T�C�Y�B�����������������������A�����������������������B
1703 static void percent_decode(char *dst, int dstlen, char *src) {
1704 if (src == NULL || dst == NULL || dstlen < 1) {
1705 return;
1706 }
1707
1708 while (*src != 0 && dstlen > 1) {
1709 if (*src == '%' && isxdigit(*(src+1)) && isxdigit(*(src+2))) {
1710 src++; *dst = (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0') << 4;
1711 src++; *dst |= (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0');
1712 src++; dst++;
1713 }
1714 else {
1715 *dst++ = *src++;
1716 }
1717 dstlen--;
1718 }
1719 *dst = 0;
1720 return;
1721 }
1722
1723 void add_forward_param(PTInstVar pvar, char *param)
1724 {
1725 if (pvar->settings.DefaultForwarding[0] == 0) {
1726 strncpy_s(pvar->settings.DefaultForwarding,
1727 sizeof(pvar->settings.DefaultForwarding),
1728 param, _TRUNCATE);
1729 } else {
1730 strncat_s(pvar->settings.DefaultForwarding,
1731 sizeof(pvar->settings.DefaultForwarding),
1732 ";", _TRUNCATE);
1733 strncat_s(pvar->settings.DefaultForwarding,
1734 sizeof(pvar->settings.DefaultForwarding),
1735 param, _TRUNCATE);
1736 }
1737 }
1738
1739 static void PASCAL TTXParseParam(PCHAR param, PTTSet ts, PCHAR DDETopic) {
1740 int param_len=strlen(param);
1741 int opt_len = param_len+1;
1742 char *option = (char *)calloc(opt_len, sizeof(char));
1743 char *option2 = (char *)calloc(opt_len, sizeof(char));
1744 int action;
1745 PCHAR start, cur, next;
1746 size_t i;
1747
1748 if (pvar->hostdlg_activated) {
1749 pvar->settings.Enabled = pvar->hostdlg_Enabled;
1750 }
1751
1752 /* the first term shuld be executable filename of Tera Term */
1753 start = GetParam(option, opt_len, param);
1754
1755 cur = start;
1756 while (next = GetParam(option, opt_len, cur)) {
1757 DequoteParam(option, opt_len, option);
1758 action = OPTION_NONE;
1759
1760 if ((option[0] == '-' || option[0] == '/')) {
1761 if (MATCH_STR(option + 1, "ssh") == 0) {
1762 if (MATCH_STR(option + 4, "-f=") == 0) {
1763 strncpy_s(option2, opt_len, option + 7, _TRUNCATE);
1764 read_ssh_options_from_user_file(pvar, option2);
1765 action = OPTION_CLEAR;
1766 } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1767 strncpy_s(option2, opt_len, option + 13, _TRUNCATE);
1768 read_ssh_options_from_user_file(pvar, option2);
1769 DeleteFile(option2);
1770 action = OPTION_CLEAR;
1771 }
1772
1773 // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1774 } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1775 strncpy_s(option2, opt_len, option + 3, _TRUNCATE);
1776 read_ssh_options_from_user_file(pvar, option2);
1777 // Tera Term���������������K�v������������������
1778 }
1779 }
1780
1781 switch (action) {
1782 case OPTION_CLEAR:
1783 memset(cur, ' ', next-cur);
1784 break;
1785 case OPTION_REPLACE:
1786 memset(cur, ' ', next-cur);
1787 memcpy(cur+1, option, strlen(option));
1788 break;
1789 }
1790
1791 cur = next;
1792 }
1793
1794 cur = start;
1795 while (next = GetParam(option, opt_len, cur)) {
1796 DequoteParam(option, opt_len, option);
1797 action = OPTION_NONE;
1798
1799 if ((option[0] == '-' || option[0] == '/')) {
1800 action = OPTION_CLEAR;
1801 if (MATCH_STR(option + 1, "ssh") == 0) {
1802 if (option[4] == 0) {
1803 pvar->settings.Enabled = 1;
1804 } else if (MATCH_STR(option + 4, "-L") == 0 ||
1805 MATCH_STR(option + 4, "-R") == 0 ||
1806 MATCH_STR(option + 4, "-D") == 0) {
1807 char *p = option + 5;
1808 option2[0] = *p;
1809 i = 1;
1810 while (*++p) {
1811 if (*p == ';' || *p == ',') {
1812 option2[i] = 0;
1813 add_forward_param(pvar, option2);
1814 i = 1;
1815 }
1816 else {
1817 option2[i++] = *p;
1818 }
1819 }
1820 if (i > 1) {
1821 option2[i] = 0;
1822 add_forward_param(pvar, option2);
1823 }
1824 } else if (MATCH_STR(option + 4, "-X") == 0) {
1825 add_forward_param(pvar, "X");
1826 if (option+6 != 0) {
1827 strncpy_s(pvar->settings.X11Display,
1828 sizeof(pvar->settings.X11Display),
1829 option + 6, _TRUNCATE);
1830 }
1831 } else if (strcmp(option + 4, "-v") == 0) {
1832 pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1833 } else if (_stricmp(option + 4, "-autologin") == 0 ||
1834 _stricmp(option + 4, "-autologon") == 0) {
1835 pvar->settings.TryDefaultAuth = TRUE;
1836 } else if (MATCH_STR_I(option + 4, "-agentconfirm=") == 0) {
1837 if ((_stricmp(option+18, "off") == 0) ||
1838 (_stricmp(option+18, "no") == 0) ||
1839 (_stricmp(option+18, "false") == 0) ||
1840 (_stricmp(option+18, "0") == 0) ||
1841 (_stricmp(option+18, "n") == 0)) {
1842 pvar->settings.ForwardAgentConfirm = 0;
1843 }
1844 else {
1845 pvar->settings.ForwardAgentConfirm = 1;
1846 }
1847 } else if (strcmp(option + 4, "-a") == 0) {
1848 pvar->settings.ForwardAgent = FALSE;
1849 } else if (strcmp(option + 4, "-A") == 0) {
1850 pvar->settings.ForwardAgent = TRUE;
1851
1852 } else if (MATCH_STR(option + 4, "-C=") == 0) {
1853 pvar->settings.CompressionLevel = atoi(option+7);
1854 if (pvar->settings.CompressionLevel < 0) {
1855 pvar->settings.CompressionLevel = 0;
1856 }
1857 else if (pvar->settings.CompressionLevel > 9) {
1858 pvar->settings.CompressionLevel = 9;
1859 }
1860 } else if (strcmp(option + 4, "-C") == 0) {
1861 pvar->settings.CompressionLevel = 6;
1862 } else if (strcmp(option + 4, "-c") == 0) {
1863 pvar->settings.CompressionLevel = 0;
1864 } else if (MATCH_STR_I(option + 4, "-icon=") == 0) {
1865 if ((_stricmp(option+10, "old") == 0) ||
1866 (_stricmp(option+10, "yellow") == 0) ||
1867 (_stricmp(option+10, "securett_yellow") == 0)) {
1868 pvar->settings.IconID = IDI_SECURETT_YELLOW;
1869 }
1870 else if ((_stricmp(option+10, "green") == 0) ||
1871 (_stricmp(option+10, "securett_green") == 0)) {
1872 pvar->settings.IconID = IDI_SECURETT_GREEN;
1873 }
1874 else {
1875 pvar->settings.IconID = IDI_SECURETT;
1876 }
1877 } else if (MATCH_STR(option + 4, "-subsystem=") == 0) {
1878 pvar->use_subsystem = TRUE;
1879 strncpy_s(pvar->subsystem_name,
1880 sizeof(pvar->subsystem_name),
1881 option + 15, _TRUNCATE);
1882
1883 // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1884 } else if (strcmp(option + 4, "1") == 0) {
1885 pvar->settings.Enabled = 1;
1886 pvar->settings.ssh_protocol_version = 1;
1887 } else if (strcmp(option + 4, "2") == 0) {
1888 pvar->settings.Enabled = 1;
1889 pvar->settings.ssh_protocol_version = 2;
1890
1891 } else {
1892 char buf[1024];
1893
1894 UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1895 "Unrecognized command-line option: %s");
1896 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1897
1898 MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1899 }
1900
1901 // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1902 } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1903 if (strcmp(option + 3, "2") == 0) {
1904 pvar->settings.Enabled = 1;
1905 // /t=2��ttssh�������g������������
1906 } else {
1907 pvar->settings.Enabled = 0;
1908 action = OPTION_NONE; // Tera Term������������������������
1909 }
1910
1911 // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1912 } else if (strcmp(option + 1, "1") == 0) {
1913 // command line: /ssh /1 is SSH1 only
1914 pvar->settings.ssh_protocol_version = 1;
1915
1916 } else if (strcmp(option + 1, "2") == 0) {
1917 // command line: /ssh /2 is SSH2 & SSH1
1918 pvar->settings.ssh_protocol_version = 2;
1919
1920 } else if (strcmp(option + 1, "nossh") == 0) {
1921 // '/nossh' �I�v�V�����������B
1922 // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1923 // �����������������B(2004.10.11 yutaka)
1924 pvar->settings.Enabled = 0;
1925
1926 } else if (strcmp(option + 1, "telnet") == 0) {
1927 // '/telnet' ���w�������������������� '/nossh' ��������
1928 // SSH������������ (2006.9.16 maya)
1929 pvar->settings.Enabled = 0;
1930 // Tera Term �� Telnet �t���O���t����
1931 pvar->ts->Telnet = 1;
1932
1933 } else if (MATCH_STR(option + 1, "auth=") == 0) {
1934 // SSH2�������O�C���I�v�V����������
1935 //
1936 // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1937 // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1938 // EXAMPLE: /ssh /auth=password /user=nike /passwd="a b""c" ; �p�X���[�h: �ua b"c�v
1939 // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1940 // NOTICE: �p�X���[�h���p�X���������Z�~�R���������������������_�u���N�H�[�g " ������
1941 // �p�X���[�h���_�u���N�H�[�g�����������������A�������_�u���N�H�[�g "" ���u��������
1942 //
1943 pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1944
1945 if (_stricmp(option + 6, "password") == 0) { // �p�X���[�h
1946 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1947 pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1948
1949 } else if (_stricmp(option + 6, "keyboard-interactive") == 0) { // keyboard-interactive�F��
1950 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1951 pvar->ssh2_authmethod = SSH_AUTH_TIS;
1952
1953 } else if (_stricmp(option + 6, "challenge") == 0) { // keyboard-interactive�F��
1954 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1955 pvar->ssh2_authmethod = SSH_AUTH_TIS;
1956
1957 } else if (_stricmp(option + 6, "publickey") == 0) { // ���J���F��
1958 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1959 pvar->ssh2_authmethod = SSH_AUTH_RSA;
1960
1961 } else if (_stricmp(option + 6, "pageant") == 0) { // ���J���F�� by Pageant
1962 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1963 pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1964
1965 } else {
1966 // TODO:
1967 }
1968
1969 } else if (MATCH_STR(option + 1, "user=") == 0) {
1970 _snprintf_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), _TRUNCATE, "%s", option+6);
1971
1972 } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1973 _snprintf_s(pvar->ssh2_password, sizeof(pvar->ssh2_password), _TRUNCATE, "%s", option+8);
1974
1975 } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1976 _snprintf_s(pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile), _TRUNCATE, "%s", option+9);
1977
1978 } else if (strcmp(option + 1, "ask4passwd") == 0) {
1979 // �p�X���[�h������ (2006.9.18 maya)
1980 pvar->ask4passwd = 1;
1981
1982 } else if (strcmp(option + 1, "nosecuritywarning") == 0) {
1983 // known_hosts�`�F�b�N���������B���Y�I�v�V�������g�����A�Z�L�����e�B������������
1984 // �����A�B���I�v�V���������������B
1985 // (2009.10.4 yutaka)
1986 pvar->nocheck_known_hosts = TRUE;
1987
1988 }
1989 else { // Other (not ttssh) option
1990 action = OPTION_NONE; // ttssh���I�v�V������������������������
1991 }
1992
1993 // �p�X���[�h�������������������O�C��������������
1994 // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1995 if (pvar->ask4passwd == 1) {
1996 pvar->ssh2_autologin = 0;
1997 }
1998
1999 }
2000 else if ((MATCH_STR_I(option, "ssh://") == 0) ||
2001 (MATCH_STR_I(option, "ssh1://") == 0) ||
2002 (MATCH_STR_I(option, "ssh2://") == 0) ||
2003 (MATCH_STR_I(option, "slogin://") == 0) ||
2004 (MATCH_STR_I(option, "slogin1://") == 0) ||
2005 (MATCH_STR_I(option, "slogin2://") == 0)) {
2006 //
2007 // ssh://user@host/ ����URL�`�����T�|�[�g
2008 // ���{�I�������� telnet:// URL��������
2009 //
2010 // �Q�l:
2011 // RFC3986: Uniform Resource Identifier (URI): Generic Syntax
2012 // RFC4248: The telnet URI Scheme
2013 //
2014 char *p, *p2, *p3;
2015 int optlen, hostlen;
2016
2017 optlen = strlen(option);
2018
2019 // ������':'���O�����������������������A������ssh�v���g�R���o�[�W������������
2020 p = _mbschr(option, ':');
2021 switch (*(p-1)) {
2022 case '1':
2023 pvar->settings.ssh_protocol_version = 1;
2024 break;
2025 case '2':
2026 pvar->settings.ssh_protocol_version = 2;
2027 break;
2028 }
2029
2030 // authority part �����|�C���^������
2031 p += 3;
2032
2033 // path part ������������
2034 if ((p2 = _mbschr(p, '/')) != NULL) {
2035 *p2 = 0;
2036 }
2037
2038 // '@'�������������A���������O�����[�U����
2039 if ((p2 = _mbschr(p, '@')) != NULL) {
2040 *p2 = 0;
2041 // ':'���~���p�X���[�h
2042 if ((p3 = _mbschr(p, ':')) != NULL) {
2043 *p3 = 0;
2044 percent_decode(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
2045 }
2046 percent_decode(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
2047 // p �� host part ������('@'����������)����������������
2048 p = p2 + 1;
2049 }
2050
2051 // host part �� option �����������������Ascheme part ������
2052 // port�w����������������port���������������������m��������������
2053 hostlen = strlen(p);
2054 memmove_s(option, optlen, p, hostlen);
2055 option[hostlen] = 0;
2056
2057 // �|�[�g�w������������":22"������
2058 if (option[0] == '[' && option[hostlen-1] == ']' || // IPv6 raw address without port
2059 option[0] != '[' && _mbschr(option, ':') == NULL) { // hostname or IPv4 raw address without port
2060 memcpy_s(option+hostlen, optlen-hostlen, ":22", 3);
2061 hostlen += 3;
2062 }
2063
2064 // �|�[�g�w�����������������X�y�[�X������
2065 memset(option+hostlen, ' ', optlen-hostlen);
2066
2067 pvar->settings.Enabled = 1;
2068
2069 action = OPTION_REPLACE;
2070 }
2071 else if (_mbschr(option, '@') != NULL) {
2072 //
2073 // user@host �`�����T�|�[�g
2074 // ����������ssh�������T�|�[�g�����A���[�U����ttssh���������B
2075 // (ssh�������O -- ttssh�������W������������)
2076 // �����I��telnet authentication option���T�|�[�g��������
2077 // Tera Term�{�����������������������\���B
2078 //
2079 char *p;
2080 p = _mbschr(option, '@');
2081 *p = 0;
2082
2083 strncpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), option, _TRUNCATE);
2084
2085 // ���[�U���������X�y�[�X�������B
2086 // ������TTX��Tera Term�{�������������������X�y�[�X�����������������A
2087 // �z�X�g�����������l�����K�v�������B
2088 memset(option, ' ', p-option+1);
2089
2090 action = OPTION_REPLACE;
2091 }
2092
2093
2094 switch (action) {
2095 case OPTION_CLEAR:
2096 memset(cur, ' ', next-cur);
2097 break;
2098 case OPTION_REPLACE:
2099 memset(cur, ' ', next-cur);
2100 memcpy(cur+1, option, strlen(option));
2101 break;
2102 }
2103
2104 cur = next;
2105 }
2106
2107 free(option);
2108
2109 FWDUI_load_settings(pvar);
2110
2111 (pvar->ParseParam) (param, ts, DDETopic);
2112 }
2113
2114 static void PASCAL TTXGetSetupHooks(TTXSetupHooks *hooks)
2115 {
2116 pvar->ReadIniFile = *hooks->ReadIniFile;
2117 pvar->WriteIniFile = *hooks->WriteIniFile;
2118 pvar->ParseParam = *hooks->ParseParam;
2119
2120 *hooks->ReadIniFile = TTXReadINIFile;
2121 *hooks->WriteIniFile = TTXWriteINIFile;
2122 *hooks->ParseParam = TTXParseParam;
2123 }
2124
2125 static void PASCAL TTXSetWinSize(int rows, int cols)
2126 {
2127 SSH_notify_win_size(pvar, cols, rows);
2128 }
2129
2130 static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
2131 WORD newItemID, char *text)
2132 {
2133 int i, j;
2134
2135 for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
2136 HMENU submenu = GetSubMenu(menu, i);
2137
2138 for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
2139 if (GetMenuItemID(submenu, j) == beforeItemID) {
2140 InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
2141 return;
2142 }
2143 }
2144 }
2145 }
2146
2147 #define GetFileMenu(menu) GetSubMenuByChildID(menu, 50110) // ID_FILE_NEWCONNECTION
2148 #define GetEditMenu(menu) GetSubMenuByChildID(menu, 50210) // ID_EDIT_COPY2
2149 #define GetSetupMenu(menu) GetSubMenuByChildID(menu, 50310) // ID_SETUP_TERMINAL
2150 #define GetControlMenu(menu) GetSubMenuByChildID(menu, 50410) // ID_CONTROL_RESETTERMINAL
2151 #define GetHelpMenu(menu) GetSubMenuByChildID(menu, 50990) // ID_HELP_ABOUT
2152
2153 HMENU GetSubMenuByChildID(HMENU menu, UINT id) {
2154 int i, j, items, subitems, cur_id;
2155 HMENU m;
2156
2157 items = GetMenuItemCount(menu);
2158
2159 for (i=0; i<items; i++) {
2160 if (m = GetSubMenu(menu, i)) {
2161 subitems = GetMenuItemCount(m);
2162 for (j=0; j<subitems; j++) {
2163 cur_id = GetMenuItemID(m, j);
2164 if (cur_id == id) {
2165 return m;
2166 }
2167 }
2168 }
2169 }
2170 return NULL;
2171 }
2172
2173 static void PASCAL TTXModifyMenu(HMENU menu)
2174 {
2175 pvar->FileMenu = GetFileMenu(menu);
2176
2177 /* inserts before ID_HELP_ABOUT */
2178 UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
2179 insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
2180
2181 /* inserts before ID_SETUP_TCPIP */
2182 UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
2183 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
2184 /* inserts before ID_SETUP_TCPIP */
2185 UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
2186 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
2187 /* inserts before ID_SETUP_TCPIP */
2188 UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
2189 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
2190 UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
2191 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
2192
2193 /* inserts before ID_FILE_CHANGEDIR */
2194 UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SS&H SCP...");
2195 insertMenuBeforeItem(menu, 50170, MF_GRAYED, ID_SSHSCPMENU, pvar->ts->UIMsg);
2196 }
2197
2198 static void PASCAL TTXModifyPopupMenu(HMENU menu) {
2199 if (menu == pvar->FileMenu) {
2200 if (pvar->cv->Ready && pvar->socket != INVALID_SOCKET)
2201 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_ENABLED);
2202 else
2203 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_GRAYED);
2204 }
2205 }
2206
2207 static void about_dlg_set_abouttext(PTInstVar pvar, HWND dlg, digest_algorithm dgst_alg)
2208 {
2209 char buf[1024], buf2[2048];
2210 char *fp = NULL;
2211
2212 // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
2213 if (pvar->socket != INVALID_SOCKET) {
2214 buf2[0] = '\0';
2215
2216 if (SSHv1(pvar)) {
2217 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2218 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2219 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2220 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2221 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2222 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2223
2224 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2225 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2226 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2227 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2228 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2229 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2230
2231 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2232 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2233 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2234 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2235 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2236 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2237
2238 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys:");
2239 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2240 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2241 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2242 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2243 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2244
2245 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
2246 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2247 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2248 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2249 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2250 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2251
2252 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
2253 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2254 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2255 SSH_get_compression_info(pvar, buf, sizeof(buf));
2256 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2257 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2258
2259 } else { // SSH2
2260 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2261 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2262 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2263 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2264 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2265 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2266
2267 UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID:");
2268 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2269 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2270 strncat_s(buf2, sizeof(buf2), pvar->client_version_string, _TRUNCATE);
2271 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2272
2273 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2274 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2275 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2276 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2277 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2278 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2279
2280 UTIL_get_lang_msg("DLG_ABOUT_KEX", pvar, "Key exchange algorithm:");
2281 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2282 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2283 strncat_s(buf2, sizeof(buf2), get_kex_algorithm_name(pvar->kex_type), _TRUNCATE);
2284 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2285
2286 UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key:");
2287 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2288 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2289 strncat_s(buf2, sizeof(buf2), get_ssh_keytype_name(pvar->hostkey_type), _TRUNCATE);
2290 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2291
2292 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2293 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2294 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2295 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2296 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2297 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2298
2299 UTIL_get_lang_msg("DLG_ABOUT_MAC", pvar, "MAC algorithm:");
2300 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2301 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2302 SSH_get_mac_info(pvar, buf, sizeof(buf));
2303 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2304 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2305
2306 if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
2307 UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression:");
2308 }
2309 else {
2310 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
2311 }
2312 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2313 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2314 SSH_get_compression_info(pvar, buf, sizeof(buf));
2315 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2316 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2317
2318 UTIL_get_lang_msg("DLG_ABOUT_KEXKEY", pvar, "Key exchange keys:");
2319 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2320 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2321 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2322 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2323 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2324
2325 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
2326 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2327 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2328 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2329 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2330 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2331 }
2332
2333 // �z�X�g���J����fingerprint���\�������B
2334 // (2014.5.1 yutaka)
2335 UTIL_get_lang_msg("DLG_ABOUT_FINGERPRINT", pvar, "Host key's fingerprint:");
2336 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2337 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2338
2339 switch (dgst_alg) {
2340 case SSH_DIGEST_MD5:
2341 fp = key_fingerprint(&pvar->hosts_state.hostkey, SSH_FP_HEX, dgst_alg);
2342 strncat_s(buf2, sizeof(buf2), fp, _TRUNCATE);
2343 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2344 free(fp);
2345 break;
2346 case SSH_DIGEST_SHA256:
2347 default:
2348 fp = key_fingerprint(&pvar->hosts_state.hostkey, SSH_FP_BASE64, SSH_DIGEST_SHA256);
2349 if (fp != NULL) {
2350 strncat_s(buf2, sizeof(buf2), fp, _TRUNCATE);
2351 free(fp);
2352 }
2353 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2354 break;
2355 }
2356
2357 fp = key_fingerprint(&pvar->hosts_state.hostkey, SSH_FP_RANDOMART, dgst_alg);
2358 strncat_s(buf2, sizeof(buf2), fp, _TRUNCATE);
2359 free(fp);
2360
2361 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETTEXT, 0, (LPARAM)(char *)buf2);
2362 }
2363 }
2364
2365 static void init_about_dlg(PTInstVar pvar, HWND dlg)
2366 {
2367 char buf[1024];
2368 char uimsg[MAX_UIMSG];
2369
2370 GetWindowText(dlg, uimsg, sizeof(uimsg));
2371 UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
2372 SetWindowText(dlg, pvar->ts->UIMsg);
2373 GetDlgItemText(dlg, IDC_FP_HASH_ALG, uimsg, sizeof(uimsg));
2374 UTIL_get_lang_msg("DLG_ABOUT_FP_HASH_ALGORITHM", pvar, uimsg);
2375 SetDlgItemText(dlg, IDC_FP_HASH_ALG, pvar->ts->UIMsg);
2376 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2377 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2378 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2379
2380 // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
2381 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
2382 "TTSSH\r\nTera Term Secure Shell extension, %d.%d", TTSSH_VERSION_MAJOR, TTSSH_VERSION_MINOR);
2383 SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2384
2385 // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
2386 // ���������� (2005.5.11 yutaka)
2387 // OPENSSL_VERSION_TEXT �}�N�����`���������A�������g�����o�[�W���������������B(2013.11.24 yutaka)
2388 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)SSLeay_version(SSLEAY_VERSION));
2389
2390 // zlib���o�[�W�������������� (2005.5.11 yutaka)
2391 #ifdef ZLIB_VERSION
2392 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
2393 #else
2394 _snprintf(buf, sizeof(buf), "ZLib Unknown");
2395 #endif
2396 SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2397
2398 // PuTTY���o�[�W�������������� (2011.7.26 yutaka)
2399 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "PuTTY %s", putty_get_version());
2400 SendMessage(GetDlgItem(dlg, IDC_PUTTY_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2401 }
2402
2403 // WM_MOUSEWHEEL �� winuser.h �w�b�_���������������������A#define _WIN32_WINNT 0x0400 ���������������������F�������������B
2404 #define WM_MOUSEWHEEL 0x020A
2405 #define WHEEL_DELTA 120
2406 #define GET_WHEEL_DELTA_WPARAM(wParam) ((short)HIWORD(wParam))
2407 #define GET_KEYSTATE_WPARAM(wParam) (LOWORD(wParam))
2408
2409 static WNDPROC g_defAboutDlgEditWndProc; // Edit Control���T�u�N���X���p
2410 static int g_deltaSumAboutDlg = 0; // �}�E�X�z�C�[����Delta�����p
2411
2412 static LRESULT CALLBACK AboutDlgEditWindowProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
2413 {
2414 WORD keys;
2415 short delta;
2416 BOOL page;
2417
2418 switch (msg) {
2419 case WM_KEYDOWN:
2420 // Edit control���� CTRL+A �������������A�e�L�X�g���S�I�������B
2421 if (wp == 'A' && GetKeyState(VK_CONTROL) < 0) {
2422 PostMessage(hWnd, EM_SETSEL, 0, -1);
2423 return 0;
2424 }
2425 break;
2426
2427 case WM_MOUSEWHEEL:
2428 // CTRLorSHIFT + �}�E�X�z�C�[���������A���X�N���[���������B
2429 keys = GET_KEYSTATE_WPARAM(wp);
2430 delta = GET_WHEEL_DELTA_WPARAM(wp);
2431 page = keys & (MK_CONTROL | MK_SHIFT);
2432
2433 if (page == 0)
2434 break;
2435
2436 g_deltaSumAboutDlg += delta;
2437
2438 if (g_deltaSumAboutDlg >= WHEEL_DELTA) {
2439 g_deltaSumAboutDlg -= WHEEL_DELTA;
2440 SendMessage(hWnd, WM_HSCROLL, SB_PAGELEFT , 0);
2441 } else if (g_deltaSumAboutDlg <= -WHEEL_DELTA) {
2442 g_deltaSumAboutDlg += WHEEL_DELTA;
2443 SendMessage(hWnd, WM_HSCROLL, SB_PAGERIGHT, 0);
2444 }
2445
2446 break;
2447 }
2448 return CallWindowProc(g_defAboutDlgEditWndProc, hWnd, msg, wp, lp);
2449 }
2450
2451 static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
2452 LPARAM lParam)
2453 {
2454 LOGFONT logfont;
2455 HFONT font;
2456
2457 switch (msg) {
2458 case WM_INITDIALOG:
2459 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
2460 GetObject(font, sizeof(LOGFONT), &logfont);
2461 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
2462 SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2463 SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2464 SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2465 SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2466 SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2467 SendDlgItemMessage(dlg, IDC_PUTTY_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2468 SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2469 SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2470 SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2471 SendDlgItemMessage(dlg, IDC_FP_HASH_ALG, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2472 SendDlgItemMessage(dlg, IDC_FP_HASH_ALG_MD5, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2473 SendDlgItemMessage(dlg, IDC_FP_HASH_ALG_SHA256, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2474 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2475 }
2476 else {
2477 DlgAboutFont = NULL;
2478 }
2479
2480 // Edit control�������t�H���g���\�������������A���������������t�H���g���Z�b�g�����B
2481 // (2014.5.5. yutaka)
2482 if (UTIL_get_lang_font("DLG_ABOUT_FONT", dlg, &logfont, &DlgAboutTextFont, pvar)) {
2483 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutTextFont, MAKELPARAM(TRUE,0));
2484 } else {
2485 // ���������������������������t�H���g���w�������B
2486 // �G�f�B�b�g�R���g���[�����_�C�A���O�������t�H���g������������
2487 // �����t�H���g�������������B
2488 strncpy_s(logfont.lfFaceName, sizeof(logfont.lfFaceName), "Courier New", _TRUNCATE);
2489 logfont.lfCharSet = 0;
2490 logfont.lfHeight = MulDiv(8, GetDeviceCaps(GetDC(dlg),LOGPIXELSY) * -1, 72);
2491 logfont.lfWidth = 0;
2492 if ((DlgAboutTextFont = CreateFontIndirect(&logfont)) != NULL) {
2493 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutTextFont, MAKELPARAM(TRUE,0));
2494 }
2495 else {
2496 DlgAboutTextFont = NULL;
2497 }
2498 }
2499
2500 // �A�C�R�������I���Z�b�g
2501 {
2502 int fuLoad = LR_DEFAULTCOLOR;
2503 HICON hicon;
2504
2505 if (IsWindowsNT4()) {
2506 fuLoad = LR_VGACOLOR;
2507 }
2508
2509 hicon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
2510 IMAGE_ICON, 32, 32, fuLoad);
2511 SendDlgItemMessage(dlg, IDC_TTSSH_ICON, STM_SETICON, (WPARAM)hicon, 0);
2512 }
2513
2514 init_about_dlg(pvar, dlg);
2515 CheckDlgButton(dlg, IDC_FP_HASH_ALG_SHA256, TRUE);
2516 about_dlg_set_abouttext(pvar, dlg, SSH_DIGEST_SHA256);
2517 SetFocus(GetDlgItem(dlg, IDOK));
2518
2519 // Edit control���T�u�N���X�������B
2520 g_deltaSumAboutDlg = 0;
2521 g_defAboutDlgEditWndProc = (WNDPROC)SetWindowLongPtr(GetDlgItem(dlg, IDC_ABOUTTEXT), GWLP_WNDPROC, (LONG_PTR)AboutDlgEditWindowProc);
2522
2523 return FALSE;
2524
2525 case WM_COMMAND:
2526 switch (LOWORD(wParam)) {
2527 case IDOK:
2528 EndDialog(dlg, 1);
2529 if (DlgAboutFont != NULL) {
2530 DeleteObject(DlgAboutFont);
2531 }
2532 if (DlgAboutTextFont != NULL) {
2533 DeleteObject(DlgAboutTextFont);
2534 }
2535 return TRUE;
2536 case IDCANCEL: /* there isn't a cancel button, but other Windows
2537 UI things can send this message */
2538 EndDialog(dlg, 0);
2539 if (DlgAboutFont != NULL) {
2540 DeleteObject(DlgAboutFont);
2541 }
2542 if (DlgAboutTextFont != NULL) {
2543 DeleteObject(DlgAboutTextFont);
2544 }
2545 return TRUE;
2546 case IDC_FP_HASH_ALG_MD5:
2547 about_dlg_set_abouttext(pvar, dlg, SSH_DIGEST_MD5);
2548 return TRUE;
2549 case IDC_FP_HASH_ALG_SHA256:
2550 about_dlg_set_abouttext(pvar, dlg, SSH_DIGEST_SHA256);
2551 return TRUE;
2552 }
2553 break;
2554 }
2555
2556 return FALSE;
2557 }
2558
2559 static char *get_cipher_name(int cipher)
2560 {
2561 switch (cipher) {
2562 case SSH_CIPHER_NONE:
2563 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
2564 "<ciphers below this line are disabled>");
2565 return pvar->ts->UIMsg;
2566 case SSH_CIPHER_3DES:
2567 return "3DES(SSH1)";
2568 case SSH_CIPHER_DES:
2569 return "DES(SSH1)";
2570 case SSH_CIPHER_BLOWFISH:
2571 return "Blowfish(SSH1)";
2572
2573 // for SSH2(yutaka)
2574 case SSH2_CIPHER_AES128_CBC:
2575 return "aes128-cbc(SSH2)";
2576 case SSH2_CIPHER_AES192_CBC:
2577 return "aes192-cbc(SSH2)";
2578 case SSH2_CIPHER_AES256_CBC:
2579 return "aes256-cbc(SSH2)";
2580 case SSH2_CIPHER_3DES_CBC:
2581 return "3des-cbc(SSH2)";
2582 case SSH2_CIPHER_BLOWFISH_CBC:
2583 return "blowfish-cbc(SSH2)";
2584 case SSH2_CIPHER_AES128_CTR:
2585 return "aes128-ctr(SSH2)";
2586 case SSH2_CIPHER_AES192_CTR:
2587 return "aes192-ctr(SSH2)";
2588 case SSH2_CIPHER_AES256_CTR:
2589 return "aes256-ctr(SSH2)";
2590 case SSH2_CIPHER_ARCFOUR:
2591 return "arcfour(SSH2)";
2592 case SSH2_CIPHER_ARCFOUR128:
2593 return "arcfour128(SSH2)";
2594 case SSH2_CIPHER_ARCFOUR256:
2595 return "arcfour256(SSH2)";
2596 case SSH2_CIPHER_CAST128_CBC:
2597 return "cast128-cbc(SSH2)";
2598 case SSH2_CIPHER_3DES_CTR:
2599 return "3des-ctr(SSH2)";
2600 case SSH2_CIPHER_BLOWFISH_CTR:
2601 return "blowfish-ctr(SSH2)";
2602 case SSH2_CIPHER_CAST128_CTR:
2603 return "cast128-ctr(SSH2)";
2604 case SSH2_CIPHER_CAMELLIA128_CBC:
2605 return "camellia128-cbc(SSH2)";
2606 case SSH2_CIPHER_CAMELLIA192_CBC:
2607 return "camellia192-cbc(SSH2)";
2608 case SSH2_CIPHER_CAMELLIA256_CBC:
2609 return "camellia256-cbc(SSH2)";
2610 case SSH2_CIPHER_CAMELLIA128_CTR:
2611 return "camellia128-ctr(SSH2)";
2612 case SSH2_CIPHER_CAMELLIA192_CTR:
2613 return "camellia192-ctr(SSH2)";
2614 case SSH2_CIPHER_CAMELLIA256_CTR:
2615 return "camellia256-ctr(SSH2)";
2616 case SSH2_CIPHER_AES128_GCM:
2617 return "aes128-gcm@openssh.com(SSH2)";
2618 case SSH2_CIPHER_AES256_GCM:
2619 return "aes256-gcm@openssh.com(SSH2)";
2620
2621 default:
2622 return NULL;
2623 }
2624 }
2625
2626 static void set_move_button_status(HWND dlg, int type, int up, int down)
2627 {
2628 HWND cipherControl = GetDlgItem(dlg, type);
2629 int curPos = (int) SendMessage(cipherControl, LB_GETCURSEL, 0, 0);
2630 int maxPos = (int) SendMessage(cipherControl, LB_GETCOUNT, 0, 0) - 1;
2631
2632 EnableWindow(GetDlgItem(dlg, up),
2633 curPos > 0 && curPos <= maxPos);
2634 EnableWindow(GetDlgItem(dlg, down),
2635 curPos >= 0 && curPos < maxPos);
2636 }
2637
2638 static void init_setup_dlg(PTInstVar pvar, HWND dlg)
2639 {
2640 HWND compressionControl = GetDlgItem(dlg, IDC_SSHCOMPRESSIONLEVEL);
2641 HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2642 HWND kexControl = GetDlgItem(dlg, IDC_SSHKEX_LIST);
2643 HWND hostkeyControl = GetDlgItem(dlg, IDC_SSHHOST_KEY_LIST);
2644 HWND macControl = GetDlgItem(dlg, IDC_SSHMAC_LIST);
2645 HWND compControl = GetDlgItem(dlg, IDC_SSHCOMP_LIST);
2646 HWND hostkeyRotationControl = GetDlgItem(dlg, IDC_HOSTKEY_ROTATION_STATIC);
2647 HWND hostkeyRotationControlList = GetDlgItem(dlg, IDC_HOSTKEY_ROTATION_COMBO);
2648 int i;
2649 int ch;
2650 char uimsg[MAX_UIMSG];
2651 char *rotationItem[SSH_UPDATE_HOSTKEYS_MAX] = {
2652 "No",
2653 "Yes",
2654 "Ask",
2655 };
2656 char *rotationItemKey[SSH_UPDATE_HOSTKEYS_MAX] = {
2657 "DLG_SSHSETUP_HOSTKEY_ROTATION_NO",
2658 "DLG_SSHSETUP_HOSTKEY_ROTATION_YES",
2659 "DLG_SSHSETUP_HOSTKEY_ROTATION_ASK",
2660 };
2661
2662 GetWindowText(dlg, uimsg, sizeof(uimsg));
2663 UTIL_get_lang_msg("DLG_SSHSETUP_TITLE", pvar, uimsg);
2664 SetWindowText(dlg, pvar->ts->UIMsg);
2665 GetDlgItemText(dlg, IDC_COMPRESSLABEL, uimsg, sizeof(uimsg));
2666 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS", pvar, uimsg);
2667 SetDlgItemText(dlg, IDC_COMPRESSLABEL, pvar->ts->UIMsg);
2668 GetDlgItemText(dlg, IDC_COMPRESSNONE, uimsg, sizeof(uimsg));
2669 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NONE", pvar, uimsg);
2670 SetDlgItemText(dlg, IDC_COMPRESSNONE, pvar->ts->UIMsg);
2671 GetDlgItemText(dlg, IDC_COMPRESSHIGH, uimsg, sizeof(uimsg));
2672 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_HIGHEST", pvar, uimsg);
2673 SetDlgItemText(dlg, IDC_COMPRESSHIGH, pvar->ts->UIMsg);
2674 GetDlgItemText(dlg, IDC_COMPRESSNOTE, uimsg, sizeof(uimsg));
2675 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NOTE", pvar, uimsg);
2676 SetDlgItemText(dlg, IDC_COMPRESSNOTE, pvar->ts->UIMsg);
2677
2678 GetDlgItemText(dlg, IDC_CIPHERORDER, uimsg, sizeof(uimsg));
2679 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER", pvar, uimsg);
2680 SetDlgItemText(dlg, IDC_CIPHERORDER, pvar->ts->UIMsg);
2681 GetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, uimsg, sizeof(uimsg));
2682 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_UP", pvar, uimsg);
2683 SetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, pvar->ts->UIMsg);
2684 GetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, uimsg, sizeof(uimsg));
2685 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_DOWN", pvar, uimsg);
2686 SetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, pvar->ts->UIMsg);
2687
2688 GetDlgItemText(dlg, IDC_KEX_ORDER, uimsg, sizeof(uimsg));
2689 UTIL_get_lang_msg("DLG_SSHSETUP_KEX", pvar, uimsg);
2690 SetDlgItemText(dlg, IDC_KEX_ORDER, pvar->ts->UIMsg);
2691 GetDlgItemText(dlg, IDC_SSHKEX_MOVEUP, uimsg, sizeof(uimsg));
2692 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_UP", pvar, uimsg);
2693 SetDlgItemText(dlg, IDC_SSHKEX_MOVEUP, pvar->ts->UIMsg);
2694 GetDlgItemText(dlg, IDC_SSHKEX_MOVEDOWN, uimsg, sizeof(uimsg));
2695 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_DOWN", pvar, uimsg);
2696 SetDlgItemText(dlg, IDC_SSHKEX_MOVEDOWN, pvar->ts->UIMsg);
2697
2698 GetDlgItemText(dlg, IDC_HOST_KEY_ORDER, uimsg, sizeof(uimsg));
2699 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY", pvar, uimsg);
2700 SetDlgItemText(dlg, IDC_HOST_KEY_ORDER, pvar->ts->UIMsg);
2701 GetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEUP, uimsg, sizeof(uimsg));
2702 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_UP", pvar, uimsg);
2703 SetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEUP, pvar->ts->UIMsg);
2704 GetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEDOWN, uimsg, sizeof(uimsg));
2705 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_DOWN", pvar, uimsg);
2706 SetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEDOWN, pvar->ts->UIMsg);
2707
2708 GetDlgItemText(dlg, IDC_MAC_ORDER, uimsg, sizeof(uimsg));
2709 UTIL_get_lang_msg("DLG_SSHSETUP_MAC", pvar, uimsg);
2710 SetDlgItemText(dlg, IDC_MAC_ORDER, pvar->ts->UIMsg);
2711 GetDlgItemText(dlg, IDC_SSHMAC_MOVEUP, uimsg, sizeof(uimsg));
2712 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_UP", pvar, uimsg);
2713 SetDlgItemText(dlg, IDC_SSHMAC_MOVEUP, pvar->ts->UIMsg);
2714 GetDlgItemText(dlg, IDC_SSHMAC_MOVEDOWN, uimsg, sizeof(uimsg));
2715 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_DOWN", pvar, uimsg);
2716 SetDlgItemText(dlg, IDC_SSHMAC_MOVEDOWN, pvar->ts->UIMsg);
2717
2718 GetDlgItemText(dlg, IDC_COMP_ORDER, uimsg, sizeof(uimsg));
2719 UTIL_get_lang_msg("DLG_SSHSETUP_COMP", pvar, uimsg);
2720 SetDlgItemText(dlg, IDC_COMP_ORDER, pvar->ts->UIMsg);
2721 GetDlgItemText(dlg, IDC_SSHCOMP_MOVEUP, uimsg, sizeof(uimsg));
2722 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_UP", pvar, uimsg);
2723 SetDlgItemText(dlg, IDC_SSHCOMP_MOVEUP, pvar->ts->UIMsg);
2724 GetDlgItemText(dlg, IDC_SSHCOMP_MOVEDOWN, uimsg, sizeof(uimsg));
2725 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_DOWN", pvar, uimsg);
2726 SetDlgItemText(dlg, IDC_SSHCOMP_MOVEDOWN, pvar->ts->UIMsg);
2727
2728 GetDlgItemText(dlg, IDC_KNOWNHOSTS, uimsg, sizeof(uimsg));
2729 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST", pvar, uimsg);
2730 SetDlgItemText(dlg, IDC_KNOWNHOSTS, pvar->ts->UIMsg);
2731 GetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, uimsg, sizeof(uimsg));
2732 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RW", pvar, uimsg);
2733 SetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, pvar->ts->UIMsg);
2734 GetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, uimsg, sizeof(uimsg));
2735 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RO", pvar, uimsg);
2736 SetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, pvar->ts->UIMsg);
2737 GetDlgItemText(dlg, IDC_HEARTBEATLABEL, uimsg, sizeof(uimsg));
2738 UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT", pvar, uimsg);
2739 SetDlgItemText(dlg, IDC_HEARTBEATLABEL, pvar->ts->UIMsg);
2740 GetDlgItemText(dlg, IDC_HEARTBEATLABEL2, uimsg, sizeof(uimsg));
2741 UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT_UNIT", pvar, uimsg);
2742 SetDlgItemText(dlg, IDC_HEARTBEATLABEL2, pvar->ts->UIMsg);
2743 GetDlgItemText(dlg, IDC_REMEMBERPASSWORD, uimsg, sizeof(uimsg));
2744 UTIL_get_lang_msg("DLG_SSHSETUP_PASSWORD", pvar, uimsg);
2745 SetDlgItemText(dlg, IDC_REMEMBERPASSWORD, pvar->ts->UIMsg);
2746 GetDlgItemText(dlg, IDC_FORWARDAGENT, uimsg, sizeof(uimsg));
2747 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENT", pvar, uimsg);
2748 SetDlgItemText(dlg, IDC_FORWARDAGENT, pvar->ts->UIMsg);
2749 GetDlgItemText(dlg, IDC_FORWARDAGENTCONFIRM, uimsg, sizeof(uimsg));
2750 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENTCONFIRM", pvar, uimsg);
2751 SetDlgItemText(dlg, IDC_FORWARDAGENTCONFIRM, pvar->ts->UIMsg);
2752 GetDlgItemText(dlg, IDC_FORWARDAGENTNOTIFY, uimsg, sizeof(uimsg));
2753 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENTNOTIFY", pvar, uimsg);
2754 SetDlgItemText(dlg, IDC_FORWARDAGENTNOTIFY, pvar->ts->UIMsg);
2755 GetDlgItemText(dlg, IDC_VERIFYHOSTKEYDNS, uimsg, sizeof(uimsg));
2756 UTIL_get_lang_msg("DLG_SSHSETUP_VERIFYHOSTKEYDNS", pvar, uimsg);
2757 SetDlgItemText(dlg, IDC_VERIFYHOSTKEYDNS, pvar->ts->UIMsg);
2758 GetDlgItemText(dlg, IDC_NOTICEBANNER, uimsg, sizeof(uimsg));
2759 UTIL_get_lang_msg("DLG_SSHSETUP_NOTICE", pvar, uimsg);
2760 SetDlgItemText(dlg, IDC_NOTICEBANNER, pvar->ts->UIMsg);
2761 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2762 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2763 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2764 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
2765 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
2766 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
2767
2768 GetDlgItemText(dlg, IDC_HOSTKEY_ROTATION_STATIC, uimsg, sizeof(uimsg));
2769 UTIL_get_lang_msg("DLG_SSHSETUP_HOSTKEY_ROTATION", pvar, uimsg);
2770 SetDlgItemText(dlg, IDC_HOSTKEY_ROTATION_STATIC, pvar->ts->UIMsg);
2771
2772 SendMessage(compressionControl, TBM_SETRANGE, TRUE, MAKELONG(0, 9));
2773 SendMessage(compressionControl, TBM_SETPOS, TRUE,
2774 pvar->settings.CompressionLevel);
2775
2776 // Cipher order
2777 normalize_cipher_order(pvar->settings.CipherOrder);
2778
2779 for (i = 0; pvar->settings.CipherOrder[i] != 0; i++) {
2780 int cipher = pvar->settings.CipherOrder[i] - '0';
2781 char *name = get_cipher_name(cipher);
2782
2783 if (name != NULL) {
2784 SendMessage(cipherControl, LB_ADDSTRING, 0, (LPARAM) name);
2785 }
2786 }
2787
2788 SendMessage(cipherControl, LB_SETCURSEL, 0, 0);
2789 set_move_button_status(dlg, IDC_SSHCIPHERPREFS, IDC_SSHMOVECIPHERUP, IDC_SSHMOVECIPHERDOWN);
2790
2791 // KEX order
2792 normalize_kex_order(pvar->settings.KexOrder);
2793 for (i = 0; pvar->settings.KexOrder[i] != 0; i++) {
2794 int index = pvar->settings.KexOrder[i] - '0';
2795 char *name = NULL;
2796
2797 if (index == 0) {
2798 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_BORDER", pvar,
2799 "<KEXs below this line are disabled>");
2800 name = pvar->ts->UIMsg;
2801 } else {
2802 name = get_kex_algorithm_name(index);
2803 }
2804
2805 if (name != NULL) {
2806 SendMessage(kexControl, LB_ADDSTRING, 0, (LPARAM) name);
2807 }
2808 }
2809 SendMessage(kexControl, LB_SETCURSEL, 0, 0);
2810 set_move_button_status(dlg, IDC_SSHKEX_LIST, IDC_SSHKEX_MOVEUP, IDC_SSHKEX_MOVEDOWN);
2811
2812 // Host Key order
2813 normalize_host_key_order(pvar->settings