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 7360 - (show annotations) (download) (as text)
Sun Dec 23 16:13:05 2018 UTC (5 years, 3 months ago) by zmatsuo
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 184449 byte(s) 
OPENFILENAME.lStructSize を　get_OPENFILENAME_SIZE()　で初期化
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 ((struct sockaddr_in6 *) &ss)->sin6_addr = in6addr_any;
763 ((struct sockaddr_in6 *) &ss)->sin6_port =
764 htons(find_local_port(pvar));
765 break;
766 default:
767 /* UNSPEC */
768 len = sizeof(ss);
769 ss.ss_family = AF_UNSPEC;
770 break;
771 }
772
773 bind(s, (struct sockaddr *) &ss, len);
774 }
775
776 return (pvar->Pconnect) (s, name, namelen);
777 }
778
779 static int PASCAL TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
780 long lEvent)
781 {
782 if (s == pvar->socket) {
783 pvar->notification_events = lEvent;
784 pvar->notification_msg = wMsg;
785
786 if (pvar->NotificationWindow == NULL) {
787 pvar->NotificationWindow = hWnd;
788 AUTH_advance_to_next_cred(pvar);
789 }
790 }
791
792 return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
793 }
794
795 static int PASCAL TTXrecv(SOCKET s, char *buf, int len, int flags)
796 {
797 if (s == pvar->socket) {
798 int ret;
799
800 ssh_heartbeat_lock();
801 ret = PKT_recv(pvar, buf, len);
802 ssh_heartbeat_unlock();
803 return (ret);
804
805 } else {
806 return (pvar->Precv) (s, buf, len, flags);
807 }
808 }
809
810 static int PASCAL TTXsend(SOCKET s, char const *buf, int len,
811 int flags)
812 {
813 if (s == pvar->socket) {
814 ssh_heartbeat_lock();
815 SSH_send(pvar, buf, len);
816 ssh_heartbeat_unlock();
817 return len;
818 } else {
819 return (pvar->Psend) (s, buf, len, flags);
820 }
821 }
822
823 void notify_established_secure_connection(PTInstVar pvar)
824 {
825 int fuLoad = LR_DEFAULTCOLOR;
826
827 if (IsWindowsNT4()) {
828 fuLoad = LR_VGACOLOR;
829 }
830
831 // LoadIcon �������� LoadImage ���g�����������A
832 // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
833 if (SecureLargeIcon == NULL) {
834 SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
835 IMAGE_ICON, 0, 0, fuLoad);
836 }
837 if (SecureSmallIcon == NULL) {
838 SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
839 IMAGE_ICON, 16, 16, fuLoad);
840 }
841
842 if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
843 pvar->OldLargeIcon =
844 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
845 ICON_BIG, 0);
846 pvar->OldSmallIcon =
847 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
848 ICON_SMALL, 0);
849
850 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
851 (LPARAM) SecureLargeIcon);
852 PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
853 (LPARAM) SecureSmallIcon);
854 }
855
856 if (IsWindows2000()) {
857 if (SecureNotifyIcon == NULL) {
858 SecureNotifyIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
859 IMAGE_ICON, 0, 0, LR_VGACOLOR | LR_SHARED);
860 }
861 OldNotifyIcon = GetCustomNotifyIcon();
862 SetCustomNotifyIcon(SecureNotifyIcon);
863 }
864
865 logputs(LOG_LEVEL_VERBOSE, "Entering secure mode");
866 }
867
868 void notify_closed_connection(PTInstVar pvar, char *send_msg)
869 {
870 SSH_notify_disconnecting(pvar, send_msg);
871 AUTH_notify_disconnecting(pvar);
872 HOSTS_notify_disconnecting(pvar);
873
874 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
875 pvar->socket, MAKELPARAM(FD_CLOSE, 0));
876 }
877
878 static void add_err_msg(PTInstVar pvar, char *msg)
879 {
880 if (pvar->err_msg != NULL) {
881 int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
882 char *buf = (char *) malloc(buf_len);
883
884 strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
885 strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
886 strncat_s(buf, buf_len, msg, _TRUNCATE);
887 free(pvar->err_msg);
888 pvar->err_msg = buf;
889 } else {
890 pvar->err_msg = _strdup(msg);
891 }
892 }
893
894 void notify_nonfatal_error(PTInstVar pvar, char *msg)
895 {
896 if (!pvar->showing_err) {
897 // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
898 // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
899 if (pvar->NotificationWindow == NULL) {
900 UTIL_get_lang_msg("MSG_NONFATAL_ERROR", pvar,
901 "Tera Term: not fatal error");
902 MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
903 msg[0] = '\0';
904
905 } else {
906 PostMessage(pvar->NotificationWindow, WM_COMMAND,
907 ID_SSHASYNCMESSAGEBOX, 0);
908 }
909 }
910 if (msg[0] != 0) {
911 logputs(LOG_LEVEL_ERROR, msg);
912 add_err_msg(pvar, msg);
913 }
914 }
915
916 void notify_fatal_error(PTInstVar pvar, char *msg, BOOL send_disconnect)
917 {
918 if (msg[0] != 0) {
919 logputs(LOG_LEVEL_FATAL, msg);
920 add_err_msg(pvar, msg);
921 }
922
923 if (!pvar->fatal_error) {
924 pvar->fatal_error = TRUE;
925
926 if (send_disconnect) {
927 SSH_notify_disconnecting(pvar, msg);
928 }
929 AUTH_notify_disconnecting(pvar);
930 HOSTS_notify_disconnecting(pvar);
931
932 PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
933 pvar->socket, MAKELPARAM(FD_CLOSE,
934 (pvar->PWSAGetLastError) ()));
935 }
936 }
937
938 void logputs(int level, char *msg)
939 {
940 if (level <= pvar->settings.LogLevel) {
941 char buf[4096];
942 int file;
943
944 get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
945 file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
946 _S_IREAD | _S_IWRITE);
947
948 if (file >= 0) {
949 char *strtime = mctimelocal("%Y-%m-%d %H:%M:%S.%NZ", TRUE);
950 DWORD processid;
951 char tmp[26];
952
953 _write(file, strtime, strlen(strtime));
954 GetWindowThreadProcessId(pvar->cv->HWin, &processid);
955 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " [%lu] ",processid);
956 _write(file, tmp, strlen(tmp));
957 _write(file, msg, strlen(msg));
958 _write(file, "\n", 1);
959 _close(file);
960 }
961 }
962 }
963
964 void logprintf(int level, char *fmt, ...)
965 {
966 char buff[4096];
967 va_list params;
968
969 if (level <= pvar->settings.LogLevel) {
970 va_start(params, fmt);
971 vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
972 va_end(params);
973
974 logputs(level, buff);
975 }
976 }
977
978 static void format_line_hexdump(char *buf, int buflen, int addr, int *bytes, int byte_cnt)
979 {
980 int i, c;
981 char tmp[128];
982
983 buf[0] = 0;
984
985 /* �������A�h���X�\�� */
986 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%08X : ", addr);
987 strncat_s(buf, buflen, tmp, _TRUNCATE);
988
989 /* �o�C�i���\���i4�o�C�g�������������}���j*/
990 for (i = 0; i < byte_cnt; i++) {
991 if (i > 0 && i % 4 == 0) {
992 strncat_s(buf, buflen, " ", _TRUNCATE);
993 }
994
995 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%02X", bytes[i]);
996 strncat_s(buf, buflen, tmp, _TRUNCATE);
997 }
998
999 /* ASCII�\���������������������� */
1000 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " %*s%*s", (16 - byte_cnt) * 2 + 1, " ", (16 - byte_cnt + 3) / 4, " ");
1001 strncat_s(buf, buflen, tmp, _TRUNCATE);
1002
1003 /* ASCII�\�� */
1004 for (i = 0; i < byte_cnt; i++) {
1005 c = bytes[i];
1006 if (isprint(c)) {
1007 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%c", c);
1008 strncat_s(buf, buflen, tmp, _TRUNCATE);
1009 }
1010 else {
1011 strncat_s(buf, buflen, ".", _TRUNCATE);
1012 }
1013 }
1014
1015 //strncat_s(buf, buflen, "\n", _TRUNCATE);
1016 }
1017
1018 void logprintf_hexdump(int level, char *data, int len, char *fmt, ...)
1019 {
1020 char buff[4096];
1021 va_list params;
1022 int c, addr;
1023 int bytes[16], *ptr;
1024 int byte_cnt;
1025 int i;
1026
1027 if (level <= pvar->settings.LogLevel) {
1028 va_start(params, fmt);
1029 vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
1030 va_end(params);
1031
1032 logputs(level, buff);
1033
1034 addr = 0;
1035 byte_cnt = 0;
1036 ptr = bytes;
1037 for (i = 0; i < len; i++) {
1038 c = data[i];
1039 *ptr++ = c & 0xff;
1040 byte_cnt++;
1041
1042 if (byte_cnt == 16) {
1043 format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1044 logputs(level, buff);
1045
1046 addr += 16;
1047 byte_cnt = 0;
1048 ptr = bytes;
1049 }
1050 }
1051
1052 if (byte_cnt > 0) {
1053 format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1054 logputs(level, buff);
1055 }
1056 }
1057 }
1058
1059 static void PASCAL TTXOpenTCP(TTXSockHooks *hooks)
1060 {
1061 if (pvar->settings.Enabled) {
1062 // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
1063 pvar->origDisableTCPEchoCR = pvar->ts->DisableTCPEchoCR;
1064 pvar->ts->DisableTCPEchoCR = TRUE;
1065
1066 pvar->session_settings = pvar->settings;
1067
1068 logputs(LOG_LEVEL_VERBOSE, "---------------------------------------------------------------------");
1069 logputs(LOG_LEVEL_VERBOSE, "Initiating SSH session");
1070
1071 FWDUI_load_settings(pvar);
1072
1073 pvar->cv->TelAutoDetect = FALSE;
1074 /* This next line should not be needed because Tera Term's
1075 CommLib should find ts->Telnet == 0 ... but we'll do this
1076 just to be on the safe side. */
1077 pvar->cv->TelFlag = FALSE;
1078 pvar->cv->TelLineMode = FALSE;
1079
1080 pvar->Precv = *hooks->Precv;
1081 pvar->Psend = *hooks->Psend;
1082 pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
1083 pvar->Pconnect = *hooks->Pconnect;
1084 pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
1085
1086 *hooks->Precv = TTXrecv;
1087 *hooks->Psend = TTXsend;
1088 *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
1089 *hooks->Pconnect = TTXconnect;
1090
1091 SSH_open(pvar);
1092 HOSTS_open(pvar);
1093 FWDUI_open(pvar);
1094
1095 // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
1096 SSH2_update_cipher_myproposal(pvar);
1097 SSH2_update_kex_myproposal(pvar);
1098 SSH2_update_host_key_myproposal(pvar);
1099 SSH2_update_hmac_myproposal(pvar);
1100 SSH2_update_compression_myproposal(pvar);
1101 }
1102 }
1103
1104 static void PASCAL TTXCloseTCP(TTXSockHooks *hooks)
1105 {
1106 if (pvar->session_settings.Enabled) {
1107 pvar->socket = INVALID_SOCKET;
1108
1109 logputs(LOG_LEVEL_VERBOSE, "Terminating SSH session...");
1110
1111 *hooks->Precv = pvar->Precv;
1112 *hooks->Psend = pvar->Psend;
1113 *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
1114 *hooks->Pconnect = pvar->Pconnect;
1115
1116 pvar->ts->DisableTCPEchoCR = pvar->origDisableTCPEchoCR;
1117 }
1118
1119 uninit_TTSSH(pvar);
1120 init_TTSSH(pvar);
1121 }
1122
1123 static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
1124 {
1125 for (; from <= to; from++) {
1126 EnableWindow(GetDlgItem(dlg, from), enabled);
1127 }
1128 }
1129
1130 // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
1131 // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
1132 // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
1133 // �T�u�N���X�������������E�C���h�E�v���V�[�W��
1134 WNDPROC OrigHostnameEditProc; // Original window procedure
1135 LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
1136 WPARAM wParam, LPARAM lParam)
1137 {
1138 HWND parent;
1139 int max, select, len;
1140 char *str, *orgstr;
1141
1142 switch (msg) {
1143 // �L�[�����������������m����
1144 case WM_KEYDOWN:
1145 if (GetKeyState(VK_CONTROL) < 0) {
1146 switch (wParam) {
1147 case 0x50: // Ctrl+p ... up
1148 parent = GetParent(dlg);
1149 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1150 if (select > 0) {
1151 PostMessage(parent, CB_SETCURSEL, select - 1, 0);
1152 }
1153 return 0;
1154 case 0x4e: // Ctrl+n ... down
1155 parent = GetParent(dlg);
1156 max = SendMessage(parent, CB_GETCOUNT, 0, 0);
1157 select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1158 if (select < max - 1) {
1159 PostMessage(parent, CB_SETCURSEL, select + 1, 0);
1160 }
1161 return 0;
1162 case 0x42: // Ctrl+b ... left
1163 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1164 PostMessage(dlg, EM_SETSEL, select-1, select-1);
1165 return 0;
1166 case 0x46: // Ctrl+f ... right
1167 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1168 max = GetWindowTextLength(dlg) ;
1169 PostMessage(dlg, EM_SETSEL, select+1, select+1);
1170 return 0;
1171 case 0x41: // Ctrl+a ... home
1172 PostMessage(dlg, EM_SETSEL, 0, 0);
1173 return 0;
1174 case 0x45: // Ctrl+e ... end
1175 max = GetWindowTextLength(dlg) ;
1176 PostMessage(dlg, EM_SETSEL, max, max);
1177 return 0;
1178
1179 case 0x44: // Ctrl+d
1180 case 0x4b: // Ctrl+k
1181 case 0x55: // Ctrl+u
1182 SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1183 max = GetWindowTextLength(dlg);
1184 max++; // '\0'
1185 orgstr = str = malloc(max);
1186 if (str != NULL) {
1187 len = GetWindowText(dlg, str, max);
1188 if (select >= 0 && select < len) {
1189 if (wParam == 0x44) { // �J�[�\���z����������������������
1190 memmove(&str[select], &str[select + 1], len - select - 1);
1191 str[len - 1] = '\0';
1192
1193 } else if (wParam == 0x4b) { // �J�[�\�������s��������������
1194 str[select] = '\0';
1195
1196 }
1197 }
1198
1199 if (wParam == 0x55) { // �J�[�\����������������������
1200 if (select >= len) {
1201 str[0] = '\0';
1202 } else {
1203 str = &str[select];
1204 }
1205 select = 0;
1206 }
1207
1208 SetWindowText(dlg, str);
1209 SendMessage(dlg, EM_SETSEL, select, select);
1210 free(orgstr);
1211 return 0;
1212 }
1213 break;
1214 }
1215 }
1216 break;
1217
1218 // �����L�[��������������������������������������������
1219 case WM_CHAR:
1220 switch (wParam) {
1221 case 0x01:
1222 case 0x02:
1223 case 0x04:
1224 case 0x05:
1225 case 0x06:
1226 case 0x0b:
1227 case 0x0e:
1228 case 0x10:
1229 case 0x15:
1230 return 0;
1231 }
1232 }
1233
1234 return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
1235 }
1236
1237 static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
1238 LPARAM lParam)
1239 {
1240 static char *ssh_version[] = {"SSH1", "SSH2", NULL};
1241 PGetHNRec GetHNRec;
1242 char EntName[128];
1243 char TempHost[HostNameMaxLength + 1];
1244 WORD i, j, w;
1245 WORD ComPortTable[MAXCOMPORT];
1246 static char *ComPortDesc[MAXCOMPORT];
1247 int comports;
1248 BOOL Ok;
1249 LOGFONT logfont;
1250 HFONT font;
1251 char uimsg[MAX_UIMSG];
1252 static HWND hwndHostname = NULL; // HOSTNAME dropdown
1253 static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
1254
1255 switch (msg) {
1256 case WM_INITDIALOG:
1257 GetHNRec = (PGetHNRec) lParam;
1258 SetWindowLong(dlg, DWL_USER, lParam);
1259
1260 GetWindowText(dlg, uimsg, sizeof(uimsg));
1261 UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
1262 SetWindowText(dlg, pvar->ts->UIMsg);
1263 GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
1264 UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
1265 SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
1266 GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
1267 UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
1268 SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
1269 GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
1270 UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
1271 SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
1272 GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
1273 UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
1274 SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
1275 GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
1276 UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
1277 SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
1278 GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
1279 UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
1280 SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
1281 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
1282 UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
1283 SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
1284 GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
1285 UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
1286 SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
1287 GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
1288 UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
1289 SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
1290 GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
1291 UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
1292 SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
1293 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1294 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1295 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1296 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1297 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1298 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1299
1300 // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
1301 if (pvar->ts->HistoryList > 0) {
1302 SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
1303 } else {
1304 SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
1305 }
1306
1307 // �t�@�C�����������O�t���p�C�v�������ATCP/IP�����������B
1308 if (GetHNRec->PortType == IdFile ||
1309 GetHNRec->PortType == IdNamedPipe
1310 )
1311 GetHNRec->PortType = IdTCPIP;
1312
1313 strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
1314
1315 i = 1;
1316 do {
1317 _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
1318 GetPrivateProfileString("Hosts", EntName, "",
1319 TempHost, sizeof(TempHost),
1320 GetHNRec->SetupFN);
1321 if (strlen(TempHost) > 0)
1322 SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1323 0, (LPARAM) TempHost);
1324 i++;
1325 } while (i <= MAXHOSTLIST);
1326
1327 SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1328 HostNameMaxLength - 1, 0);
1329
1330 SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1331
1332 // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1333 hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1334 hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1335 OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1336 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1337
1338 CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1339 pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1340 Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1341 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1342 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1343 for (i = 0; ProtocolFamilyList[i]; ++i) {
1344 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1345 0, (LPARAM) ProtocolFamilyList[i]);
1346 }
1347 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1348 ProtocolFamilyMaxLength - 1, 0);
1349 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1350
1351 /////// SSH version
1352 for (i = 0; ssh_version[i]; ++i) {
1353 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1354 0, (LPARAM) ssh_version[i]);
1355 }
1356 SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1357 NUM_ELEM(ssh_version) - 1, 0);
1358
1359 if (pvar->settings.ssh_protocol_version == 1) {
1360 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1361 } else {
1362 SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1363 }
1364
1365 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1366 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1367 } else {
1368 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1369 }
1370 /////// SSH version
1371
1372
1373 j = 0;
1374 w = 1;
1375 if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1376 for (i=0; i<comports; i++) {
1377 // MaxComPort ���z�����|�[�g���\��������
1378 if (ComPortTable[i] > GetHNRec->MaxComPort) {
1379 continue;
1380 }
1381
1382 // �g�p�����|�[�g���\��������
1383 if (CheckCOMFlag(ComPortTable[i]) == 1) {
1384 continue;
1385 }
1386
1387 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1388 if (ComPortDesc[i] != NULL) {
1389 strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1390 strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1391 }
1392 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1393 0, (LPARAM)EntName);
1394 j++;
1395 if (GetHNRec->ComPort == ComPortTable[i])
1396 w = j;
1397 }
1398
1399 } else {
1400 for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1401 // �g�p�����|�[�g���\��������
1402 if (CheckCOMFlag(i) == 1) {
1403 continue;
1404 }
1405
1406 _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1407 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1408 0, (LPARAM) EntName);
1409 j++;
1410 if (GetHNRec->ComPort == i)
1411 w = j;
1412 }
1413 }
1414
1415 if (j > 0)
1416 SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1417 else { /* All com ports are already used */
1418 GetHNRec->PortType = IdTCPIP;
1419 enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1420 }
1421
1422 CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1423 IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1424
1425 if (GetHNRec->PortType == IdTCPIP) {
1426 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1427
1428 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1429 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1430
1431 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // enabled
1432 }
1433 else {
1434 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1435 FALSE);
1436 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1437 IDC_HOSTTCPPROTOCOL, FALSE);
1438
1439 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1440 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1441
1442 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1443 }
1444
1445 // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1446 if (GetHNRec->PortType == IdTCPIP) {
1447 HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1448 SetFocus(hwnd);
1449 } else {
1450 HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1451 SetFocus(hwnd);
1452 }
1453
1454 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
1455 GetObject(font, sizeof(LOGFONT), &logfont);
1456 if (UTIL_get_lang_font("DLG_SYSTEM_FONT", dlg, &logfont, &DlgHostFont, pvar)) {
1457 SendDlgItemMessage(dlg, IDC_HOSTTCPIP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1458 SendDlgItemMessage(dlg, IDC_HOSTNAMELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1459 SendDlgItemMessage(dlg, IDC_HOSTNAME, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1460 SendDlgItemMessage(dlg, IDC_HISTORY, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1461 SendDlgItemMessage(dlg, IDC_SERVICELABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1462 SendDlgItemMessage(dlg, IDC_HOSTTELNET, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1463 SendDlgItemMessage(dlg, IDC_HOSTSSH, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1464 SendDlgItemMessage(dlg, IDC_HOSTOTHER, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1465 SendDlgItemMessage(dlg, IDC_HOSTTCPPORTLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1466 SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1467 SendDlgItemMessage(dlg, IDC_SSH_VERSION_LABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1468 SendDlgItemMessage(dlg, IDC_SSH_VERSION, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1469 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOLLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1470 SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1471 SendDlgItemMessage(dlg, IDC_HOSTSERIAL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1472 SendDlgItemMessage(dlg, IDC_HOSTCOMLABEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1473 SendDlgItemMessage(dlg, IDC_HOSTCOM, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1474 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1475 SendDlgItemMessage(dlg, IDCANCEL, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1476 SendDlgItemMessage(dlg, IDC_HOSTHELP, WM_SETFONT, (WPARAM)DlgHostFont, MAKELPARAM(TRUE,0));
1477 }
1478 else {
1479 DlgHostFont = NULL;
1480 }
1481
1482 // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1483 // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1484 // (2004.11.23 yutaka)
1485 return FALSE;
1486 //return TRUE;
1487
1488 case WM_COMMAND:
1489 switch (LOWORD(wParam)) {
1490 case IDOK:
1491 GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1492 if (GetHNRec != NULL) {
1493 if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1494 char afstr[BUFSIZ];
1495 i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1496 if (Ok) {
1497 GetHNRec->TCPPort = i;
1498 } else {
1499 UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1500 "The TCP port must be a number.");
1501 MessageBox(dlg, pvar->ts->UIMsg,
1502 "Tera Term", MB_OK | MB_ICONEXCLAMATION);
1503 return TRUE;
1504 }
1505 #define getaf(str) \
1506 ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1507 ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1508 memset(afstr, 0, sizeof(afstr));
1509 GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1510 sizeof(afstr));
1511 GetHNRec->ProtocolFamily = getaf(afstr);
1512 GetHNRec->PortType = IdTCPIP;
1513 GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1514 HostNameMaxLength);
1515 pvar->hostdlg_activated = TRUE;
1516 pvar->hostdlg_Enabled = FALSE;
1517 if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1518 GetHNRec->Telnet = TRUE;
1519 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1520 pvar->hostdlg_Enabled = TRUE;
1521
1522 // check SSH protocol version
1523 memset(afstr, 0, sizeof(afstr));
1524 GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1525 if (_stricmp(afstr, "SSH1") == 0) {
1526 pvar->settings.ssh_protocol_version = 1;
1527 } else {
1528 pvar->settings.ssh_protocol_version = 2;
1529 }
1530 }
1531 else { // IDC_HOSTOTHER
1532 GetHNRec->Telnet = FALSE;
1533 }
1534
1535 // host history check button
1536 if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1537 pvar->ts->HistoryList = 1;
1538 } else {
1539 pvar->ts->HistoryList = 0;
1540 }
1541
1542 } else {
1543 GetHNRec->PortType = IdSerial;
1544 GetHNRec->HostName[0] = 0;
1545 memset(EntName, 0, sizeof(EntName));
1546 GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1547 sizeof(EntName) - 1);
1548 if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1549 GetHNRec->ComPort = atoi(&EntName[3]);
1550 if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1551 GetHNRec->ComPort = 1;
1552 } else {
1553 GetHNRec->ComPort = 1;
1554 }
1555 }
1556 }
1557 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1558 EndDialog(dlg, 1);
1559
1560 if (DlgHostFont != NULL) {
1561 DeleteObject(DlgHostFont);
1562 }
1563
1564 return TRUE;
1565
1566 case IDCANCEL:
1567 SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1568 EndDialog(dlg, 0);
1569
1570 if (DlgHostFont != NULL) {
1571 DeleteObject(DlgHostFont);
1572 }
1573
1574 return TRUE;
1575
1576 case IDC_HOSTTCPIP:
1577 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1578 TRUE);
1579 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1580 IDC_HOSTTCPPROTOCOL, TRUE);
1581 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1582
1583 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1584 if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1585 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1586 } else {
1587 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1588 }
1589
1590 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1591
1592 return TRUE;
1593
1594 case IDC_HOSTSERIAL:
1595 enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1596 enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1597 FALSE);
1598 enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1599 IDC_HOSTTCPPROTOCOL, FALSE);
1600 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1601 enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1602
1603 enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1604
1605 return TRUE;
1606
1607 case IDC_HOSTSSH:
1608 enable_dlg_items(dlg, IDC_SSH_VERSION,
1609 IDC_SSH_VERSION, TRUE);
1610 goto hostssh_enabled;
1611
1612 case IDC_HOSTTELNET:
1613 case IDC_HOSTOTHER:
1614 enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1615 hostssh_enabled:
1616
1617 GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1618
1619 if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1620 if (GetHNRec != NULL)
1621 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1622 FALSE);
1623 } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1624 SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1625 }
1626 return TRUE;
1627
1628 case IDC_HOSTCOM:
1629 if(HIWORD(wParam) == CBN_DROPDOWN) {
1630 HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1631 int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1632 int i, len, max_len = 0;
1633 char *lbl;
1634 HDC TmpDC = GetDC(hostcom);
1635 SIZE s;
1636 for (i=0; i<count; i++) {
1637 len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1638 lbl = (char *)calloc(len+1, sizeof(char));
1639 SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1640 GetTextExtentPoint32(TmpDC, lbl, len, &s);
1641 if (s.cx > max_len)
1642 max_len = s.cx;
1643 free(lbl);
1644 }
1645 SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1646 max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1647 }
1648 break;
1649
1650 case IDC_HOSTHELP:
1651 PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1652 }
1653 }
1654 return FALSE;
1655 }
1656
1657 static BOOL PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1658 {
1659 return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1660 parent, TTXHostDlg, (LONG) rec);
1661 }
1662
1663 static void PASCAL TTXGetUIHooks(TTXUIHooks *hooks)
1664 {
1665 *hooks->GetHostName = TTXGetHostName;
1666 }
1667
1668 static void PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1669 {
1670 (pvar->ReadIniFile) (fileName, ts);
1671 read_ssh_options(pvar, fileName);
1672 pvar->settings = *pvar->ts_SSH;
1673 logputs(LOG_LEVEL_VERBOSE, "Reading INI file");
1674 FWDUI_load_settings(pvar);
1675 }
1676
1677 static void PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1678 {
1679 (pvar->WriteIniFile) (fileName, ts);
1680 *pvar->ts_SSH = pvar->settings;
1681 clear_local_settings(pvar);
1682 logputs(LOG_LEVEL_VERBOSE, "Writing INI file");
1683 write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1684 }
1685
1686 static void read_ssh_options_from_user_file(PTInstVar pvar,
1687 char *user_file_name)
1688 {
1689 if (user_file_name[0] == '.') {
1690 read_ssh_options(pvar, user_file_name);
1691 } else {
1692 char buf[1024];
1693
1694 get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1695 read_ssh_options(pvar, buf);
1696 }
1697
1698 pvar->settings = *pvar->ts_SSH;
1699 FWDUI_load_settings(pvar);
1700 }
1701
1702 // Percent-encode������������src���f�R�[�h����dst���R�s�[�����B
1703 // dstlen��dst���T�C�Y�B�����������������������A�����������������������B
1704 static void percent_decode(char *dst, int dstlen, char *src) {
1705 if (src == NULL || dst == NULL || dstlen < 1) {
1706 return;
1707 }
1708
1709 while (*src != 0 && dstlen > 1) {
1710 if (*src == '%' && isxdigit(*(src+1)) && isxdigit(*(src+2))) {
1711 src++; *dst = (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0') << 4;
1712 src++; *dst |= (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0');
1713 src++; dst++;
1714 }
1715 else {
1716 *dst++ = *src++;
1717 }
1718 dstlen--;
1719 }
1720 *dst = 0;
1721 return;
1722 }
1723
1724 void add_forward_param(PTInstVar pvar, char *param)
1725 {
1726 if (pvar->settings.DefaultForwarding[0] == 0) {
1727 strncpy_s(pvar->settings.DefaultForwarding,
1728 sizeof(pvar->settings.DefaultForwarding),
1729 param, _TRUNCATE);
1730 } else {
1731 strncat_s(pvar->settings.DefaultForwarding,
1732 sizeof(pvar->settings.DefaultForwarding),
1733 ";", _TRUNCATE);
1734 strncat_s(pvar->settings.DefaultForwarding,
1735 sizeof(pvar->settings.DefaultForwarding),
1736 param, _TRUNCATE);
1737 }
1738 }
1739
1740 static void PASCAL TTXParseParam(PCHAR param, PTTSet ts, PCHAR DDETopic) {
1741 int param_len=strlen(param);
1742 int opt_len = param_len+1;
1743 char *option = (char *)calloc(opt_len, sizeof(char));
1744 char *option2 = (char *)calloc(opt_len, sizeof(char));
1745 int action;
1746 PCHAR start, cur, next;
1747 size_t i;
1748
1749 if (pvar->hostdlg_activated) {
1750 pvar->settings.Enabled = pvar->hostdlg_Enabled;
1751 }
1752
1753 /* the first term shuld be executable filename of Tera Term */
1754 start = GetParam(option, opt_len, param);
1755
1756 cur = start;
1757 while (next = GetParam(option, opt_len, cur)) {
1758 DequoteParam(option, opt_len, option);
1759 action = OPTION_NONE;
1760
1761 if ((option[0] == '-' || option[0] == '/')) {
1762 if (MATCH_STR(option + 1, "ssh") == 0) {
1763 if (MATCH_STR(option + 4, "-f=") == 0) {
1764 strncpy_s(option2, opt_len, option + 7, _TRUNCATE);
1765 read_ssh_options_from_user_file(pvar, option2);
1766 action = OPTION_CLEAR;
1767 } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1768 strncpy_s(option2, opt_len, option + 13, _TRUNCATE);
1769 read_ssh_options_from_user_file(pvar, option2);
1770 DeleteFile(option2);
1771 action = OPTION_CLEAR;
1772 }
1773
1774 // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1775 } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1776 strncpy_s(option2, opt_len, option + 3, _TRUNCATE);
1777 read_ssh_options_from_user_file(pvar, option2);
1778 // Tera Term���������������K�v������������������
1779 }
1780 }
1781
1782 switch (action) {
1783 case OPTION_CLEAR:
1784 memset(cur, ' ', next-cur);
1785 break;
1786 case OPTION_REPLACE:
1787 memset(cur, ' ', next-cur);
1788 memcpy(cur+1, option, strlen(option));
1789 break;
1790 }
1791
1792 cur = next;
1793 }
1794
1795 cur = start;
1796 while (next = GetParam(option, opt_len, cur)) {
1797 DequoteParam(option, opt_len, option);
1798 action = OPTION_NONE;
1799
1800 if ((option[0] == '-' || option[0] == '/')) {
1801 action = OPTION_CLEAR;
1802 if (MATCH_STR(option + 1, "ssh") == 0) {
1803 if (option[4] == 0) {
1804 pvar->settings.Enabled = 1;
1805 } else if (MATCH_STR(option + 4, "-L") == 0 ||
1806 MATCH_STR(option + 4, "-R") == 0 ||
1807 MATCH_STR(option + 4, "-D") == 0) {
1808 char *p = option + 5;
1809 option2[0] = *p;
1810 i = 1;
1811 while (*++p) {
1812 if (*p == ';' || *p == ',') {
1813 option2[i] = 0;
1814 add_forward_param(pvar, option2);
1815 i = 1;
1816 }
1817 else {
1818 option2[i++] = *p;
1819 }
1820 }
1821 if (i > 1) {
1822 option2[i] = 0;
1823 add_forward_param(pvar, option2);
1824 }
1825 } else if (MATCH_STR(option + 4, "-X") == 0) {
1826 add_forward_param(pvar, "X");
1827 if (option+6 != 0) {
1828 strncpy_s(pvar->settings.X11Display,
1829 sizeof(pvar->settings.X11Display),
1830 option + 6, _TRUNCATE);
1831 }
1832 } else if (strcmp(option + 4, "-v") == 0) {
1833 pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1834 } else if (_stricmp(option + 4, "-autologin") == 0 ||
1835 _stricmp(option + 4, "-autologon") == 0) {
1836 pvar->settings.TryDefaultAuth = TRUE;
1837 } else if (MATCH_STR_I(option + 4, "-agentconfirm=") == 0) {
1838 if ((_stricmp(option+18, "off") == 0) ||
1839 (_stricmp(option+18, "no") == 0) ||
1840 (_stricmp(option+18, "false") == 0) ||
1841 (_stricmp(option+18, "0") == 0) ||
1842 (_stricmp(option+18, "n") == 0)) {
1843 pvar->settings.ForwardAgentConfirm = 0;
1844 }
1845 else {
1846 pvar->settings.ForwardAgentConfirm = 1;
1847 }
1848 } else if (strcmp(option + 4, "-a") == 0) {
1849 pvar->settings.ForwardAgent = FALSE;
1850 } else if (strcmp(option + 4, "-A") == 0) {
1851 pvar->settings.ForwardAgent = TRUE;
1852
1853 } else if (MATCH_STR(option + 4, "-C=") == 0) {
1854 pvar->settings.CompressionLevel = atoi(option+7);
1855 if (pvar->settings.CompressionLevel < 0) {
1856 pvar->settings.CompressionLevel = 0;
1857 }
1858 else if (pvar->settings.CompressionLevel > 9) {
1859 pvar->settings.CompressionLevel = 9;
1860 }
1861 } else if (strcmp(option + 4, "-C") == 0) {
1862 pvar->settings.CompressionLevel = 6;
1863 } else if (strcmp(option + 4, "-c") == 0) {
1864 pvar->settings.CompressionLevel = 0;
1865 } else if (MATCH_STR_I(option + 4, "-icon=") == 0) {
1866 if ((_stricmp(option+10, "old") == 0) ||
1867 (_stricmp(option+10, "yellow") == 0) ||
1868 (_stricmp(option+10, "securett_yellow") == 0)) {
1869 pvar->settings.IconID = IDI_SECURETT_YELLOW;
1870 }
1871 else if ((_stricmp(option+10, "green") == 0) ||
1872 (_stricmp(option+10, "securett_green") == 0)) {
1873 pvar->settings.IconID = IDI_SECURETT_GREEN;
1874 }
1875 else {
1876 pvar->settings.IconID = IDI_SECURETT;
1877 }
1878 } else if (MATCH_STR(option + 4, "-subsystem=") == 0) {
1879 pvar->use_subsystem = TRUE;
1880 strncpy_s(pvar->subsystem_name,
1881 sizeof(pvar->subsystem_name),
1882 option + 15, _TRUNCATE);
1883
1884 // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1885 } else if (strcmp(option + 4, "1") == 0) {
1886 pvar->settings.Enabled = 1;
1887 pvar->settings.ssh_protocol_version = 1;
1888 } else if (strcmp(option + 4, "2") == 0) {
1889 pvar->settings.Enabled = 1;
1890 pvar->settings.ssh_protocol_version = 2;
1891
1892 } else {
1893 char buf[1024];
1894
1895 UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1896 "Unrecognized command-line option: %s");
1897 _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1898
1899 MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1900 }
1901
1902 // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1903 } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1904 if (strcmp(option + 3, "2") == 0) {
1905 pvar->settings.Enabled = 1;
1906 // /t=2��ttssh�������g������������
1907 } else {
1908 pvar->settings.Enabled = 0;
1909 action = OPTION_NONE; // Tera Term������������������������
1910 }
1911
1912 // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1913 } else if (strcmp(option + 1, "1") == 0) {
1914 // command line: /ssh /1 is SSH1 only
1915 pvar->settings.ssh_protocol_version = 1;
1916
1917 } else if (strcmp(option + 1, "2") == 0) {
1918 // command line: /ssh /2 is SSH2 & SSH1
1919 pvar->settings.ssh_protocol_version = 2;
1920
1921 } else if (strcmp(option + 1, "nossh") == 0) {
1922 // '/nossh' �I�v�V�����������B
1923 // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1924 // �����������������B(2004.10.11 yutaka)
1925 pvar->settings.Enabled = 0;
1926
1927 } else if (strcmp(option + 1, "telnet") == 0) {
1928 // '/telnet' ���w�������������������� '/nossh' ��������
1929 // SSH������������ (2006.9.16 maya)
1930 pvar->settings.Enabled = 0;
1931 // Tera Term �� Telnet �t���O���t����
1932 pvar->ts->Telnet = 1;
1933
1934 } else if (MATCH_STR(option + 1, "auth=") == 0) {
1935 // SSH2�������O�C���I�v�V����������
1936 //
1937 // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1938 // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1939 // EXAMPLE: /ssh /auth=password /user=nike /passwd="a b""c" ; �p�X���[�h: �ua b"c�v
1940 // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1941 // NOTICE: �p�X���[�h���p�X���������Z�~�R���������������������_�u���N�H�[�g " ������
1942 // �p�X���[�h���_�u���N�H�[�g�����������������A�������_�u���N�H�[�g "" ���u��������
1943 //
1944 pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1945
1946 if (_stricmp(option + 6, "password") == 0) { // �p�X���[�h
1947 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1948 pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1949
1950 } else if (_stricmp(option + 6, "keyboard-interactive") == 0) { // keyboard-interactive�F��
1951 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1952 pvar->ssh2_authmethod = SSH_AUTH_TIS;
1953
1954 } else if (_stricmp(option + 6, "challenge") == 0) { // keyboard-interactive�F��
1955 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1956 pvar->ssh2_authmethod = SSH_AUTH_TIS;
1957
1958 } else if (_stricmp(option + 6, "publickey") == 0) { // ���J���F��
1959 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1960 pvar->ssh2_authmethod = SSH_AUTH_RSA;
1961
1962 } else if (_stricmp(option + 6, "pageant") == 0) { // ���J���F�� by Pageant
1963 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1964 pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1965
1966 } else {
1967 // TODO:
1968 }
1969
1970 } else if (MATCH_STR(option + 1, "user=") == 0) {
1971 _snprintf_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), _TRUNCATE, "%s", option+6);
1972
1973 } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1974 _snprintf_s(pvar->ssh2_password, sizeof(pvar->ssh2_password), _TRUNCATE, "%s", option+8);
1975
1976 } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1977 _snprintf_s(pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile), _TRUNCATE, "%s", option+9);
1978
1979 } else if (strcmp(option + 1, "ask4passwd") == 0) {
1980 // �p�X���[�h������ (2006.9.18 maya)
1981 pvar->ask4passwd = 1;
1982
1983 } else if (strcmp(option + 1, "nosecuritywarning") == 0) {
1984 // known_hosts�`�F�b�N���������B���Y�I�v�V�������g�����A�Z�L�����e�B������������
1985 // �����A�B���I�v�V���������������B
1986 // (2009.10.4 yutaka)
1987 pvar->nocheck_known_hosts = TRUE;
1988
1989 }
1990 else { // Other (not ttssh) option
1991 action = OPTION_NONE; // ttssh���I�v�V������������������������
1992 }
1993
1994 // �p�X���[�h�������������������O�C��������������
1995 // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1996 if (pvar->ask4passwd == 1) {
1997 pvar->ssh2_autologin = 0;
1998 }
1999
2000 }
2001 else if ((MATCH_STR_I(option, "ssh://") == 0) ||
2002 (MATCH_STR_I(option, "ssh1://") == 0) ||
2003 (MATCH_STR_I(option, "ssh2://") == 0) ||
2004 (MATCH_STR_I(option, "slogin://") == 0) ||
2005 (MATCH_STR_I(option, "slogin1://") == 0) ||
2006 (MATCH_STR_I(option, "slogin2://") == 0)) {
2007 //
2008 // ssh://user@host/ ����URL�`�����T�|�[�g
2009 // ���{�I�������� telnet:// URL��������
2010 //
2011 // �Q�l:
2012 // RFC3986: Uniform Resource Identifier (URI): Generic Syntax
2013 // RFC4248: The telnet URI Scheme
2014 //
2015 char *p, *p2, *p3;
2016 int optlen, hostlen;
2017
2018 optlen = strlen(option);
2019
2020 // ������':'���O�����������������������A������ssh�v���g�R���o�[�W������������
2021 p = _mbschr(option, ':');
2022 switch (*(p-1)) {
2023 case '1':
2024 pvar->settings.ssh_protocol_version = 1;
2025 break;
2026 case '2':
2027 pvar->settings.ssh_protocol_version = 2;
2028 break;
2029 }
2030
2031 // authority part �����|�C���^������
2032 p += 3;
2033
2034 // path part ������������
2035 if ((p2 = _mbschr(p, '/')) != NULL) {
2036 *p2 = 0;
2037 }
2038
2039 // '@'�������������A���������O�����[�U����
2040 if ((p2 = _mbschr(p, '@')) != NULL) {
2041 *p2 = 0;
2042 // ':'���~���p�X���[�h
2043 if ((p3 = _mbschr(p, ':')) != NULL) {
2044 *p3 = 0;
2045 percent_decode(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
2046 }
2047 percent_decode(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
2048 // p �� host part ������('@'����������)����������������
2049 p = p2 + 1;
2050 }
2051
2052 // host part �� option �����������������Ascheme part ������
2053 // port�w����������������port���������������������m��������������
2054 hostlen = strlen(p);
2055 memmove_s(option, optlen, p, hostlen);
2056 option[hostlen] = 0;
2057
2058 // �|�[�g�w������������":22"������
2059 if (option[0] == '[' && option[hostlen-1] == ']' || // IPv6 raw address without port
2060 option[0] != '[' && _mbschr(option, ':') == NULL) { // hostname or IPv4 raw address without port
2061 memcpy_s(option+hostlen, optlen-hostlen, ":22", 3);
2062 hostlen += 3;
2063 }
2064
2065 // �|�[�g�w�����������������X�y�[�X������
2066 memset(option+hostlen, ' ', optlen-hostlen);
2067
2068 pvar->settings.Enabled = 1;
2069
2070 action = OPTION_REPLACE;
2071 }
2072 else if (_mbschr(option, '@') != NULL) {
2073 //
2074 // user@host �`�����T�|�[�g
2075 // ����������ssh�������T�|�[�g�����A���[�U����ttssh���������B
2076 // (ssh�������O -- ttssh�������W������������)
2077 // �����I��telnet authentication option���T�|�[�g��������
2078 // Tera Term�{�����������������������\���B
2079 //
2080 char *p;
2081 p = _mbschr(option, '@');
2082 *p = 0;
2083
2084 strncpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), option, _TRUNCATE);
2085
2086 // ���[�U���������X�y�[�X�������B
2087 // ������TTX��Tera Term�{�������������������X�y�[�X�����������������A
2088 // �z�X�g�����������l�����K�v�������B
2089 memset(option, ' ', p-option+1);
2090
2091 action = OPTION_REPLACE;
2092 }
2093
2094
2095 switch (action) {
2096 case OPTION_CLEAR:
2097 memset(cur, ' ', next-cur);
2098 break;
2099 case OPTION_REPLACE:
2100 memset(cur, ' ', next-cur);
2101 memcpy(cur+1, option, strlen(option));
2102 break;
2103 }
2104
2105 cur = next;
2106 }
2107
2108 free(option);
2109
2110 FWDUI_load_settings(pvar);
2111
2112 (pvar->ParseParam) (param, ts, DDETopic);
2113 }
2114
2115 static void PASCAL TTXGetSetupHooks(TTXSetupHooks *hooks)
2116 {
2117 pvar->ReadIniFile = *hooks->ReadIniFile;
2118 pvar->WriteIniFile = *hooks->WriteIniFile;
2119 pvar->ParseParam = *hooks->ParseParam;
2120
2121 *hooks->ReadIniFile = TTXReadINIFile;
2122 *hooks->WriteIniFile = TTXWriteINIFile;
2123 *hooks->ParseParam = TTXParseParam;
2124 }
2125
2126 static void PASCAL TTXSetWinSize(int rows, int cols)
2127 {
2128 SSH_notify_win_size(pvar, cols, rows);
2129 }
2130
2131 static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
2132 WORD newItemID, char *text)
2133 {
2134 int i, j;
2135
2136 for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
2137 HMENU submenu = GetSubMenu(menu, i);
2138
2139 for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
2140 if (GetMenuItemID(submenu, j) == beforeItemID) {
2141 InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
2142 return;
2143 }
2144 }
2145 }
2146 }
2147
2148 #define GetFileMenu(menu) GetSubMenuByChildID(menu, 50110) // ID_FILE_NEWCONNECTION
2149 #define GetEditMenu(menu) GetSubMenuByChildID(menu, 50210) // ID_EDIT_COPY2
2150 #define GetSetupMenu(menu) GetSubMenuByChildID(menu, 50310) // ID_SETUP_TERMINAL
2151 #define GetControlMenu(menu) GetSubMenuByChildID(menu, 50410) // ID_CONTROL_RESETTERMINAL
2152 #define GetHelpMenu(menu) GetSubMenuByChildID(menu, 50990) // ID_HELP_ABOUT
2153
2154 HMENU GetSubMenuByChildID(HMENU menu, UINT id) {
2155 int i, j, items, subitems, cur_id;
2156 HMENU m;
2157
2158 items = GetMenuItemCount(menu);
2159
2160 for (i=0; i<items; i++) {
2161 if (m = GetSubMenu(menu, i)) {
2162 subitems = GetMenuItemCount(m);
2163 for (j=0; j<subitems; j++) {
2164 cur_id = GetMenuItemID(m, j);
2165 if (cur_id == id) {
2166 return m;
2167 }
2168 }
2169 }
2170 }
2171 return NULL;
2172 }
2173
2174 static void PASCAL TTXModifyMenu(HMENU menu)
2175 {
2176 pvar->FileMenu = GetFileMenu(menu);
2177
2178 /* inserts before ID_HELP_ABOUT */
2179 UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
2180 insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
2181
2182 /* inserts before ID_SETUP_TCPIP */
2183 UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
2184 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
2185 /* inserts before ID_SETUP_TCPIP */
2186 UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
2187 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
2188 /* inserts before ID_SETUP_TCPIP */
2189 UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
2190 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
2191 UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
2192 insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
2193
2194 /* inserts before ID_FILE_CHANGEDIR */
2195 UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SS&H SCP...");
2196 insertMenuBeforeItem(menu, 50170, MF_GRAYED, ID_SSHSCPMENU, pvar->ts->UIMsg);
2197 }
2198
2199 static void PASCAL TTXModifyPopupMenu(HMENU menu) {
2200 if (menu == pvar->FileMenu) {
2201 if (pvar->cv->Ready && pvar->socket != INVALID_SOCKET)
2202 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_ENABLED);
2203 else
2204 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_GRAYED);
2205 }
2206 }
2207
2208 static void about_dlg_set_abouttext(PTInstVar pvar, HWND dlg, digest_algorithm dgst_alg)
2209 {
2210 char buf[1024], buf2[2048];
2211 char *fp = NULL;
2212
2213 // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
2214 if (pvar->socket != INVALID_SOCKET) {
2215 buf2[0] = '\0';
2216
2217 if (SSHv1(pvar)) {
2218 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2219 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2220 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2221 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2222 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2223 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2224
2225 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2226 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2227 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2228 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2229 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2230 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2231
2232 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2233 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2234 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2235 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2236 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2237 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2238
2239 UTIL_get_lang_msg("DLG_ABOUT_SERVERKEY", pvar, "Server keys:");
2240 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2241 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2242 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2243 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2244 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2245
2246 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
2247 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2248 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2249 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2250 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2251 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2252
2253 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
2254 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2255 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2256 SSH_get_compression_info(pvar, buf, sizeof(buf));
2257 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2258 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2259
2260 } else { // SSH2
2261 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2262 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2263 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2264 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2265 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2266 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2267
2268 UTIL_get_lang_msg("DLG_ABOUT_CLIENTID", pvar, "Client ID:");
2269 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2270 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2271 strncat_s(buf2, sizeof(buf2), pvar->client_version_string, _TRUNCATE);
2272 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2273
2274 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2275 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2276 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2277 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2278 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2279 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2280
2281 UTIL_get_lang_msg("DLG_ABOUT_KEX", pvar, "Key exchange algorithm:");
2282 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2283 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2284 strncat_s(buf2, sizeof(buf2), get_kex_algorithm_name(pvar->kex_type), _TRUNCATE);
2285 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2286
2287 UTIL_get_lang_msg("DLG_ABOUT_HOSTKEY", pvar, "Host Key:");
2288 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2289 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2290 strncat_s(buf2, sizeof(buf2), get_ssh_keytype_name(pvar->hostkey_type), _TRUNCATE);
2291 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2292
2293 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2294 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2295 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2296 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2297 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2298 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2299
2300 UTIL_get_lang_msg("DLG_ABOUT_MAC", pvar, "MAC algorithm:");
2301 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2302 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2303 SSH_get_mac_info(pvar, buf, sizeof(buf));
2304 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2305 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2306
2307 if (pvar->ctos_compression == COMP_DELAYED) { // �x���p�P�b�g���k������ (2006.6.23 yutaka)
2308 UTIL_get_lang_msg("DLG_ABOUT_COMPDELAY", pvar, "Delayed Compression:");
2309 }
2310 else {
2311 UTIL_get_lang_msg("DLG_ABOUT_COMP", pvar, "Compression:");
2312 }
2313 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2314 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2315 SSH_get_compression_info(pvar, buf, sizeof(buf));
2316 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2317 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2318
2319 UTIL_get_lang_msg("DLG_ABOUT_KEXKEY", pvar, "Key exchange keys:");
2320 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2321 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2322 CRYPT_get_server_key_info(pvar, buf, sizeof(buf));
2323 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2324 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2325
2326 UTIL_get_lang_msg("DLG_ABOUT_AUTH", pvar, "Authentication:");
2327 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2328 strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2329 AUTH_get_auth_info(pvar, buf, sizeof(buf));
2330 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2331 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2332 }
2333
2334 // �z�X�g���J����fingerprint���\�������B
2335 // (2014.5.1 yutaka)
2336 UTIL_get_lang_msg("DLG_ABOUT_FINGERPRINT", pvar, "Host key's fingerprint:");
2337 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2338 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2339
2340 switch (dgst_alg) {
2341 case SSH_DIGEST_MD5:
2342 fp = key_fingerprint(&pvar->hosts_state.hostkey, SSH_FP_HEX, dgst_alg);
2343 strncat_s(buf2, sizeof(buf2), fp, _TRUNCATE);
2344 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2345 free(fp);
2346 break;
2347 case SSH_DIGEST_SHA256:
2348 default:
2349 fp = key_fingerprint(&pvar->hosts_state.hostkey, SSH_FP_BASE64, SSH_DIGEST_SHA256);
2350 if (fp != NULL) {
2351 strncat_s(buf2, sizeof(buf2), fp, _TRUNCATE);
2352 free(fp);
2353 }
2354 strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2355 break;
2356 }
2357
2358 fp = key_fingerprint(&pvar->hosts_state.hostkey, SSH_FP_RANDOMART, dgst_alg);
2359 strncat_s(buf2, sizeof(buf2), fp, _TRUNCATE);
2360 free(fp);
2361
2362 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETTEXT, 0, (LPARAM)(char *)buf2);
2363 }
2364 }
2365
2366 static void init_about_dlg(PTInstVar pvar, HWND dlg)
2367 {
2368 char buf[1024];
2369 char uimsg[MAX_UIMSG];
2370
2371 GetWindowText(dlg, uimsg, sizeof(uimsg));
2372 UTIL_get_lang_msg("DLG_ABOUT_TITLE", pvar, uimsg);
2373 SetWindowText(dlg, pvar->ts->UIMsg);
2374 GetDlgItemText(dlg, IDC_FP_HASH_ALG, uimsg, sizeof(uimsg));
2375 UTIL_get_lang_msg("DLG_ABOUT_FP_HASH_ALGORITHM", pvar, uimsg);
2376 SetDlgItemText(dlg, IDC_FP_HASH_ALG, pvar->ts->UIMsg);
2377 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2378 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2379 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2380
2381 // TTSSH���o�[�W�������������� (2005.2.28 yutaka)
2382 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
2383 "TTSSH\r\nTera Term Secure Shell extension, %d.%d", TTSSH_VERSION_MAJOR, TTSSH_VERSION_MINOR);
2384 SendMessage(GetDlgItem(dlg, IDC_TTSSH_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2385
2386 // OpenSSL���o�[�W�������������� (2005.1.24 yutaka)
2387 // ���������� (2005.5.11 yutaka)
2388 // OPENSSL_VERSION_TEXT �}�N�����`���������A�������g�����o�[�W���������������B(2013.11.24 yutaka)
2389 SendMessage(GetDlgItem(dlg, IDC_OPENSSL_VERSION), WM_SETTEXT, 0, (LPARAM)SSLeay_version(SSLEAY_VERSION));
2390
2391 // zlib���o�[�W�������������� (2005.5.11 yutaka)
2392 #ifdef ZLIB_VERSION
2393 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "ZLib %s", ZLIB_VERSION);
2394 #else
2395 _snprintf(buf, sizeof(buf), "ZLib Unknown");
2396 #endif
2397 SendMessage(GetDlgItem(dlg, IDC_ZLIB_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2398
2399 // PuTTY���o�[�W�������������� (2011.7.26 yutaka)
2400 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "PuTTY %s", putty_get_version());
2401 SendMessage(GetDlgItem(dlg, IDC_PUTTY_VERSION), WM_SETTEXT, 0, (LPARAM)buf);
2402 }
2403
2404 // WM_MOUSEWHEEL �� winuser.h �w�b�_���������������������A#define _WIN32_WINNT 0x0400 ���������������������F�������������B
2405 #define WM_MOUSEWHEEL 0x020A
2406 #define WHEEL_DELTA 120
2407 #define GET_WHEEL_DELTA_WPARAM(wParam) ((short)HIWORD(wParam))
2408 #define GET_KEYSTATE_WPARAM(wParam) (LOWORD(wParam))
2409
2410 static WNDPROC g_defAboutDlgEditWndProc; // Edit Control���T�u�N���X���p
2411 static int g_deltaSumAboutDlg = 0; // �}�E�X�z�C�[����Delta�����p
2412
2413 static LRESULT CALLBACK AboutDlgEditWindowProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
2414 {
2415 WORD keys;
2416 short delta;
2417 BOOL page;
2418
2419 switch (msg) {
2420 case WM_KEYDOWN:
2421 // Edit control���� CTRL+A �������������A�e�L�X�g���S�I�������B
2422 if (wp == 'A' && GetKeyState(VK_CONTROL) < 0) {
2423 PostMessage(hWnd, EM_SETSEL, 0, -1);
2424 return 0;
2425 }
2426 break;
2427
2428 case WM_MOUSEWHEEL:
2429 // CTRLorSHIFT + �}�E�X�z�C�[���������A���X�N���[���������B
2430 keys = GET_KEYSTATE_WPARAM(wp);
2431 delta = GET_WHEEL_DELTA_WPARAM(wp);
2432 page = keys & (MK_CONTROL | MK_SHIFT);
2433
2434 if (page == 0)
2435 break;
2436
2437 g_deltaSumAboutDlg += delta;
2438
2439 if (g_deltaSumAboutDlg >= WHEEL_DELTA) {
2440 g_deltaSumAboutDlg -= WHEEL_DELTA;
2441 SendMessage(hWnd, WM_HSCROLL, SB_PAGELEFT , 0);
2442 } else if (g_deltaSumAboutDlg <= -WHEEL_DELTA) {
2443 g_deltaSumAboutDlg += WHEEL_DELTA;
2444 SendMessage(hWnd, WM_HSCROLL, SB_PAGERIGHT, 0);
2445 }
2446
2447 break;
2448 }
2449 return CallWindowProc(g_defAboutDlgEditWndProc, hWnd, msg, wp, lp);
2450 }
2451
2452 static BOOL CALLBACK TTXAboutDlg(HWND dlg, UINT msg, WPARAM wParam,
2453 LPARAM lParam)
2454 {
2455 LOGFONT logfont;
2456 HFONT font;
2457
2458 switch (msg) {
2459 case WM_INITDIALOG:
2460 font = (HFONT)SendMessage(dlg, WM_GETFONT, 0, 0);
2461 GetObject(font, sizeof(LOGFONT), &logfont);
2462 if (UTIL_get_lang_font("DLG_TAHOMA_FONT", dlg, &logfont, &DlgAboutFont, pvar)) {
2463 SendDlgItemMessage(dlg, IDC_TTSSH_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2464 SendDlgItemMessage(dlg, IDC_SSHVERSIONS, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2465 SendDlgItemMessage(dlg, IDC_INCLUDES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2466 SendDlgItemMessage(dlg, IDC_OPENSSL_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2467 SendDlgItemMessage(dlg, IDC_ZLIB_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2468 SendDlgItemMessage(dlg, IDC_PUTTY_VERSION, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2469 SendDlgItemMessage(dlg, IDC_WEBSITES, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2470 SendDlgItemMessage(dlg, IDC_CRYPTOGRAPHY, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2471 SendDlgItemMessage(dlg, IDC_CREDIT, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2472 SendDlgItemMessage(dlg, IDC_FP_HASH_ALG, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2473 SendDlgItemMessage(dlg, IDC_FP_HASH_ALG_MD5, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2474 SendDlgItemMessage(dlg, IDC_FP_HASH_ALG_SHA256, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE, 0));
2475 SendDlgItemMessage(dlg, IDOK, WM_SETFONT, (WPARAM)DlgAboutFont, MAKELPARAM(TRUE,0));
2476 }
2477 else {
2478 DlgAboutFont = NULL;
2479 }
2480
2481 // Edit control�������t�H���g���\�������������A���������������t�H���g���Z�b�g�����B
2482 // (2014.5.5. yutaka)
2483 if (UTIL_get_lang_font("DLG_ABOUT_FONT", dlg, &logfont, &DlgAboutTextFont, pvar)) {
2484 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutTextFont, MAKELPARAM(TRUE,0));
2485 } else {
2486 // ���������������������������t�H���g���w�������B
2487 // �G�f�B�b�g�R���g���[�����_�C�A���O�������t�H���g������������
2488 // �����t�H���g�������������B
2489 strncpy_s(logfont.lfFaceName, sizeof(logfont.lfFaceName), "Courier New", _TRUNCATE);
2490 logfont.lfCharSet = 0;
2491 logfont.lfHeight = MulDiv(8, GetDeviceCaps(GetDC(dlg),LOGPIXELSY) * -1, 72);
2492 logfont.lfWidth = 0;
2493 if ((DlgAboutTextFont = CreateFontIndirect(&logfont)) != NULL) {
2494 SendDlgItemMessage(dlg, IDC_ABOUTTEXT, WM_SETFONT, (WPARAM)DlgAboutTextFont, MAKELPARAM(TRUE,0));
2495 }
2496 else {
2497 DlgAboutTextFont = NULL;
2498 }
2499 }
2500
2501 // �A�C�R�������I���Z�b�g
2502 {
2503 int fuLoad = LR_DEFAULTCOLOR;
2504 HICON hicon;
2505
2506 if (IsWindowsNT4()) {
2507 fuLoad = LR_VGACOLOR;
2508 }
2509
2510 hicon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
2511 IMAGE_ICON, 32, 32, fuLoad);
2512 SendDlgItemMessage(dlg, IDC_TTSSH_ICON, STM_SETICON, (WPARAM)hicon, 0);
2513 }
2514
2515 init_about_dlg(pvar, dlg);
2516 CheckDlgButton(dlg, IDC_FP_HASH_ALG_SHA256, TRUE);
2517 about_dlg_set_abouttext(pvar, dlg, SSH_DIGEST_SHA256);
2518 SetFocus(GetDlgItem(dlg, IDOK));
2519
2520 // Edit control���T�u�N���X�������B
2521 g_deltaSumAboutDlg = 0;
2522 g_defAboutDlgEditWndProc = (WNDPROC)SetWindowLongPtr(GetDlgItem(dlg, IDC_ABOUTTEXT), GWLP_WNDPROC, (LONG_PTR)AboutDlgEditWindowProc);
2523
2524 return FALSE;
2525
2526 case WM_COMMAND:
2527 switch (LOWORD(wParam)) {
2528 case IDOK:
2529 EndDialog(dlg, 1);
2530 if (DlgAboutFont != NULL) {
2531 DeleteObject(DlgAboutFont);
2532 }
2533 if (DlgAboutTextFont != NULL) {
2534 DeleteObject(DlgAboutTextFont);
2535 }
2536 return TRUE;
2537 case IDCANCEL: /* there isn't a cancel button, but other Windows
2538 UI things can send this message */
2539 EndDialog(dlg, 0);
2540 if (DlgAboutFont != NULL) {
2541 DeleteObject(DlgAboutFont);
2542 }
2543 if (DlgAboutTextFont != NULL) {
2544 DeleteObject(DlgAboutTextFont);
2545 }
2546 return TRUE;
2547 case IDC_FP_HASH_ALG_MD5:
2548 about_dlg_set_abouttext(pvar, dlg, SSH_DIGEST_MD5);
2549 return TRUE;
2550 case IDC_FP_HASH_ALG_SHA256:
2551 about_dlg_set_abouttext(pvar, dlg, SSH_DIGEST_SHA256);
2552 return TRUE;
2553 }
2554 break;
2555 }
2556
2557 return FALSE;
2558 }
2559
2560 static char *get_cipher_name(int cipher)
2561 {
2562 switch (cipher) {
2563 case SSH_CIPHER_NONE:
2564 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_BORDER", pvar,
2565 "<ciphers below this line are disabled>");
2566 return pvar->ts->UIMsg;
2567 case SSH_CIPHER_3DES:
2568 return "3DES(SSH1)";
2569 case SSH_CIPHER_DES:
2570 return "DES(SSH1)";
2571 case SSH_CIPHER_BLOWFISH:
2572 return "Blowfish(SSH1)";
2573
2574 // for SSH2(yutaka)
2575 case SSH2_CIPHER_AES128_CBC:
2576 return "aes128-cbc(SSH2)";
2577 case SSH2_CIPHER_AES192_CBC:
2578 return "aes192-cbc(SSH2)";
2579 case SSH2_CIPHER_AES256_CBC:
2580 return "aes256-cbc(SSH2)";
2581 case SSH2_CIPHER_3DES_CBC:
2582 return "3des-cbc(SSH2)";
2583 case SSH2_CIPHER_BLOWFISH_CBC:
2584 return "blowfish-cbc(SSH2)";
2585 case SSH2_CIPHER_AES128_CTR:
2586 return "aes128-ctr(SSH2)";
2587 case SSH2_CIPHER_AES192_CTR:
2588 return "aes192-ctr(SSH2)";
2589 case SSH2_CIPHER_AES256_CTR:
2590 return "aes256-ctr(SSH2)";
2591 case SSH2_CIPHER_ARCFOUR:
2592 return "arcfour(SSH2)";
2593 case SSH2_CIPHER_ARCFOUR128:
2594 return "arcfour128(SSH2)";
2595 case SSH2_CIPHER_ARCFOUR256:
2596 return "arcfour256(SSH2)";
2597 case SSH2_CIPHER_CAST128_CBC:
2598 return "cast128-cbc(SSH2)";
2599 case SSH2_CIPHER_3DES_CTR:
2600 return "3des-ctr(SSH2)";
2601 case SSH2_CIPHER_BLOWFISH_CTR:
2602 return "blowfish-ctr(SSH2)";
2603 case SSH2_CIPHER_CAST128_CTR:
2604 return "cast128-ctr(SSH2)";
2605 case SSH2_CIPHER_CAMELLIA128_CBC:
2606 return "camellia128-cbc(SSH2)";
2607 case SSH2_CIPHER_CAMELLIA192_CBC:
2608 return "camellia192-cbc(SSH2)";
2609 case SSH2_CIPHER_CAMELLIA256_CBC:
2610 return "camellia256-cbc(SSH2)";
2611 case SSH2_CIPHER_CAMELLIA128_CTR:
2612 return "camellia128-ctr(SSH2)";
2613 case SSH2_CIPHER_CAMELLIA192_CTR:
2614 return "camellia192-ctr(SSH2)";
2615 case SSH2_CIPHER_CAMELLIA256_CTR:
2616 return "camellia256-ctr(SSH2)";
2617 case SSH2_CIPHER_AES128_GCM:
2618 return "aes128-gcm@openssh.com(SSH2)";
2619 case SSH2_CIPHER_AES256_GCM:
2620 return "aes256-gcm@openssh.com(SSH2)";
2621
2622 default:
2623 return NULL;
2624 }
2625 }
2626
2627 static void set_move_button_status(HWND dlg, int type, int up, int down)
2628 {
2629 HWND cipherControl = GetDlgItem(dlg, type);
2630 int curPos = (int) SendMessage(cipherControl, LB_GETCURSEL, 0, 0);
2631 int maxPos = (int) SendMessage(cipherControl, LB_GETCOUNT, 0, 0) - 1;
2632
2633 EnableWindow(GetDlgItem(dlg, up),
2634 curPos > 0 && curPos <= maxPos);
2635 EnableWindow(GetDlgItem(dlg, down),
2636 curPos >= 0 && curPos < maxPos);
2637 }
2638
2639 static void init_setup_dlg(PTInstVar pvar, HWND dlg)
2640 {
2641 HWND compressionControl = GetDlgItem(dlg, IDC_SSHCOMPRESSIONLEVEL);
2642 HWND cipherControl = GetDlgItem(dlg, IDC_SSHCIPHERPREFS);
2643 HWND kexControl = GetDlgItem(dlg, IDC_SSHKEX_LIST);
2644 HWND hostkeyControl = GetDlgItem(dlg, IDC_SSHHOST_KEY_LIST);
2645 HWND macControl = GetDlgItem(dlg, IDC_SSHMAC_LIST);
2646 HWND compControl = GetDlgItem(dlg, IDC_SSHCOMP_LIST);
2647 HWND hostkeyRotationControl = GetDlgItem(dlg, IDC_HOSTKEY_ROTATION_STATIC);
2648 HWND hostkeyRotationControlList = GetDlgItem(dlg, IDC_HOSTKEY_ROTATION_COMBO);
2649 int i;
2650 int ch;
2651 char uimsg[MAX_UIMSG];
2652 char *rotationItem[SSH_UPDATE_HOSTKEYS_MAX] = {
2653 "No",
2654 "Yes",
2655 "Ask",
2656 };
2657 char *rotationItemKey[SSH_UPDATE_HOSTKEYS_MAX] = {
2658 "DLG_SSHSETUP_HOSTKEY_ROTATION_NO",
2659 "DLG_SSHSETUP_HOSTKEY_ROTATION_YES",
2660 "DLG_SSHSETUP_HOSTKEY_ROTATION_ASK",
2661 };
2662
2663 GetWindowText(dlg, uimsg, sizeof(uimsg));
2664 UTIL_get_lang_msg("DLG_SSHSETUP_TITLE", pvar, uimsg);
2665 SetWindowText(dlg, pvar->ts->UIMsg);
2666 GetDlgItemText(dlg, IDC_COMPRESSLABEL, uimsg, sizeof(uimsg));
2667 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS", pvar, uimsg);
2668 SetDlgItemText(dlg, IDC_COMPRESSLABEL, pvar->ts->UIMsg);
2669 GetDlgItemText(dlg, IDC_COMPRESSNONE, uimsg, sizeof(uimsg));
2670 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NONE", pvar, uimsg);
2671 SetDlgItemText(dlg, IDC_COMPRESSNONE, pvar->ts->UIMsg);
2672 GetDlgItemText(dlg, IDC_COMPRESSHIGH, uimsg, sizeof(uimsg));
2673 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_HIGHEST", pvar, uimsg);
2674 SetDlgItemText(dlg, IDC_COMPRESSHIGH, pvar->ts->UIMsg);
2675 GetDlgItemText(dlg, IDC_COMPRESSNOTE, uimsg, sizeof(uimsg));
2676 UTIL_get_lang_msg("DLG_SSHSETUP_COMPRESS_NOTE", pvar, uimsg);
2677 SetDlgItemText(dlg, IDC_COMPRESSNOTE, pvar->ts->UIMsg);
2678
2679 GetDlgItemText(dlg, IDC_CIPHERORDER, uimsg, sizeof(uimsg));
2680 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER", pvar, uimsg);
2681 SetDlgItemText(dlg, IDC_CIPHERORDER, pvar->ts->UIMsg);
2682 GetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, uimsg, sizeof(uimsg));
2683 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_UP", pvar, uimsg);
2684 SetDlgItemText(dlg, IDC_SSHMOVECIPHERUP, pvar->ts->UIMsg);
2685 GetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, uimsg, sizeof(uimsg));
2686 UTIL_get_lang_msg("DLG_SSHSETUP_CIPHER_DOWN", pvar, uimsg);
2687 SetDlgItemText(dlg, IDC_SSHMOVECIPHERDOWN, pvar->ts->UIMsg);
2688
2689 GetDlgItemText(dlg, IDC_KEX_ORDER, uimsg, sizeof(uimsg));
2690 UTIL_get_lang_msg("DLG_SSHSETUP_KEX", pvar, uimsg);
2691 SetDlgItemText(dlg, IDC_KEX_ORDER, pvar->ts->UIMsg);
2692 GetDlgItemText(dlg, IDC_SSHKEX_MOVEUP, uimsg, sizeof(uimsg));
2693 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_UP", pvar, uimsg);
2694 SetDlgItemText(dlg, IDC_SSHKEX_MOVEUP, pvar->ts->UIMsg);
2695 GetDlgItemText(dlg, IDC_SSHKEX_MOVEDOWN, uimsg, sizeof(uimsg));
2696 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_DOWN", pvar, uimsg);
2697 SetDlgItemText(dlg, IDC_SSHKEX_MOVEDOWN, pvar->ts->UIMsg);
2698
2699 GetDlgItemText(dlg, IDC_HOST_KEY_ORDER, uimsg, sizeof(uimsg));
2700 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY", pvar, uimsg);
2701 SetDlgItemText(dlg, IDC_HOST_KEY_ORDER, pvar->ts->UIMsg);
2702 GetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEUP, uimsg, sizeof(uimsg));
2703 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_UP", pvar, uimsg);
2704 SetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEUP, pvar->ts->UIMsg);
2705 GetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEDOWN, uimsg, sizeof(uimsg));
2706 UTIL_get_lang_msg("DLG_SSHSETUP_HOST_KEY_DOWN", pvar, uimsg);
2707 SetDlgItemText(dlg, IDC_SSHHOST_KEY_MOVEDOWN, pvar->ts->UIMsg);
2708
2709 GetDlgItemText(dlg, IDC_MAC_ORDER, uimsg, sizeof(uimsg));
2710 UTIL_get_lang_msg("DLG_SSHSETUP_MAC", pvar, uimsg);
2711 SetDlgItemText(dlg, IDC_MAC_ORDER, pvar->ts->UIMsg);
2712 GetDlgItemText(dlg, IDC_SSHMAC_MOVEUP, uimsg, sizeof(uimsg));
2713 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_UP", pvar, uimsg);
2714 SetDlgItemText(dlg, IDC_SSHMAC_MOVEUP, pvar->ts->UIMsg);
2715 GetDlgItemText(dlg, IDC_SSHMAC_MOVEDOWN, uimsg, sizeof(uimsg));
2716 UTIL_get_lang_msg("DLG_SSHSETUP_MAC_DOWN", pvar, uimsg);
2717 SetDlgItemText(dlg, IDC_SSHMAC_MOVEDOWN, pvar->ts->UIMsg);
2718
2719 GetDlgItemText(dlg, IDC_COMP_ORDER, uimsg, sizeof(uimsg));
2720 UTIL_get_lang_msg("DLG_SSHSETUP_COMP", pvar, uimsg);
2721 SetDlgItemText(dlg, IDC_COMP_ORDER, pvar->ts->UIMsg);
2722 GetDlgItemText(dlg, IDC_SSHCOMP_MOVEUP, uimsg, sizeof(uimsg));
2723 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_UP", pvar, uimsg);
2724 SetDlgItemText(dlg, IDC_SSHCOMP_MOVEUP, pvar->ts->UIMsg);
2725 GetDlgItemText(dlg, IDC_SSHCOMP_MOVEDOWN, uimsg, sizeof(uimsg));
2726 UTIL_get_lang_msg("DLG_SSHSETUP_COMP_DOWN", pvar, uimsg);
2727 SetDlgItemText(dlg, IDC_SSHCOMP_MOVEDOWN, pvar->ts->UIMsg);
2728
2729 GetDlgItemText(dlg, IDC_KNOWNHOSTS, uimsg, sizeof(uimsg));
2730 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST", pvar, uimsg);
2731 SetDlgItemText(dlg, IDC_KNOWNHOSTS, pvar->ts->UIMsg);
2732 GetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, uimsg, sizeof(uimsg));
2733 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RW", pvar, uimsg);
2734 SetDlgItemText(dlg, IDC_CHOOSEREADWRITEFILE, pvar->ts->UIMsg);
2735 GetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, uimsg, sizeof(uimsg));
2736 UTIL_get_lang_msg("DLG_SSHSETUP_KNOWNHOST_RO", pvar, uimsg);
2737 SetDlgItemText(dlg, IDC_CHOOSEREADONLYFILE, pvar->ts->UIMsg);
2738 GetDlgItemText(dlg, IDC_HEARTBEATLABEL, uimsg, sizeof(uimsg));
2739 UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT", pvar, uimsg);
2740 SetDlgItemText(dlg, IDC_HEARTBEATLABEL, pvar->ts->UIMsg);
2741 GetDlgItemText(dlg, IDC_HEARTBEATLABEL2, uimsg, sizeof(uimsg));
2742 UTIL_get_lang_msg("DLG_SSHSETUP_HEARTBEAT_UNIT", pvar, uimsg);
2743 SetDlgItemText(dlg, IDC_HEARTBEATLABEL2, pvar->ts->UIMsg);
2744 GetDlgItemText(dlg, IDC_REMEMBERPASSWORD, uimsg, sizeof(uimsg));
2745 UTIL_get_lang_msg("DLG_SSHSETUP_PASSWORD", pvar, uimsg);
2746 SetDlgItemText(dlg, IDC_REMEMBERPASSWORD, pvar->ts->UIMsg);
2747 GetDlgItemText(dlg, IDC_FORWARDAGENT, uimsg, sizeof(uimsg));
2748 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENT", pvar, uimsg);
2749 SetDlgItemText(dlg, IDC_FORWARDAGENT, pvar->ts->UIMsg);
2750 GetDlgItemText(dlg, IDC_FORWARDAGENTCONFIRM, uimsg, sizeof(uimsg));
2751 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENTCONFIRM", pvar, uimsg);
2752 SetDlgItemText(dlg, IDC_FORWARDAGENTCONFIRM, pvar->ts->UIMsg);
2753 GetDlgItemText(dlg, IDC_FORWARDAGENTNOTIFY, uimsg, sizeof(uimsg));
2754 UTIL_get_lang_msg("DLG_SSHSETUP_FORWARDAGENTNOTIFY", pvar, uimsg);
2755 SetDlgItemText(dlg, IDC_FORWARDAGENTNOTIFY, pvar->ts->UIMsg);
2756 GetDlgItemText(dlg, IDC_VERIFYHOSTKEYDNS, uimsg, sizeof(uimsg));
2757 UTIL_get_lang_msg("DLG_SSHSETUP_VERIFYHOSTKEYDNS", pvar, uimsg);
2758 SetDlgItemText(dlg, IDC_VERIFYHOSTKEYDNS, pvar->ts->UIMsg);
2759 GetDlgItemText(dlg, IDC_NOTICEBANNER, uimsg, sizeof(uimsg));
2760 UTIL_get_lang_msg("DLG_SSHSETUP_NOTICE", pvar, uimsg);
2761 SetDlgItemText(dlg, IDC_NOTICEBANNER, pvar->ts->UIMsg);
2762 GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
2763 UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
2764 SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
2765 GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
2766 UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
2767 SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
2768
2769 GetDlgItemText(dlg, IDC_HOSTKEY_ROTATION_STATIC, uimsg, sizeof(uimsg));
2770 UTIL_get_lang_msg("DLG_SSHSETUP_HOSTKEY_ROTATION", pvar, uimsg);
2771 SetDlgItemText(dlg, IDC_HOSTKEY_ROTATION_STATIC, pvar->ts->UIMsg);
2772
2773 SendMessage(compressionControl, TBM_SETRANGE, TRUE, MAKELONG(0, 9));
2774 SendMessage(compressionControl, TBM_SETPOS, TRUE,
2775 pvar->settings.CompressionLevel);
2776
2777 // Cipher order
2778 normalize_cipher_order(pvar->settings.CipherOrder);
2779
2780 for (i = 0; pvar->settings.CipherOrder[i] != 0; i++) {
2781 int cipher = pvar->settings.CipherOrder[i] - '0';
2782 char *name = get_cipher_name(cipher);
2783
2784 if (name != NULL) {
2785 SendMessage(cipherControl, LB_ADDSTRING, 0, (LPARAM) name);
2786 }
2787 }
2788
2789 SendMessage(cipherControl, LB_SETCURSEL, 0, 0);
2790 set_move_button_status(dlg, IDC_SSHCIPHERPREFS, IDC_SSHMOVECIPHERUP, IDC_SSHMOVECIPHERDOWN);
2791
2792 // KEX order
2793 normalize_kex_order(pvar->settings.KexOrder);
2794 for (i = 0; pvar->settings.KexOrder[i] != 0; i++) {
2795 int index = pvar->settings.KexOrder[i] - '0';
2796 char *name = NULL;
2797
2798 if (index == 0) {
2799 UTIL_get_lang_msg("DLG_SSHSETUP_KEX_BORDER", pvar,
2800 "<KEXs below this line are disabled>");
2801 name = pvar->ts->UIMsg;
2802 } else {
2803 name = get_kex_algorithm_name(index);
2804 }
2805
2806 if (name != NULL) {
2807 SendMessage(kexControl, LB_ADDSTRING, 0, (LPARAM) name);
2808 }
2809 }
2810 SendMessage(kexControl, LB_SETCURSEL, 0, 0);
2811 set_move_button_status(dlg, IDC_SSHKEX_LIST, IDC_SSHKEX_MOVEUP, IDC_SSHKEX_MOVEDOWN);
2812
2813 // Host Key order