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