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