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