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 5620 - (show annotations) (download) (as text)
Thu Jun 26 12:48:19 2014 UTC (9 years, 9 months ago) by yutakapon
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 179473 byte(s) 
チケット #33822 notify_nonfatal_errorの一部停止

ポート転送でローカルアプリケーションにデータ送信する処理で、送信失敗した場合の
エラーポップアップメッセージ（＆ログ採取）を抑止することができる設定を追加した。
デフォルトは無効。

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