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