Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Annotation of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/ttxssh.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 7706 - (hide annotations) (download) (as text)
Tue May 21 15:20:52 2019 UTC (4 years, 10 months ago) by zmatsuo
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 174100 byte(s) 
ダイアログフォントの設定をメモリに持つようにした

- common/tttype.h に ダイアログフォントに関するメンバを追加
- SetDialogFont()#common/dlglib_cpp.cpp の仕様を変更
- CVTWindow::OnSetupDlgFont#teraterm/vtwin.cpp
  ダイアログフォント設定でiniファイルに書き込まないようにした
- ReadIniFile(),WriteIniFile()#ttpset/ttset.cで読み,書き追加
<
1 maya 3227 /*
2 doda 6841 * Copyright (c) 1998-2001, Robert O'Callahan
3 zmatsuo 7605 * (C) 2004-2019 TeraTerm Project
4 doda 6841 * All rights reserved.
5     *
6     * Redistribution and use in source and binary forms, with or without
7     * modification, are permitted provided that the following conditions
8     * are met:
9     *
10     * 1. Redistributions of source code must retain the above copyright
11     * notice, this list of conditions and the following disclaimer.
12     * 2. Redistributions in binary form must reproduce the above copyright
13     * notice, this list of conditions and the following disclaimer in the
14     * documentation and/or other materials provided with the distribution.
15     * 3. The name of the author may not be used to endorse or promote products
16     * derived from this software without specific prior written permission.
17     *
18     * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19     * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20     * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21     * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22     * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23     * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27     * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28     */
29 maya 3227
30     /* Tera Term extension mechanism
31     Robert O'Callahan (roc+tt@cs.cmu.edu)
32    
33     Tera Term by Takashi Teranishi (teranishi@rikaxp.riken.go.jp)
34     */
35    
36 zmatsuo 7554 #include "teraterm_conf.h"
37 maya 3227 #include "ttxssh.h"
38     #include "fwdui.h"
39     #include "util.h"
40     #include "ssh.h"
41     #include "ttcommon.h"
42 r850 3298 #include "ttlib.h"
43 yutakapon 5545 #include "keyfiles.h"
44 doda 6250 #include "arc4random.h"
45 zmatsuo 7605 #include "auth.h"
46 maya 3227
47     #include <stdlib.h>
48     #include <stdio.h>
49     #include <string.h>
50     #include <io.h>
51     #include <fcntl.h>
52     #include <sys/stat.h>
53     #include <time.h>
54 doda 3232 #include <mbstring.h>
55 maya 3227
56     #include "resource.h"
57     #include <commctrl.h>
58     #include <commdlg.h>
59     #include <winsock2.h>
60 doda 6801 static char *ProtocolFamilyList[] = { "UNSPEC", "IPv6", "IPv4", NULL };
61 maya 3227
62 zmatsuo 7542 #include <lmcons.h>
63 maya 3227
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 maya 4321 #include "key.h"
80 zmatsuo 7560 #include "dlglib.h"
81 maya 3227
82     #include "sftp.h"
83    
84     #include "compat_w95.h"
85 zmatsuo 7554 #include "compat_win.h"
86 maya 3227
87 maya 6625 #include "libputty.h"
88 yutakapon 4533
89 zmatsuo 7560 #undef DialogBoxParam
90     #define DialogBoxParam(p1,p2,p3,p4,p5) \
91     TTDialogBoxParam(p1,p2,p3,p4,p5)
92     #undef EndDialog
93     #define EndDialog(p1,p2) \
94     TTEndDialog(p1, p2)
95    
96 maya 3227 #define MATCH_STR(s, o) strncmp((s), (o), NUM_ELEM(o) - 1)
97     #define MATCH_STR_I(s, o) _strnicmp((s), (o), NUM_ELEM(o) - 1)
98    
99     /* This extension implements SSH, so we choose a load order in the
100     "protocols" range. */
101     #define ORDER 2500
102    
103     static HICON SecureLargeIcon = NULL;
104     static HICON SecureSmallIcon = NULL;
105 doda 6691 static HICON SecureNotifyIcon = NULL;
106     static HICON OldNotifyIcon = NULL;
107 maya 3227
108 yutakapon 5578 static HFONT DlgAboutTextFont;
109 maya 3227
110 doda 6801 static TInstVar *pvar;
111 maya 3227
112     typedef struct {
113 maya 4307 int cnt;
114     HWND dlg;
115 maya 4378 ssh_keytype type;
116 maya 3227 } cbarg_t;
117    
118     /* WIN32 allows multiple instances of a DLL */
119     static TInstVar InstVar;
120    
121     /*
122     This code makes lots of assumptions about the order in which Tera Term
123     does things, and how. A key assumption is that the Notification window
124     passed into WSAAsyncSelect is the main terminal window. We also assume
125     that the socket used in the first WSAconnect is the main session socket.
126     */
127    
128     static void init_TTSSH(PTInstVar pvar)
129     {
130     pvar->socket = INVALID_SOCKET;
131     pvar->OldLargeIcon = NULL;
132     pvar->OldSmallIcon = NULL;
133     pvar->NotificationWindow = NULL;
134     pvar->hostdlg_activated = FALSE;
135     pvar->socket = INVALID_SOCKET;
136     pvar->NotificationWindow = NULL;
137     pvar->protocol_major = 0;
138     pvar->protocol_minor = 0;
139    
140     PKT_init(pvar);
141     SSH_init(pvar);
142     CRYPT_init(pvar);
143     AUTH_init(pvar);
144     HOSTS_init(pvar);
145     FWD_init(pvar);
146     FWDUI_init(pvar);
147    
148     ssh_heartbeat_lock_initialize();
149     }
150    
151     static void uninit_TTSSH(PTInstVar pvar)
152     {
153     halt_ssh_heartbeat_thread(pvar);
154    
155     ssh2_channel_free();
156    
157     SSH_end(pvar);
158     PKT_end(pvar);
159     AUTH_end(pvar);
160     CRYPT_end(pvar);
161     HOSTS_end(pvar);
162     FWD_end(pvar);
163     FWDUI_end(pvar);
164    
165     if (pvar->OldLargeIcon != NULL) {
166     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
167     (LPARAM) pvar->OldLargeIcon);
168     pvar->OldLargeIcon = NULL;
169     }
170     if (pvar->OldSmallIcon != NULL) {
171     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
172     (LPARAM) pvar->OldSmallIcon);
173     pvar->OldSmallIcon = NULL;
174     }
175 doda 6691 if (OldNotifyIcon) {
176     SetCustomNotifyIcon(OldNotifyIcon);
177     }
178 maya 3227
179     ssh_heartbeat_lock_finalize();
180     }
181    
182 doda 6801 static void PASCAL TTXInit(PTTSet ts, PComVar cv)
183 maya 3227 {
184     pvar->settings = *pvar->ts_SSH;
185     pvar->ts = ts;
186     pvar->cv = cv;
187     pvar->fatal_error = FALSE;
188     pvar->showing_err = FALSE;
189     pvar->err_msg = NULL;
190    
191     init_TTSSH(pvar);
192     }
193    
194 maya 4378 static void normalize_generic_order(char *buf, char default_strings[], int default_strings_len)
195     {
196     char listed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
197     char allowed[max(KEX_DH_MAX,max(SSH_CIPHER_MAX,max(KEY_MAX,max(HMAC_MAX,COMP_MAX)))) + 1];
198 maya 6031 int i, j, k=-1;
199 maya 4378
200     memset(listed, 0, sizeof(listed));
201     memset(allowed, 0, sizeof(allowed));
202 yutakapon 6508
203     // �����������������������X�g�������B
204 maya 4378 for (i = 0; i < default_strings_len ; i++) {
205     allowed[default_strings[i]] = 1;
206     }
207    
208 yutakapon 6508 // �w�����������������������A���������������������A�d���������������������B
209     //
210     // ex. (i=5 ����������������)
211     // i=012345
212     // >:=9<87;A@?B3026(\0)
213     // i+1
214     // <------------>
215     // ��
216     // >:=9<7;A@?B3026(\0)
217     //
218 maya 4378 for (i = 0; buf[i] != 0; i++) {
219     int num = buf[i] - '0';
220    
221     if (num < 0 || num > default_strings_len
222     || !allowed[num]
223     || listed[num]) {
224     memmove(buf + i, buf + i + 1, strlen(buf + i + 1) + 1);
225     i--;
226     } else {
227     listed[num] = 1;
228     }
229 maya 6031
230 yutakapon 6508 // disabled line���������A���u���o���������B
231 maya 6031 if (num == 0) {
232     k = i;
233     }
234 maya 4378 }
235    
236 yutakapon 6508 // �w���������������������������Adisabled line�����O���}�������B
237     //
238     // ex. (Z���}������)
239     // k
240     // >:=9<87;A@?B3026(\0)
241     // k+1
242     // <---->
243     // �� k
244     // >:=9<87;A@?B30026(\0)
245     // �� k
246     // >:=9<87;A@?B3Z026(\0)
247     //
248 maya 6031 for (j = 0; j < default_strings_len && default_strings[j] != 0; j++) {
249     int num = default_strings[j];
250    
251     if (!listed[num] && k >= 0) {
252 yutakapon 6508 int copylen = strlen(buf + k + 1) + 1;
253    
254     memmove(buf + k + 1, buf + k, copylen);
255     buf[k + 1 + copylen] = '\0'; // �I�[���Y�������t�����B
256 maya 6031 buf[k] = num + '0';
257     k++;
258     i++;
259     }
260     }
261     if (k < 0) {
262     j = 0;
263     }
264     else {
265     j++;
266     }
267 yutakapon 6508
268     // disabled line�������������������A�����������������������B
269 maya 6031 for (; j < default_strings_len ; j++) {
270     int num = default_strings[j];
271    
272     if (!listed[num]) {
273     buf[i] = num + '0';
274 doda 7454 listed[num] = 1;
275 maya 6031 i++;
276     }
277     }
278 maya 4378
279     buf[i] = 0;
280     }
281    
282 maya 3227 /*
283     * Remove unsupported cipher or duplicated cipher.
284     * Add unspecified ciphers at the end of list.
285     */
286 doda 6801 static void normalize_cipher_order(char *buf)
287 maya 3227 {
288     /* SSH_CIPHER_NONE means that all ciphers below that one are disabled.
289     We *never* allow no encryption. */
290 maya 4378 static char default_strings[] = {
291 doda 6985 SSH2_CIPHER_AES256_GCM,
292 doda 4433 SSH2_CIPHER_CAMELLIA256_CTR,
293 maya 3227 SSH2_CIPHER_AES256_CTR,
294 doda 4433 SSH2_CIPHER_CAMELLIA256_CBC,
295 maya 3227 SSH2_CIPHER_AES256_CBC,
296 doda 4433 SSH2_CIPHER_CAMELLIA192_CTR,
297 maya 3227 SSH2_CIPHER_AES192_CTR,
298 doda 4433 SSH2_CIPHER_CAMELLIA192_CBC,
299 maya 3227 SSH2_CIPHER_AES192_CBC,
300 doda 6985 SSH2_CIPHER_AES128_GCM,
301 doda 4433 SSH2_CIPHER_CAMELLIA128_CTR,
302 maya 3227 SSH2_CIPHER_AES128_CTR,
303 doda 4433 SSH2_CIPHER_CAMELLIA128_CBC,
304 maya 3227 SSH2_CIPHER_AES128_CBC,
305 doda 3850 SSH2_CIPHER_3DES_CTR,
306 maya 3227 SSH2_CIPHER_3DES_CBC,
307 doda 3850 SSH2_CIPHER_BLOWFISH_CTR,
308 maya 3227 SSH2_CIPHER_BLOWFISH_CBC,
309 doda 3850 SSH2_CIPHER_CAST128_CTR,
310 maya 3227 SSH2_CIPHER_CAST128_CBC,
311     SSH_CIPHER_3DES,
312     SSH_CIPHER_NONE,
313 maya 5917 SSH2_CIPHER_ARCFOUR256,
314     SSH2_CIPHER_ARCFOUR128,
315     SSH2_CIPHER_ARCFOUR,
316     SSH_CIPHER_BLOWFISH,
317 maya 3227 SSH_CIPHER_DES,
318 maya 4432 0, 0, 0 // Dummy for SSH_CIPHER_IDEA, SSH_CIPHER_TSS, SSH_CIPHER_RC4
319 maya 3227 };
320    
321 maya 4378 normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
322 maya 3227 }
323    
324 doda 6801 static void normalize_kex_order(char *buf)
325 yutakapon 4367 {
326     static char default_strings[] = {
327     KEX_ECDH_SHA2_256,
328     KEX_ECDH_SHA2_384,
329     KEX_ECDH_SHA2_521,
330 doda 6310 KEX_DH_GRP18_SHA512,
331     KEX_DH_GRP16_SHA512,
332 doda 6263 KEX_DH_GRP14_SHA256,
333 yutakapon 4367 KEX_DH_GEX_SHA256,
334     KEX_DH_GEX_SHA1,
335     KEX_DH_GRP14_SHA1,
336     KEX_DH_GRP1_SHA1,
337     KEX_DH_NONE,
338     };
339    
340     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
341     }
342    
343 doda 6801 static void normalize_host_key_order(char *buf)
344 yutakapon 4367 {
345     static char default_strings[] = {
346     KEY_ECDSA256,
347     KEY_ECDSA384,
348     KEY_ECDSA521,
349 yutakapon 5545 KEY_ED25519,
350 yutakapon 4367 KEY_RSA,
351     KEY_DSA,
352     KEY_NONE,
353     };
354    
355     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
356     }
357    
358 doda 6801 static void normalize_mac_order(char *buf)
359 yutakapon 4367 {
360     static char default_strings[] = {
361 doda 6969 HMAC_SHA2_512_EtM,
362     HMAC_SHA2_256_EtM,
363     HMAC_SHA1_EtM,
364 doda 4434 HMAC_SHA2_512,
365     HMAC_SHA2_256,
366 yutakapon 4367 HMAC_SHA1,
367 doda 6969 HMAC_RIPEMD160_EtM,
368 doda 4423 HMAC_RIPEMD160,
369 doda 6969 HMAC_MD5_EtM,
370 yutakapon 4367 HMAC_MD5,
371 doda 4426 HMAC_NONE,
372 doda 6969 HMAC_SHA1_96_EtM,
373     HMAC_MD5_96_EtM,
374 doda 4434 HMAC_SHA1_96,
375     HMAC_MD5_96,
376 doda 5016 0, // Dummy for HMAC_SHA2_512_96,
377     0, // Dummy for HMAC_SHA2_256_96,
378 yutakapon 4367 };
379    
380     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
381     }
382    
383 doda 6801 static void normalize_comp_order(char *buf)
384 yutakapon 4367 {
385     static char default_strings[] = {
386 doda 4371 COMP_DELAYED,
387     COMP_ZLIB,
388 maya 4378 COMP_NOCOMP,
389 yutakapon 4367 COMP_NONE,
390     };
391    
392     normalize_generic_order(buf, default_strings, NUM_ELEM(default_strings));
393     }
394    
395    
396 maya 3227 /* Remove local settings from the shared memory block. */
397     static void clear_local_settings(PTInstVar pvar)
398     {
399     pvar->ts_SSH->TryDefaultAuth = FALSE;
400     }
401    
402 doda 6801 static BOOL read_BOOL_option(PCHAR fileName, char *keyName, BOOL def)
403 maya 3227 {
404     char buf[1024];
405    
406     buf[0] = 0;
407     GetPrivateProfileString("TTSSH", keyName, "", buf, sizeof(buf),
408     fileName);
409     if (buf[0] == 0) {
410     return def;
411     } else {
412     return atoi(buf) != 0 ||
413     _stricmp(buf, "yes") == 0 ||
414     _stricmp(buf, "y") == 0;
415     }
416     }
417    
418 doda 6801 static void read_string_option(PCHAR fileName, char *keyName,
419     char *def, char *buf, int bufSize)
420 maya 3227 {
421    
422     buf[0] = 0;
423     GetPrivateProfileString("TTSSH", keyName, def, buf, bufSize, fileName);
424     }
425    
426     static void read_ssh_options(PTInstVar pvar, PCHAR fileName)
427     {
428     char buf[1024];
429 doda 6801 TS_SSH *settings = pvar->ts_SSH;
430 maya 3227
431     #define READ_STD_STRING_OPTION(name) \
432     read_string_option(fileName, #name, "", settings->name, sizeof(settings->name))
433    
434     settings->Enabled = read_BOOL_option(fileName, "Enabled", FALSE);
435    
436     buf[0] = 0;
437     GetPrivateProfileString("TTSSH", "Compression", "", buf, sizeof(buf),
438     fileName);
439     settings->CompressionLevel = atoi(buf);
440     if (settings->CompressionLevel < 0 || settings->CompressionLevel > 9) {
441     settings->CompressionLevel = 0;
442     }
443    
444     READ_STD_STRING_OPTION(DefaultUserName);
445 zmatsuo 7632 settings->DefaultUserType = GetPrivateProfileInt("TTSSH", "DefaultUserType", 1, fileName);
446    
447 maya 3227 READ_STD_STRING_OPTION(DefaultForwarding);
448     READ_STD_STRING_OPTION(DefaultRhostsLocalUserName);
449     READ_STD_STRING_OPTION(DefaultRhostsHostPrivateKeyFile);
450     READ_STD_STRING_OPTION(DefaultRSAPrivateKeyFile);
451    
452     READ_STD_STRING_OPTION(CipherOrder);
453     normalize_cipher_order(settings->CipherOrder);
454    
455 yutakapon 4367 // KEX order
456     READ_STD_STRING_OPTION(KexOrder);
457     normalize_kex_order(settings->KexOrder);
458     // Host Key algorithm order
459     READ_STD_STRING_OPTION(HostKeyOrder);
460     normalize_host_key_order(settings->HostKeyOrder);
461 doda 6821 // HMAC order
462 yutakapon 4367 READ_STD_STRING_OPTION(MacOrder);
463     normalize_mac_order(settings->MacOrder);
464     // Compression algorithm order
465     READ_STD_STRING_OPTION(CompOrder);
466     normalize_comp_order(settings->CompOrder);
467    
468 maya 3227 read_string_option(fileName, "KnownHostsFiles", "ssh_known_hosts",
469     settings->KnownHostsFiles,
470     sizeof(settings->KnownHostsFiles));
471    
472     buf[0] = 0;
473     GetPrivateProfileString("TTSSH", "DefaultAuthMethod", "", buf,
474     sizeof(buf), fileName);
475     settings->DefaultAuthMethod = atoi(buf);
476     if (settings->DefaultAuthMethod != SSH_AUTH_PASSWORD
477     && settings->DefaultAuthMethod != SSH_AUTH_RSA
478     && settings->DefaultAuthMethod != SSH_AUTH_TIS // add (2005.3.12 yutaka)
479     && settings->DefaultAuthMethod != SSH_AUTH_RHOSTS
480     && settings->DefaultAuthMethod != SSH_AUTH_PAGEANT) {
481     /* this default can never be SSH_AUTH_RHOSTS_RSA because that is not a
482     selection in the dialog box; SSH_AUTH_RHOSTS_RSA is automatically chosen
483     when the dialog box has rhosts selected and an host private key file
484     is supplied. */
485     settings->DefaultAuthMethod = SSH_AUTH_PASSWORD;
486     }
487    
488     buf[0] = 0;
489     GetPrivateProfileString("TTSSH", "LogLevel", "", buf, sizeof(buf),
490     fileName);
491     settings->LogLevel = atoi(buf);
492    
493     buf[0] = 0;
494     GetPrivateProfileString("TTSSH", "WriteBufferSize", "", buf,
495     sizeof(buf), fileName);
496     settings->WriteBufferSize = atoi(buf);
497     if (settings->WriteBufferSize <= 0) {
498     settings->WriteBufferSize = (PACKET_MAX_SIZE / 2); // 2MB
499     }
500    
501     // SSH protocol version (2004.10.11 yutaka)
502     // default is SSH2 (2004.11.30 yutaka)
503     settings->ssh_protocol_version = GetPrivateProfileInt("TTSSH", "ProtocolVersion", 2, fileName);
504    
505     // SSH heartbeat time(second) (2004.12.11 yutaka)
506     settings->ssh_heartbeat_overtime = GetPrivateProfileInt("TTSSH", "HeartBeat", 60, fileName);
507    
508     // �p�X���[�h�F�����������J���F�����g���p�X���[�h����������������������������������
509     // �\���B(2006.8.5 yutaka)
510     settings->remember_password = GetPrivateProfileInt("TTSSH", "RememberPassword", 1, fileName);
511    
512     // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
513     // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
514     settings->CheckAuthListFirst = read_BOOL_option(fileName, "CheckAuthListFirst", FALSE);
515    
516     // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
517     settings->EnableRsaShortKeyServer = read_BOOL_option(fileName, "EnableRsaShortKeyServer", FALSE);
518    
519     // agent forward ���L�������� (2008.11.25 maya)
520     settings->ForwardAgent = read_BOOL_option(fileName, "ForwardAgent", FALSE);
521    
522 maya 4229 // agent forward �m�F���L��������
523     settings->ForwardAgentConfirm = read_BOOL_option(fileName, "ForwardAgentConfirm", TRUE);
524    
525 doda 6663 // agent forward �m�F���L��������
526     settings->ForwardAgentNotify = read_BOOL_option(fileName, "ForwardAgentNotify", TRUE);
527    
528 doda 4531 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
529 doda 4619 settings->VerifyHostKeyDNS = read_BOOL_option(fileName, "VerifyHostKeyDNS", TRUE);
530 doda 4531
531 doda 5261 // icon
532     GetPrivateProfileString("TTSSH", "SSHIcon", "", buf, sizeof(buf), fileName);
533     if ((_stricmp(buf, "old") == 0) ||
534     (_stricmp(buf, "yellow") == 0) ||
535     (_stricmp(buf, "securett_yellow") == 0)) {
536     settings->IconID = IDI_SECURETT_YELLOW;
537     }
538 maya 6386 else if ((_stricmp(buf, "green") == 0) ||
539     (_stricmp(buf, "securett_green") == 0)) {
540     settings->IconID = IDI_SECURETT_GREEN;
541     }
542 doda 5261 else {
543     settings->IconID = IDI_SECURETT;
544     }
545    
546 yutakapon 5620 // �G���[�������x�������|�b�v�A�b�v���b�Z�[�W���}�~���� (2014.6.26 yutaka)
547     settings->DisablePopupMessage = GetPrivateProfileInt("TTSSH", "DisablePopupMessage", 0, fileName);
548    
549 doda 5793 READ_STD_STRING_OPTION(X11Display);
550    
551 yutakapon 5849 settings->UpdateHostkeys = GetPrivateProfileInt("TTSSH", "UpdateHostkeys", 0, fileName);
552 yutakapon 5839
553 doda 5900 settings->GexMinimalGroupSize = GetPrivateProfileInt("TTSSH", "GexMinimalGroupSize", 0, fileName);
554    
555 doda 7048 settings->AuthBanner = GetPrivateProfileInt("TTSSH", "AuthBanner", 1, fileName);
556    
557 maya 3227 clear_local_settings(pvar);
558     }
559    
560     static void write_ssh_options(PTInstVar pvar, PCHAR fileName,
561 doda 6801 TS_SSH *settings, BOOL copy_forward)
562 maya 3227 {
563     char buf[1024];
564    
565     WritePrivateProfileString("TTSSH", "Enabled",
566     settings->Enabled ? "1" : "0", fileName);
567    
568     _itoa(settings->CompressionLevel, buf, 10);
569     WritePrivateProfileString("TTSSH", "Compression", buf, fileName);
570    
571 zmatsuo 7632 _itoa(settings->DefaultUserType, buf, 10);
572     WritePrivateProfileString("TTSSH", "DefaultUserType", buf, fileName);
573 maya 3227 WritePrivateProfileString("TTSSH", "DefaultUserName",
574     settings->DefaultUserName, fileName);
575    
576     if (copy_forward) {
577     WritePrivateProfileString("TTSSH", "DefaultForwarding",
578 maya 5960 settings->DefaultForwarding, fileName);
579 maya 3227 }
580    
581     WritePrivateProfileString("TTSSH", "CipherOrder",
582     settings->CipherOrder, fileName);
583    
584 yutakapon 4367 WritePrivateProfileString("TTSSH", "KexOrder",
585     settings->KexOrder, fileName);
586    
587     WritePrivateProfileString("TTSSH", "HostKeyOrder",
588     settings->HostKeyOrder, fileName);
589    
590     WritePrivateProfileString("TTSSH", "MacOrder",
591     settings->MacOrder, fileName);
592    
593     WritePrivateProfileString("TTSSH", "CompOrder",
594     settings->CompOrder, fileName);
595    
596 maya 3227 WritePrivateProfileString("TTSSH", "KnownHostsFiles",
597     settings->KnownHostsFiles, fileName);
598    
599     WritePrivateProfileString("TTSSH", "DefaultRhostsLocalUserName",
600     settings->DefaultRhostsLocalUserName,
601     fileName);
602    
603     WritePrivateProfileString("TTSSH", "DefaultRhostsHostPrivateKeyFile",
604     settings->DefaultRhostsHostPrivateKeyFile,
605     fileName);
606    
607     WritePrivateProfileString("TTSSH", "DefaultRSAPrivateKeyFile",
608     settings->DefaultRSAPrivateKeyFile,
609     fileName);
610    
611     _itoa(settings->DefaultAuthMethod, buf, 10);
612     WritePrivateProfileString("TTSSH", "DefaultAuthMethod", buf, fileName);
613    
614     _itoa(settings->LogLevel, buf, 10);
615     WritePrivateProfileString("TTSSH", "LogLevel", buf, fileName);
616    
617     _itoa(settings->WriteBufferSize, buf, 10);
618     WritePrivateProfileString("TTSSH", "WriteBufferSize", buf, fileName);
619    
620     // SSH protocol version (2004.10.11 yutaka)
621     WritePrivateProfileString("TTSSH", "ProtocolVersion",
622     settings->ssh_protocol_version==2 ? "2" : "1",
623     fileName);
624    
625     // SSH heartbeat time(second) (2004.12.11 yutaka)
626     _snprintf_s(buf, sizeof(buf), _TRUNCATE,
627     "%d", settings->ssh_heartbeat_overtime);
628     WritePrivateProfileString("TTSSH", "HeartBeat", buf, fileName);
629    
630     // Remember password (2006.8.5 yutaka)
631     WritePrivateProfileString("TTSSH", "RememberPassword",
632     settings->remember_password ? "1" : "0",
633     fileName);
634    
635     // �������F���_�C�A���O���T�|�[�g�������������\�b�h���`�F�b�N���A
636     // ���������\�b�h���O���C�A�E�g���� (2007.9.24 maya)
637     WritePrivateProfileString("TTSSH", "CheckAuthListFirst",
638     settings->CheckAuthListFirst ? "1" : "0", fileName);
639    
640     // 768bit ������ RSA ���������T�[�o�����������L�������� (2008.9.11 maya)
641     WritePrivateProfileString("TTSSH", "EnableRsaShortKeyServer",
642     settings->EnableRsaShortKeyServer ? "1" : "0", fileName);
643    
644     // agent forward ���L�������� (2008.11.25 maya)
645     WritePrivateProfileString("TTSSH", "ForwardAgent",
646     settings->ForwardAgent ? "1" : "0", fileName);
647 maya 4229
648     // agent forward �m�F���L��������
649     WritePrivateProfileString("TTSSH", "ForwardAgentConfirm",
650     settings->ForwardAgentConfirm ? "1" : "0", fileName);
651 doda 4531
652 doda 6663 // agent forward ���m���L��������
653     WritePrivateProfileString("TTSSH", "ForwardAgentNotify",
654     settings->ForwardAgentNotify ? "1" : "0", fileName);
655    
656 doda 4531 // �z�X�g���� DNS �����`�F�b�N (RFC 4255)
657     WritePrivateProfileString("TTSSH", "VerifyHostKeyDNS",
658     settings->VerifyHostKeyDNS ? "1" : "0", fileName);
659 doda 5294
660     // SSH �A�C�R��
661 maya 6386 if (settings->IconID==IDI_SECURETT_YELLOW) {
662     WritePrivateProfileString("TTSSH", "SSHIcon", "yellow", fileName);
663     }
664     else if (settings->IconID==IDI_SECURETT_GREEN) {
665     WritePrivateProfileString("TTSSH", "SSHIcon", "green", fileName);
666     }
667     else {
668     WritePrivateProfileString("TTSSH", "SSHIcon", "Default", fileName);
669     }
670 yutakapon 5620
671     _itoa(settings->DisablePopupMessage, buf, 10);
672     WritePrivateProfileString("TTSSH", "DisablePopupMessage", buf, fileName);
673 doda 5793
674     WritePrivateProfileString("TTSSH", "X11Display", settings->X11Display, fileName);
675 yutakapon 5839
676 yutakapon 5849 _snprintf_s(buf, sizeof(buf), _TRUNCATE,
677     "%d", settings->UpdateHostkeys);
678     WritePrivateProfileString("TTSSH", "UpdateHostkeys", buf, fileName);
679 doda 5900
680     _itoa_s(settings->GexMinimalGroupSize, buf, sizeof(buf), 10);
681     WritePrivateProfileString("TTSSH", "GexMinimalGroupSize", buf, fileName);
682 doda 7048
683     _itoa_s(settings->AuthBanner, buf, sizeof(buf), 10);
684     WritePrivateProfileString("TTSSH", "AuthBanner", buf, fileName);
685 maya 3227 }
686    
687    
688     /* find free port in all protocol family */
689     static unsigned short find_local_port(PTInstVar pvar)
690     {
691     int tries;
692     SOCKET connecter;
693     struct addrinfo hints;
694 doda 6801 struct addrinfo *res;
695     struct addrinfo *res0;
696 maya 3227 unsigned short port;
697     char pname[NI_MAXHOST];
698    
699     if (pvar->session_settings.DefaultAuthMethod != SSH_AUTH_RHOSTS) {
700     return 0;
701     }
702    
703     /* The random numbers here are only used to try to get fresh
704     ports across runs (dangling ports can cause bind errors
705     if we're unlucky). They do not need to be (and are not)
706     cryptographically strong.
707     */
708     srand((unsigned) GetTickCount());
709    
710     for (tries = 20; tries > 0; tries--) {
711     memset(&hints, 0, sizeof(hints));
712     hints.ai_family = pvar->ts->ProtocolFamily;
713     hints.ai_flags = AI_PASSIVE;
714     hints.ai_socktype = SOCK_STREAM;
715     port = (unsigned) rand() % 512 + 512;
716     _snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", (int) port);
717     if (getaddrinfo(NULL, pname, &hints, &res0)) {
718     return 0;
719     /* NOT REACHED */
720     }
721    
722     for (res = res0; res; res = res->ai_next) {
723     if (res->ai_family == AF_INET || res->ai_family == AF_INET6)
724     continue;
725    
726     connecter =
727     socket(res->ai_family, res->ai_socktype, res->ai_protocol);
728     if (connecter == INVALID_SOCKET) {
729     freeaddrinfo(res0);
730     return 0;
731     }
732    
733     if (bind(connecter, res->ai_addr, res->ai_addrlen) !=
734     SOCKET_ERROR) {
735     return port;
736     freeaddrinfo(res0);
737     closesocket(connecter);
738     } else if (WSAGetLastError() != WSAEADDRINUSE) {
739     closesocket(connecter);
740     freeaddrinfo(res0);
741     return 0;
742     }
743    
744     closesocket(connecter);
745     }
746     freeaddrinfo(res0);
747     }
748    
749     return 0;
750     }
751    
752 doda 6801 static int PASCAL TTXconnect(SOCKET s,
753     const struct sockaddr *name,
754 maya 3227 int namelen)
755     {
756 maya 4584 if (pvar->socket == INVALID_SOCKET || pvar->socket != s) {
757 maya 3227 struct sockaddr_storage ss;
758     int len;
759    
760     pvar->socket = s;
761    
762     memset(&ss, 0, sizeof(ss));
763     switch (pvar->ts->ProtocolFamily) {
764     case AF_INET:
765     len = sizeof(struct sockaddr_in);
766 doda 6801 ((struct sockaddr_in *) &ss)->sin_family = AF_INET;
767     ((struct sockaddr_in *) &ss)->sin_addr.s_addr = INADDR_ANY;
768     ((struct sockaddr_in *) &ss)->sin_port =
769 maya 3227 htons(find_local_port(pvar));
770     break;
771     case AF_INET6:
772     len = sizeof(struct sockaddr_in6);
773 doda 6801 ((struct sockaddr_in6 *) &ss)->sin6_family = AF_INET6;
774 zmatsuo 7197 ((struct sockaddr_in6 *) &ss)->sin6_addr = in6addr_any;
775 doda 6801 ((struct sockaddr_in6 *) &ss)->sin6_port =
776 maya 3227 htons(find_local_port(pvar));
777     break;
778     default:
779 maya 4586 /* UNSPEC */
780 zmatsuo 7197 len = sizeof(ss);
781     ss.ss_family = AF_UNSPEC;
782 maya 3227 break;
783     }
784    
785 doda 6801 bind(s, (struct sockaddr *) &ss, len);
786 maya 3227 }
787    
788     return (pvar->Pconnect) (s, name, namelen);
789     }
790    
791 doda 6801 static int PASCAL TTXWSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
792 maya 3227 long lEvent)
793     {
794     if (s == pvar->socket) {
795     pvar->notification_events = lEvent;
796     pvar->notification_msg = wMsg;
797    
798     if (pvar->NotificationWindow == NULL) {
799     pvar->NotificationWindow = hWnd;
800     AUTH_advance_to_next_cred(pvar);
801     }
802     }
803    
804     return (pvar->PWSAAsyncSelect) (s, hWnd, wMsg, lEvent);
805     }
806    
807 doda 6801 static int PASCAL TTXrecv(SOCKET s, char *buf, int len, int flags)
808 maya 3227 {
809     if (s == pvar->socket) {
810     int ret;
811    
812     ssh_heartbeat_lock();
813     ret = PKT_recv(pvar, buf, len);
814     ssh_heartbeat_unlock();
815     return (ret);
816    
817     } else {
818     return (pvar->Precv) (s, buf, len, flags);
819     }
820     }
821    
822 doda 6801 static int PASCAL TTXsend(SOCKET s, char const *buf, int len,
823 maya 3227 int flags)
824     {
825     if (s == pvar->socket) {
826     ssh_heartbeat_lock();
827     SSH_send(pvar, buf, len);
828     ssh_heartbeat_unlock();
829     return len;
830     } else {
831     return (pvar->Psend) (s, buf, len, flags);
832     }
833     }
834    
835     void notify_established_secure_connection(PTInstVar pvar)
836     {
837     int fuLoad = LR_DEFAULTCOLOR;
838    
839 yutakapon 6286 if (IsWindowsNT4()) {
840 maya 3227 fuLoad = LR_VGACOLOR;
841     }
842    
843     // LoadIcon �������� LoadImage ���g�����������A
844     // 16x16 ���A�C�R���������I�������������������� (2006.8.9 maya)
845     if (SecureLargeIcon == NULL) {
846 doda 5261 SecureLargeIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
847 maya 3227 IMAGE_ICON, 0, 0, fuLoad);
848     }
849     if (SecureSmallIcon == NULL) {
850 doda 5261 SecureSmallIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
851 maya 3227 IMAGE_ICON, 16, 16, fuLoad);
852     }
853    
854     if (SecureLargeIcon != NULL && SecureSmallIcon != NULL) {
855     pvar->OldLargeIcon =
856 maya 3454 (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
857     ICON_BIG, 0);
858 maya 3227 pvar->OldSmallIcon =
859     (HICON) SendMessage(pvar->NotificationWindow, WM_GETICON,
860     ICON_SMALL, 0);
861    
862     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_BIG,
863     (LPARAM) SecureLargeIcon);
864     PostMessage(pvar->NotificationWindow, WM_SETICON, ICON_SMALL,
865     (LPARAM) SecureSmallIcon);
866     }
867    
868 doda 6691 if (IsWindows2000()) {
869     if (SecureNotifyIcon == NULL) {
870     SecureNotifyIcon = LoadImage(hInst, MAKEINTRESOURCE(pvar->settings.IconID),
871     IMAGE_ICON, 0, 0, LR_VGACOLOR | LR_SHARED);
872     }
873     OldNotifyIcon = GetCustomNotifyIcon();
874     SetCustomNotifyIcon(SecureNotifyIcon);
875     }
876    
877 doda 6809 logputs(LOG_LEVEL_VERBOSE, "Entering secure mode");
878 maya 3227 }
879    
880 doda 6801 void notify_closed_connection(PTInstVar pvar, char *send_msg)
881 maya 3227 {
882 maya 5678 SSH_notify_disconnecting(pvar, send_msg);
883 maya 3227 AUTH_notify_disconnecting(pvar);
884     HOSTS_notify_disconnecting(pvar);
885    
886     PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
887     pvar->socket, MAKELPARAM(FD_CLOSE, 0));
888     }
889    
890 doda 6801 static void add_err_msg(PTInstVar pvar, char *msg)
891 maya 3227 {
892     if (pvar->err_msg != NULL) {
893     int buf_len = strlen(pvar->err_msg) + 3 + strlen(msg);
894 doda 6801 char *buf = (char *) malloc(buf_len);
895 maya 3227
896     strncpy_s(buf, buf_len, pvar->err_msg, _TRUNCATE);
897     strncat_s(buf, buf_len, "\n\n", _TRUNCATE);
898     strncat_s(buf, buf_len, msg, _TRUNCATE);
899     free(pvar->err_msg);
900     pvar->err_msg = buf;
901     } else {
902     pvar->err_msg = _strdup(msg);
903     }
904     }
905    
906 doda 6801 void notify_nonfatal_error(PTInstVar pvar, char *msg)
907 maya 3227 {
908     if (!pvar->showing_err) {
909     // �������������������m���E�B���h�E�����������A�f�X�N�g�b�v���I�[�i�[������
910     // ���b�Z�[�W�{�b�N�X���o���������B(2006.6.11 yutaka)
911     if (pvar->NotificationWindow == NULL) {
912 doda 6688 UTIL_get_lang_msg("MSG_NONFATAL_ERROR", pvar,
913 maya 3227 "Tera Term: not fatal error");
914     MessageBox(NULL, msg, pvar->ts->UIMsg, MB_OK|MB_ICONINFORMATION);
915     msg[0] = '\0';
916    
917     } else {
918     PostMessage(pvar->NotificationWindow, WM_COMMAND,
919     ID_SSHASYNCMESSAGEBOX, 0);
920     }
921     }
922     if (msg[0] != 0) {
923 doda 6809 logputs(LOG_LEVEL_ERROR, msg);
924 maya 3227 add_err_msg(pvar, msg);
925     }
926     }
927    
928 doda 6801 void notify_fatal_error(PTInstVar pvar, char *msg, BOOL send_disconnect)
929 maya 3227 {
930     if (msg[0] != 0) {
931 doda 6809 logputs(LOG_LEVEL_FATAL, msg);
932 maya 3227 add_err_msg(pvar, msg);
933     }
934    
935     if (!pvar->fatal_error) {
936     pvar->fatal_error = TRUE;
937    
938 maya 5678 if (send_disconnect) {
939     SSH_notify_disconnecting(pvar, msg);
940     }
941 maya 3227 AUTH_notify_disconnecting(pvar);
942     HOSTS_notify_disconnecting(pvar);
943    
944     PostMessage(pvar->NotificationWindow, WM_USER_COMMNOTIFY,
945     pvar->socket, MAKELPARAM(FD_CLOSE,
946     (pvar->PWSAGetLastError) ()));
947     }
948     }
949    
950 doda 6809 void logputs(int level, char *msg)
951 maya 3227 {
952 doda 6823 if (level <= pvar->settings.LogLevel) {
953 doda 7016 char buf[4096];
954 maya 3227 int file;
955    
956     get_teraterm_dir_relative_name(buf, NUM_ELEM(buf), "TTSSH.LOG");
957     file = _open(buf, _O_RDWR | _O_APPEND | _O_CREAT | _O_TEXT,
958     _S_IREAD | _S_IWRITE);
959    
960     if (file >= 0) {
961 doda 6778 char *strtime = mctimelocal("%Y-%m-%d %H:%M:%S.%NZ", TRUE);
962 maya 4546 DWORD processid;
963 maya 3227 char tmp[26];
964 maya 4546
965     _write(file, strtime, strlen(strtime));
966 maya 3227 GetWindowThreadProcessId(pvar->cv->HWin, &processid);
967     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " [%lu] ",processid);
968     _write(file, tmp, strlen(tmp));
969     _write(file, msg, strlen(msg));
970     _write(file, "\n", 1);
971     _close(file);
972     }
973     }
974     }
975    
976 zmatsuo 7648 #if defined(_MSC_VER)
977     void logprintf(int level, _Printf_format_string_ const char *fmt, ...)
978     #else
979     void logprintf(int level, const char *fmt, ...)
980     #endif
981 doda 6051 {
982     char buff[4096];
983     va_list params;
984    
985 doda 6823 if (level <= pvar->settings.LogLevel) {
986 doda 6051 va_start(params, fmt);
987     vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
988     va_end(params);
989    
990 doda 6809 logputs(level, buff);
991 doda 6051 }
992     }
993    
994 yutakapon 6302 static void format_line_hexdump(char *buf, int buflen, int addr, int *bytes, int byte_cnt)
995     {
996     int i, c;
997     char tmp[128];
998    
999     buf[0] = 0;
1000    
1001     /* �������A�h���X�\�� */
1002     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%08X : ", addr);
1003     strncat_s(buf, buflen, tmp, _TRUNCATE);
1004    
1005     /* �o�C�i���\���i4�o�C�g�������������}���j*/
1006     for (i = 0; i < byte_cnt; i++) {
1007     if (i > 0 && i % 4 == 0) {
1008     strncat_s(buf, buflen, " ", _TRUNCATE);
1009     }
1010    
1011     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%02X", bytes[i]);
1012     strncat_s(buf, buflen, tmp, _TRUNCATE);
1013     }
1014    
1015     /* ASCII�\���������������������� */
1016     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, " %*s%*s", (16 - byte_cnt) * 2 + 1, " ", (16 - byte_cnt + 3) / 4, " ");
1017     strncat_s(buf, buflen, tmp, _TRUNCATE);
1018    
1019     /* ASCII�\�� */
1020     for (i = 0; i < byte_cnt; i++) {
1021     c = bytes[i];
1022     if (isprint(c)) {
1023     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, "%c", c);
1024     strncat_s(buf, buflen, tmp, _TRUNCATE);
1025     }
1026     else {
1027     strncat_s(buf, buflen, ".", _TRUNCATE);
1028     }
1029     }
1030    
1031     //strncat_s(buf, buflen, "\n", _TRUNCATE);
1032     }
1033    
1034 zmatsuo 7648 #if defined(_MSC_VER)
1035     void logprintf_hexdump(int level, const char *data, int len, _Printf_format_string_ const char *fmt, ...)
1036     #else
1037     void logprintf_hexdump(int level, const char *data, int len, const char *fmt, ...)
1038     #endif
1039 yutakapon 6302 {
1040     char buff[4096];
1041     va_list params;
1042     int c, addr;
1043     int bytes[16], *ptr;
1044     int byte_cnt;
1045     int i;
1046    
1047 doda 6823 if (level <= pvar->settings.LogLevel) {
1048 yutakapon 6302 va_start(params, fmt);
1049     vsnprintf_s(buff, sizeof(buff), _TRUNCATE, fmt, params);
1050     va_end(params);
1051    
1052 doda 6809 logputs(level, buff);
1053 yutakapon 6302
1054     addr = 0;
1055     byte_cnt = 0;
1056     ptr = bytes;
1057     for (i = 0; i < len; i++) {
1058     c = data[i];
1059     *ptr++ = c & 0xff;
1060     byte_cnt++;
1061    
1062     if (byte_cnt == 16) {
1063     format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1064 doda 6809 logputs(level, buff);
1065 yutakapon 6302
1066     addr += 16;
1067     byte_cnt = 0;
1068     ptr = bytes;
1069     }
1070     }
1071    
1072     if (byte_cnt > 0) {
1073     format_line_hexdump(buff, sizeof(buff), addr, bytes, byte_cnt);
1074 doda 6809 logputs(level, buff);
1075 yutakapon 6302 }
1076     }
1077     }
1078    
1079 doda 6801 static void PASCAL TTXOpenTCP(TTXSockHooks *hooks)
1080 maya 3227 {
1081     if (pvar->settings.Enabled) {
1082     // TCPLocalEcho/TCPCRSend ������������ (maya 2007.4.25)
1083 doda 3579 pvar->origDisableTCPEchoCR = pvar->ts->DisableTCPEchoCR;
1084 maya 3227 pvar->ts->DisableTCPEchoCR = TRUE;
1085    
1086     pvar->session_settings = pvar->settings;
1087    
1088 doda 6809 logputs(LOG_LEVEL_VERBOSE, "---------------------------------------------------------------------");
1089     logputs(LOG_LEVEL_VERBOSE, "Initiating SSH session");
1090 maya 3227
1091     FWDUI_load_settings(pvar);
1092    
1093     pvar->cv->TelAutoDetect = FALSE;
1094     /* This next line should not be needed because Tera Term's
1095     CommLib should find ts->Telnet == 0 ... but we'll do this
1096     just to be on the safe side. */
1097     pvar->cv->TelFlag = FALSE;
1098 doda 3495 pvar->cv->TelLineMode = FALSE;
1099 maya 3227
1100     pvar->Precv = *hooks->Precv;
1101     pvar->Psend = *hooks->Psend;
1102     pvar->PWSAAsyncSelect = *hooks->PWSAAsyncSelect;
1103     pvar->Pconnect = *hooks->Pconnect;
1104     pvar->PWSAGetLastError = *hooks->PWSAGetLastError;
1105    
1106     *hooks->Precv = TTXrecv;
1107     *hooks->Psend = TTXsend;
1108     *hooks->PWSAAsyncSelect = TTXWSAAsyncSelect;
1109     *hooks->Pconnect = TTXconnect;
1110    
1111     SSH_open(pvar);
1112     HOSTS_open(pvar);
1113     FWDUI_open(pvar);
1114    
1115     // ������ myproposal �����f���������A�������O�����������B (2006.6.26 maya)
1116     SSH2_update_cipher_myproposal(pvar);
1117 yutakapon 4367 SSH2_update_kex_myproposal(pvar);
1118     SSH2_update_host_key_myproposal(pvar);
1119     SSH2_update_hmac_myproposal(pvar);
1120 maya 3227 SSH2_update_compression_myproposal(pvar);
1121     }
1122     }
1123    
1124 doda 6801 static void PASCAL TTXCloseTCP(TTXSockHooks *hooks)
1125 maya 3227 {
1126     if (pvar->session_settings.Enabled) {
1127     pvar->socket = INVALID_SOCKET;
1128    
1129 doda 6809 logputs(LOG_LEVEL_VERBOSE, "Terminating SSH session...");
1130 maya 3227
1131     *hooks->Precv = pvar->Precv;
1132     *hooks->Psend = pvar->Psend;
1133     *hooks->PWSAAsyncSelect = pvar->PWSAAsyncSelect;
1134     *hooks->Pconnect = pvar->Pconnect;
1135 doda 3579
1136     pvar->ts->DisableTCPEchoCR = pvar->origDisableTCPEchoCR;
1137 maya 3227 }
1138    
1139     uninit_TTSSH(pvar);
1140     init_TTSSH(pvar);
1141     }
1142    
1143     static void enable_dlg_items(HWND dlg, int from, int to, BOOL enabled)
1144     {
1145     for (; from <= to; from++) {
1146     EnableWindow(GetDlgItem(dlg, from), enabled);
1147     }
1148     }
1149    
1150     // C-p/C-n/C-b/C-f/C-a/C-e ���T�|�[�g (2007.9.5 maya)
1151     // C-d/C-k ���T�|�[�g (2007.10.3 yutaka)
1152     // �h���b�v�_�E���������G�f�B�b�g�R���g���[����
1153     // �T�u�N���X�������������E�C���h�E�v���V�[�W��
1154     WNDPROC OrigHostnameEditProc; // Original window procedure
1155     LRESULT CALLBACK HostnameEditProc(HWND dlg, UINT msg,
1156 maya 5868 WPARAM wParam, LPARAM lParam)
1157 maya 3227 {
1158     HWND parent;
1159     int max, select, len;
1160     char *str, *orgstr;
1161    
1162     switch (msg) {
1163     // �L�[�����������������m����
1164     case WM_KEYDOWN:
1165     if (GetKeyState(VK_CONTROL) < 0) {
1166     switch (wParam) {
1167     case 0x50: // Ctrl+p ... up
1168     parent = GetParent(dlg);
1169     select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1170     if (select > 0) {
1171     PostMessage(parent, CB_SETCURSEL, select - 1, 0);
1172     }
1173     return 0;
1174     case 0x4e: // Ctrl+n ... down
1175     parent = GetParent(dlg);
1176     max = SendMessage(parent, CB_GETCOUNT, 0, 0);
1177     select = SendMessage(parent, CB_GETCURSEL, 0, 0);
1178     if (select < max - 1) {
1179     PostMessage(parent, CB_SETCURSEL, select + 1, 0);
1180     }
1181     return 0;
1182     case 0x42: // Ctrl+b ... left
1183     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1184     PostMessage(dlg, EM_SETSEL, select-1, select-1);
1185     return 0;
1186     case 0x46: // Ctrl+f ... right
1187     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1188     max = GetWindowTextLength(dlg) ;
1189     PostMessage(dlg, EM_SETSEL, select+1, select+1);
1190     return 0;
1191     case 0x41: // Ctrl+a ... home
1192     PostMessage(dlg, EM_SETSEL, 0, 0);
1193     return 0;
1194     case 0x45: // Ctrl+e ... end
1195     max = GetWindowTextLength(dlg) ;
1196     PostMessage(dlg, EM_SETSEL, max, max);
1197     return 0;
1198    
1199     case 0x44: // Ctrl+d
1200     case 0x4b: // Ctrl+k
1201     case 0x55: // Ctrl+u
1202     SendMessage(dlg, EM_GETSEL, 0, (LPARAM)&select);
1203     max = GetWindowTextLength(dlg);
1204     max++; // '\0'
1205     orgstr = str = malloc(max);
1206     if (str != NULL) {
1207     len = GetWindowText(dlg, str, max);
1208     if (select >= 0 && select < len) {
1209     if (wParam == 0x44) { // �J�[�\���z����������������������
1210     memmove(&str[select], &str[select + 1], len - select - 1);
1211     str[len - 1] = '\0';
1212    
1213     } else if (wParam == 0x4b) { // �J�[�\�������s��������������
1214     str[select] = '\0';
1215    
1216     }
1217     }
1218    
1219     if (wParam == 0x55) { // �J�[�\����������������������
1220     if (select >= len) {
1221     str[0] = '\0';
1222     } else {
1223     str = &str[select];
1224     }
1225     select = 0;
1226     }
1227    
1228     SetWindowText(dlg, str);
1229     SendMessage(dlg, EM_SETSEL, select, select);
1230     free(orgstr);
1231     return 0;
1232     }
1233     break;
1234     }
1235     }
1236     break;
1237    
1238     // �����L�[��������������������������������������������
1239     case WM_CHAR:
1240     switch (wParam) {
1241     case 0x01:
1242     case 0x02:
1243     case 0x04:
1244     case 0x05:
1245     case 0x06:
1246     case 0x0b:
1247     case 0x0e:
1248     case 0x10:
1249     case 0x15:
1250     return 0;
1251     }
1252     }
1253    
1254     return CallWindowProc(OrigHostnameEditProc, dlg, msg, wParam, lParam);
1255     }
1256    
1257     static BOOL CALLBACK TTXHostDlg(HWND dlg, UINT msg, WPARAM wParam,
1258     LPARAM lParam)
1259     {
1260     static char *ssh_version[] = {"SSH1", "SSH2", NULL};
1261     PGetHNRec GetHNRec;
1262     char EntName[128];
1263     char TempHost[HostNameMaxLength + 1];
1264     WORD i, j, w;
1265     WORD ComPortTable[MAXCOMPORT];
1266     static char *ComPortDesc[MAXCOMPORT];
1267     int comports;
1268     BOOL Ok;
1269     char uimsg[MAX_UIMSG];
1270     static HWND hwndHostname = NULL; // HOSTNAME dropdown
1271     static HWND hwndHostnameEdit = NULL; // Edit control on HOSTNAME dropdown
1272    
1273     switch (msg) {
1274     case WM_INITDIALOG:
1275     GetHNRec = (PGetHNRec) lParam;
1276     SetWindowLong(dlg, DWL_USER, lParam);
1277    
1278     GetWindowText(dlg, uimsg, sizeof(uimsg));
1279     UTIL_get_lang_msg("DLG_HOST_TITLE", pvar, uimsg);
1280     SetWindowText(dlg, pvar->ts->UIMsg);
1281     GetDlgItemText(dlg, IDC_HOSTNAMELABEL, uimsg, sizeof(uimsg));
1282     UTIL_get_lang_msg("DLG_HOST_TCPIPHOST", pvar, uimsg);
1283     SetDlgItemText(dlg, IDC_HOSTNAMELABEL, pvar->ts->UIMsg);
1284     GetDlgItemText(dlg, IDC_HISTORY, uimsg, sizeof(uimsg));
1285     UTIL_get_lang_msg("DLG_HOST_TCPIPHISTORY", pvar, uimsg);
1286     SetDlgItemText(dlg, IDC_HISTORY, pvar->ts->UIMsg);
1287     GetDlgItemText(dlg, IDC_SERVICELABEL, uimsg, sizeof(uimsg));
1288     UTIL_get_lang_msg("DLG_HOST_TCPIPSERVICE", pvar, uimsg);
1289     SetDlgItemText(dlg, IDC_SERVICELABEL, pvar->ts->UIMsg);
1290     GetDlgItemText(dlg, IDC_HOSTOTHER, uimsg, sizeof(uimsg));
1291     UTIL_get_lang_msg("DLG_HOST_TCPIPOTHER", pvar, uimsg);
1292     SetDlgItemText(dlg, IDC_HOSTOTHER, pvar->ts->UIMsg);
1293     GetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, uimsg, sizeof(uimsg));
1294     UTIL_get_lang_msg("DLG_HOST_TCPIPPORT", pvar, uimsg);
1295     SetDlgItemText(dlg, IDC_HOSTTCPPORTLABEL, pvar->ts->UIMsg);
1296     GetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, uimsg, sizeof(uimsg));
1297     UTIL_get_lang_msg("DLG_HOST_TCPIPSSHVERSION", pvar, uimsg);
1298     SetDlgItemText(dlg, IDC_SSH_VERSION_LABEL, pvar->ts->UIMsg);
1299     GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, uimsg, sizeof(uimsg));
1300     UTIL_get_lang_msg("DLG_HOST_TCPIPPROTOCOL", pvar, uimsg);
1301     SetDlgItemText(dlg, IDC_HOSTTCPPROTOCOLLABEL, pvar->ts->UIMsg);
1302     GetDlgItemText(dlg, IDC_HOSTSERIAL, uimsg, sizeof(uimsg));
1303     UTIL_get_lang_msg("DLG_HOST_SERIAL", pvar, uimsg);
1304     SetDlgItemText(dlg, IDC_HOSTSERIAL, pvar->ts->UIMsg);
1305     GetDlgItemText(dlg, IDC_HOSTCOMLABEL, uimsg, sizeof(uimsg));
1306     UTIL_get_lang_msg("DLG_HOST_SERIALPORT", pvar, uimsg);
1307     SetDlgItemText(dlg, IDC_HOSTCOMLABEL, pvar->ts->UIMsg);
1308     GetDlgItemText(dlg, IDC_HOSTHELP, uimsg, sizeof(uimsg));
1309     UTIL_get_lang_msg("DLG_HOST_HELP", pvar, uimsg);
1310     SetDlgItemText(dlg, IDC_HOSTHELP, pvar->ts->UIMsg);
1311     GetDlgItemText(dlg, IDOK, uimsg, sizeof(uimsg));
1312     UTIL_get_lang_msg("BTN_OK", pvar, uimsg);
1313     SetDlgItemText(dlg, IDOK, pvar->ts->UIMsg);
1314     GetDlgItemText(dlg, IDCANCEL, uimsg, sizeof(uimsg));
1315     UTIL_get_lang_msg("BTN_CANCEL", pvar, uimsg);
1316     SetDlgItemText(dlg, IDCANCEL, pvar->ts->UIMsg);
1317    
1318     // �z�X�g�q�X�g�����`�F�b�N�{�b�N�X������ (2005.10.21 yutaka)
1319     if (pvar->ts->HistoryList > 0) {
1320     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_CHECKED, 0);
1321     } else {
1322     SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_SETCHECK, BST_UNCHECKED, 0);
1323     }
1324    
1325 yutakapon 4860 // �t�@�C�����������O�t���p�C�v�������ATCP/IP�����������B
1326     if (GetHNRec->PortType == IdFile ||
1327     GetHNRec->PortType == IdNamedPipe
1328     )
1329 maya 3227 GetHNRec->PortType = IdTCPIP;
1330    
1331     strncpy_s(EntName, sizeof(EntName), "Host", _TRUNCATE);
1332    
1333     i = 1;
1334     do {
1335     _snprintf_s(&EntName[4], sizeof(EntName)-4, _TRUNCATE, "%d", i);
1336     GetPrivateProfileString("Hosts", EntName, "",
1337     TempHost, sizeof(TempHost),
1338     GetHNRec->SetupFN);
1339     if (strlen(TempHost) > 0)
1340     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_ADDSTRING,
1341     0, (LPARAM) TempHost);
1342     i++;
1343 maya 4963 } while (i <= MAXHOSTLIST);
1344 maya 3227
1345     SendDlgItemMessage(dlg, IDC_HOSTNAME, EM_LIMITTEXT,
1346     HostNameMaxLength - 1, 0);
1347    
1348     SendDlgItemMessage(dlg, IDC_HOSTNAME, CB_SETCURSEL, 0, 0);
1349    
1350     // C-n/C-p ���������T�u�N���X�� (2007.9.4 maya)
1351     hwndHostname = GetDlgItem(dlg, IDC_HOSTNAME);
1352     hwndHostnameEdit = GetWindow(hwndHostname, GW_CHILD);
1353     OrigHostnameEditProc = (WNDPROC)GetWindowLong(hwndHostnameEdit, GWL_WNDPROC);
1354     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)HostnameEditProc);
1355    
1356     CheckRadioButton(dlg, IDC_HOSTTELNET, IDC_HOSTOTHER,
1357     pvar->settings.Enabled ? IDC_HOSTSSH : GetHNRec->
1358     Telnet ? IDC_HOSTTELNET : IDC_HOSTOTHER);
1359     SendDlgItemMessage(dlg, IDC_HOSTTCPPORT, EM_LIMITTEXT, 5, 0);
1360     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TCPPort, FALSE);
1361     for (i = 0; ProtocolFamilyList[i]; ++i) {
1362     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_ADDSTRING,
1363     0, (LPARAM) ProtocolFamilyList[i]);
1364     }
1365     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, EM_LIMITTEXT,
1366     ProtocolFamilyMaxLength - 1, 0);
1367     SendDlgItemMessage(dlg, IDC_HOSTTCPPROTOCOL, CB_SETCURSEL, 0, 0);
1368    
1369     /////// SSH version
1370     for (i = 0; ssh_version[i]; ++i) {
1371     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_ADDSTRING,
1372     0, (LPARAM) ssh_version[i]);
1373     }
1374     SendDlgItemMessage(dlg, IDC_SSH_VERSION, EM_LIMITTEXT,
1375     NUM_ELEM(ssh_version) - 1, 0);
1376    
1377     if (pvar->settings.ssh_protocol_version == 1) {
1378     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 0, 0); // SSH1
1379     } else {
1380     SendDlgItemMessage(dlg, IDC_SSH_VERSION, CB_SETCURSEL, 1, 0); // SSH2
1381     }
1382    
1383     if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1384     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE); // enabled
1385     } else {
1386     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1387     }
1388     /////// SSH version
1389    
1390    
1391     j = 0;
1392     w = 1;
1393     if ((comports=DetectComPorts(ComPortTable, GetHNRec->MaxComPort, ComPortDesc)) >= 0) {
1394     for (i=0; i<comports; i++) {
1395     // MaxComPort ���z�����|�[�g���\��������
1396     if (ComPortTable[i] > GetHNRec->MaxComPort) {
1397     continue;
1398     }
1399    
1400     // �g�p�����|�[�g���\��������
1401     if (CheckCOMFlag(ComPortTable[i]) == 1) {
1402     continue;
1403     }
1404    
1405     _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", ComPortTable[i]);
1406     if (ComPortDesc[i] != NULL) {
1407     strncat_s(EntName, sizeof(EntName), ": ", _TRUNCATE);
1408     strncat_s(EntName, sizeof(EntName), ComPortDesc[i], _TRUNCATE);
1409     }
1410     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1411     0, (LPARAM)EntName);
1412     j++;
1413     if (GetHNRec->ComPort == ComPortTable[i])
1414     w = j;
1415     }
1416    
1417     } else {
1418     for (i = 1; i <= GetHNRec->MaxComPort; i++) {
1419     // �g�p�����|�[�g���\��������
1420     if (CheckCOMFlag(i) == 1) {
1421     continue;
1422     }
1423    
1424     _snprintf_s(EntName, sizeof(EntName), _TRUNCATE, "COM%d", i);
1425     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_ADDSTRING,
1426     0, (LPARAM) EntName);
1427     j++;
1428     if (GetHNRec->ComPort == i)
1429     w = j;
1430     }
1431     }
1432    
1433     if (j > 0)
1434     SendDlgItemMessage(dlg, IDC_HOSTCOM, CB_SETCURSEL, w - 1, 0);
1435     else { /* All com ports are already used */
1436     GetHNRec->PortType = IdTCPIP;
1437     enable_dlg_items(dlg, IDC_HOSTSERIAL, IDC_HOSTSERIAL, FALSE);
1438     }
1439    
1440     CheckRadioButton(dlg, IDC_HOSTTCPIP, IDC_HOSTSERIAL,
1441     IDC_HOSTTCPIP + GetHNRec->PortType - 1);
1442    
1443     if (GetHNRec->PortType == IdTCPIP) {
1444     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1445    
1446     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1447     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE);
1448    
1449     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // enabled
1450     }
1451     else {
1452     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1453     FALSE);
1454     enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1455     IDC_HOSTTCPPROTOCOL, FALSE);
1456    
1457     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1458     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1459    
1460     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1461     }
1462    
1463     // Host dialog���t�H�[�J�X�������� (2004.10.2 yutaka)
1464     if (GetHNRec->PortType == IdTCPIP) {
1465     HWND hwnd = GetDlgItem(dlg, IDC_HOSTNAME);
1466     SetFocus(hwnd);
1467     } else {
1468     HWND hwnd = GetDlgItem(dlg, IDC_HOSTCOM);
1469     SetFocus(hwnd);
1470     }
1471    
1472 zmatsuo 7592 CenterWindow(dlg, GetParent(dlg));
1473    
1474 maya 3227 // SetFocus()���t�H�[�J�X���������������AFALSE�������K�v�������B
1475     // TRUE���������ATABSTOP�������������������R���g���[�����I�������B
1476     // (2004.11.23 yutaka)
1477     return FALSE;
1478     //return TRUE;
1479    
1480     case WM_COMMAND:
1481     switch (LOWORD(wParam)) {
1482     case IDOK:
1483     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1484     if (GetHNRec != NULL) {
1485     if (IsDlgButtonChecked(dlg, IDC_HOSTTCPIP)) {
1486     char afstr[BUFSIZ];
1487     i = GetDlgItemInt(dlg, IDC_HOSTTCPPORT, &Ok, FALSE);
1488     if (Ok) {
1489     GetHNRec->TCPPort = i;
1490     } else {
1491     UTIL_get_lang_msg("MSG_TCPPORT_NAN_ERROR", pvar,
1492     "The TCP port must be a number.");
1493     MessageBox(dlg, pvar->ts->UIMsg,
1494     "Tera Term", MB_OK | MB_ICONEXCLAMATION);
1495     return TRUE;
1496     }
1497     #define getaf(str) \
1498     ((strcmp((str), "IPv6") == 0) ? AF_INET6 : \
1499     ((strcmp((str), "IPv4") == 0) ? AF_INET : AF_UNSPEC))
1500     memset(afstr, 0, sizeof(afstr));
1501     GetDlgItemText(dlg, IDC_HOSTTCPPROTOCOL, afstr,
1502     sizeof(afstr));
1503     GetHNRec->ProtocolFamily = getaf(afstr);
1504     GetHNRec->PortType = IdTCPIP;
1505     GetDlgItemText(dlg, IDC_HOSTNAME, GetHNRec->HostName,
1506     HostNameMaxLength);
1507     pvar->hostdlg_activated = TRUE;
1508     pvar->hostdlg_Enabled = FALSE;
1509     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1510     GetHNRec->Telnet = TRUE;
1511     } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1512     pvar->hostdlg_Enabled = TRUE;
1513    
1514     // check SSH protocol version
1515     memset(afstr, 0, sizeof(afstr));
1516     GetDlgItemText(dlg, IDC_SSH_VERSION, afstr, sizeof(afstr));
1517     if (_stricmp(afstr, "SSH1") == 0) {
1518     pvar->settings.ssh_protocol_version = 1;
1519     } else {
1520     pvar->settings.ssh_protocol_version = 2;
1521     }
1522     }
1523 doda 3541 else { // IDC_HOSTOTHER
1524     GetHNRec->Telnet = FALSE;
1525     }
1526 maya 3227
1527     // host history check button
1528     if (SendMessage(GetDlgItem(dlg, IDC_HISTORY), BM_GETCHECK, 0, 0) == BST_CHECKED) {
1529     pvar->ts->HistoryList = 1;
1530     } else {
1531     pvar->ts->HistoryList = 0;
1532     }
1533    
1534     } else {
1535     GetHNRec->PortType = IdSerial;
1536     GetHNRec->HostName[0] = 0;
1537     memset(EntName, 0, sizeof(EntName));
1538     GetDlgItemText(dlg, IDC_HOSTCOM, EntName,
1539     sizeof(EntName) - 1);
1540     if (strncmp(EntName, "COM", 3) == 0 && EntName[3] != '\0') {
1541     GetHNRec->ComPort = atoi(&EntName[3]);
1542     if (GetHNRec->ComPort > GetHNRec->MaxComPort)
1543     GetHNRec->ComPort = 1;
1544     } else {
1545     GetHNRec->ComPort = 1;
1546     }
1547     }
1548     }
1549     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1550     EndDialog(dlg, 1);
1551     return TRUE;
1552    
1553     case IDCANCEL:
1554     SetWindowLong(hwndHostnameEdit, GWL_WNDPROC, (LONG)OrigHostnameEditProc);
1555     EndDialog(dlg, 0);
1556     return TRUE;
1557    
1558     case IDC_HOSTTCPIP:
1559     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1560     TRUE);
1561     enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1562     IDC_HOSTTCPPROTOCOL, TRUE);
1563     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, FALSE);
1564    
1565     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, TRUE); // disabled (2004.11.23 yutaka)
1566     if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1567     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, TRUE);
1568     } else {
1569     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1570     }
1571    
1572     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, TRUE); // disabled
1573    
1574     return TRUE;
1575    
1576     case IDC_HOSTSERIAL:
1577     enable_dlg_items(dlg, IDC_HOSTCOMLABEL, IDC_HOSTCOM, TRUE);
1578     enable_dlg_items(dlg, IDC_HOSTNAMELABEL, IDC_HOSTTCPPORT,
1579     FALSE);
1580     enable_dlg_items(dlg, IDC_HOSTTCPPROTOCOLLABEL,
1581     IDC_HOSTTCPPROTOCOL, FALSE);
1582     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1583     enable_dlg_items(dlg, IDC_SSH_VERSION_LABEL, IDC_SSH_VERSION_LABEL, FALSE); // disabled (2004.11.23 yutaka)
1584    
1585     enable_dlg_items(dlg, IDC_HISTORY, IDC_HISTORY, FALSE); // disabled
1586    
1587     return TRUE;
1588    
1589     case IDC_HOSTSSH:
1590     enable_dlg_items(dlg, IDC_SSH_VERSION,
1591     IDC_SSH_VERSION, TRUE);
1592     goto hostssh_enabled;
1593    
1594     case IDC_HOSTTELNET:
1595     case IDC_HOSTOTHER:
1596     enable_dlg_items(dlg, IDC_SSH_VERSION, IDC_SSH_VERSION, FALSE); // disabled
1597     hostssh_enabled:
1598    
1599     GetHNRec = (PGetHNRec) GetWindowLong(dlg, DWL_USER);
1600    
1601     if (IsDlgButtonChecked(dlg, IDC_HOSTTELNET)) {
1602     if (GetHNRec != NULL)
1603     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, GetHNRec->TelPort,
1604     FALSE);
1605     } else if (IsDlgButtonChecked(dlg, IDC_HOSTSSH)) {
1606     SetDlgItemInt(dlg, IDC_HOSTTCPPORT, 22, FALSE);
1607     }
1608     return TRUE;
1609    
1610     case IDC_HOSTCOM:
1611     if(HIWORD(wParam) == CBN_DROPDOWN) {
1612     HWND hostcom = GetDlgItem(dlg, IDC_HOSTCOM);
1613     int count = SendMessage(hostcom, CB_GETCOUNT, 0, 0);
1614     int i, len, max_len = 0;
1615     char *lbl;
1616     HDC TmpDC = GetDC(hostcom);
1617     SIZE s;
1618     for (i=0; i<count; i++) {
1619     len = SendMessage(hostcom, CB_GETLBTEXTLEN, i, 0);
1620     lbl = (char *)calloc(len+1, sizeof(char));
1621     SendMessage(hostcom, CB_GETLBTEXT, i, (LPARAM)lbl);
1622     GetTextExtentPoint32(TmpDC, lbl, len, &s);
1623     if (s.cx > max_len)
1624     max_len = s.cx;
1625     free(lbl);
1626     }
1627     SendMessage(hostcom, CB_SETDROPPEDWIDTH,
1628     max_len + GetSystemMetrics(SM_CXVSCROLL), 0);
1629     }
1630     break;
1631    
1632     case IDC_HOSTHELP:
1633     PostMessage(GetParent(dlg), WM_USER_DLGHELP2, 0, 0);
1634     }
1635     }
1636     return FALSE;
1637     }
1638    
1639 zmatsuo 7560 static void UTIL_SetDialogFont()
1640     {
1641 zmatsuo 7706 SetDialogFont(pvar->ts->DialogFontName, pvar->ts->DialogFontPoint, pvar->ts->DialogFontCharSet,
1642     pvar->ts->UILanguageFile, "TTSSH", "DLG_TAHOMA_FONT");
1643 zmatsuo 7560 }
1644    
1645 doda 6801 static BOOL PASCAL TTXGetHostName(HWND parent, PGetHNRec rec)
1646 maya 3227 {
1647 zmatsuo 7706 SetDialogFont(pvar->ts->DialogFontName, pvar->ts->DialogFontPoint, pvar->ts->DialogFontCharSet,
1648 zmatsuo 7589 pvar->ts->UILanguageFile, "TTSSH", "DLG_SYSTEM_FONT");
1649 maya 3227 return (BOOL) DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_HOSTDLG),
1650 zmatsuo 7560 parent, TTXHostDlg, (LPARAM)rec);
1651 maya 3227 }
1652    
1653 doda 6801 static void PASCAL TTXGetUIHooks(TTXUIHooks *hooks)
1654 maya 3227 {
1655     *hooks->GetHostName = TTXGetHostName;
1656     }
1657    
1658 doda 6801 static void PASCAL TTXReadINIFile(PCHAR fileName, PTTSet ts)
1659 maya 3227 {
1660     (pvar->ReadIniFile) (fileName, ts);
1661     read_ssh_options(pvar, fileName);
1662     pvar->settings = *pvar->ts_SSH;
1663 doda 6809 logputs(LOG_LEVEL_VERBOSE, "Reading INI file");
1664 maya 3227 FWDUI_load_settings(pvar);
1665     }
1666    
1667 doda 6801 static void PASCAL TTXWriteINIFile(PCHAR fileName, PTTSet ts)
1668 maya 3227 {
1669     (pvar->WriteIniFile) (fileName, ts);
1670     *pvar->ts_SSH = pvar->settings;
1671     clear_local_settings(pvar);
1672 doda 6809 logputs(LOG_LEVEL_VERBOSE, "Writing INI file");
1673 maya 3227 write_ssh_options(pvar, fileName, pvar->ts_SSH, TRUE);
1674     }
1675    
1676     static void read_ssh_options_from_user_file(PTInstVar pvar,
1677 doda 6801 char *user_file_name)
1678 maya 3227 {
1679     if (user_file_name[0] == '.') {
1680     read_ssh_options(pvar, user_file_name);
1681     } else {
1682     char buf[1024];
1683    
1684     get_teraterm_dir_relative_name(buf, sizeof(buf), user_file_name);
1685     read_ssh_options(pvar, buf);
1686     }
1687    
1688     pvar->settings = *pvar->ts_SSH;
1689     FWDUI_load_settings(pvar);
1690     }
1691    
1692     // Percent-encode������������src���f�R�[�h����dst���R�s�[�����B
1693     // dstlen��dst���T�C�Y�B�����������������������A�����������������������B
1694     static void percent_decode(char *dst, int dstlen, char *src) {
1695     if (src == NULL || dst == NULL || dstlen < 1) {
1696     return;
1697     }
1698    
1699     while (*src != 0 && dstlen > 1) {
1700     if (*src == '%' && isxdigit(*(src+1)) && isxdigit(*(src+2))) {
1701     src++; *dst = (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0') << 4;
1702     src++; *dst |= (isalpha(*src) ? (*src|0x20) - 'a' + 10 : *src - '0');
1703     src++; dst++;
1704     }
1705     else {
1706     *dst++ = *src++;
1707     }
1708     dstlen--;
1709     }
1710     *dst = 0;
1711     return;
1712     }
1713    
1714 doda 5799 void add_forward_param(PTInstVar pvar, char *param)
1715     {
1716     if (pvar->settings.DefaultForwarding[0] == 0) {
1717     strncpy_s(pvar->settings.DefaultForwarding,
1718     sizeof(pvar->settings.DefaultForwarding),
1719     param, _TRUNCATE);
1720     } else {
1721     strncat_s(pvar->settings.DefaultForwarding,
1722     sizeof(pvar->settings.DefaultForwarding),
1723     ";", _TRUNCATE);
1724     strncat_s(pvar->settings.DefaultForwarding,
1725     sizeof(pvar->settings.DefaultForwarding),
1726     param, _TRUNCATE);
1727     }
1728     }
1729    
1730 doda 6801 static void PASCAL TTXParseParam(PCHAR param, PTTSet ts, PCHAR DDETopic) {
1731 maya 5869 int param_len=strlen(param);
1732     int opt_len = param_len+1;
1733     char *option = (char *)calloc(opt_len, sizeof(char));
1734 maya 5882 char *option2 = (char *)calloc(opt_len, sizeof(char));
1735 maya 5869 int action;
1736 maya 5874 PCHAR start, cur, next;
1737 maya 5908 size_t i;
1738 maya 5869
1739     if (pvar->hostdlg_activated) {
1740     pvar->settings.Enabled = pvar->hostdlg_Enabled;
1741     }
1742    
1743 maya 5874 /* the first term shuld be executable filename of Tera Term */
1744     start = GetParam(option, opt_len, param);
1745    
1746     cur = start;
1747 maya 5869 while (next = GetParam(option, opt_len, cur)) {
1748 doda 6140 DequoteParam(option, opt_len, option);
1749 maya 5869 action = OPTION_NONE;
1750    
1751     if ((option[0] == '-' || option[0] == '/')) {
1752     if (MATCH_STR(option + 1, "ssh") == 0) {
1753     if (MATCH_STR(option + 4, "-f=") == 0) {
1754 doda 6140 strncpy_s(option2, opt_len, option + 7, _TRUNCATE);
1755 maya 5882 read_ssh_options_from_user_file(pvar, option2);
1756 maya 5869 action = OPTION_CLEAR;
1757     } else if (MATCH_STR(option + 4, "-consume=") == 0) {
1758 doda 6140 strncpy_s(option2, opt_len, option + 13, _TRUNCATE);
1759 maya 5882 read_ssh_options_from_user_file(pvar, option2);
1760     DeleteFile(option2);
1761 maya 5869 action = OPTION_CLEAR;
1762     }
1763    
1764     // ttermpro.exe �� /F= �w������ TTSSH ������������ (2006.10.11 maya)
1765     } else if (MATCH_STR_I(option + 1, "f=") == 0) {
1766 doda 6140 strncpy_s(option2, opt_len, option + 3, _TRUNCATE);
1767 maya 5882 read_ssh_options_from_user_file(pvar, option2);
1768 maya 5869 // Tera Term���������������K�v������������������
1769     }
1770     }
1771    
1772     switch (action) {
1773     case OPTION_CLEAR:
1774     memset(cur, ' ', next-cur);
1775     break;
1776     case OPTION_REPLACE:
1777     memset(cur, ' ', next-cur);
1778     memcpy(cur+1, option, strlen(option));
1779     break;
1780     }
1781    
1782     cur = next;
1783     }
1784    
1785 maya 5874 cur = start;
1786 maya 5869 while (next = GetParam(option, opt_len, cur)) {
1787 doda 6140 DequoteParam(option, opt_len, option);
1788 maya 5869 action = OPTION_NONE;
1789    
1790     if ((option[0] == '-' || option[0] == '/')) {
1791     action = OPTION_CLEAR;
1792     if (MATCH_STR(option + 1, "ssh") == 0) {
1793     if (option[4] == 0) {
1794     pvar->settings.Enabled = 1;
1795     } else if (MATCH_STR(option + 4, "-L") == 0 ||
1796 doda 6846 MATCH_STR(option + 4, "-R") == 0 ||
1797     MATCH_STR(option + 4, "-D") == 0) {
1798 doda 5959 char *p = option + 5;
1799     option2[0] = *p;
1800     i = 1;
1801     while (*++p) {
1802     if (*p == ';' || *p == ',') {
1803     option2[i] = 0;
1804     add_forward_param(pvar, option2);
1805     i = 1;
1806 maya 5908 }
1807 doda 5959 else {
1808     option2[i++] = *p;
1809     }
1810 maya 5908 }
1811 doda 5959 if (i > 1) {
1812     option2[i] = 0;
1813     add_forward_param(pvar, option2);
1814     }
1815 maya 5869 } else if (MATCH_STR(option + 4, "-X") == 0) {
1816     add_forward_param(pvar, "X");
1817 doda 5959 if (option+6 != 0) {
1818     strncpy_s(pvar->settings.X11Display,
1819     sizeof(pvar->settings.X11Display),
1820     option + 6, _TRUNCATE);
1821     }
1822 doda 6473 } else if (strcmp(option + 4, "-v") == 0) {
1823 maya 5869 pvar->settings.LogLevel = LOG_LEVEL_VERBOSE;
1824     } else if (_stricmp(option + 4, "-autologin") == 0 ||
1825     _stricmp(option + 4, "-autologon") == 0) {
1826     pvar->settings.TryDefaultAuth = TRUE;
1827     } else if (MATCH_STR_I(option + 4, "-agentconfirm=") == 0) {
1828     if ((_stricmp(option+18, "off") == 0) ||
1829     (_stricmp(option+18, "no") == 0) ||
1830     (_stricmp(option+18, "false") == 0) ||
1831     (_stricmp(option+18, "0") == 0) ||
1832     (_stricmp(option+18, "n") == 0)) {
1833     pvar->settings.ForwardAgentConfirm = 0;
1834     }
1835     else {
1836     pvar->settings.ForwardAgentConfirm = 1;
1837     }
1838 doda 6473 } else if (strcmp(option + 4, "-a") == 0) {
1839 maya 5869 pvar->settings.ForwardAgent = FALSE;
1840 doda 6473 } else if (strcmp(option + 4, "-A") == 0) {
1841 maya 5869 pvar->settings.ForwardAgent = TRUE;
1842    
1843     } else if (MATCH_STR(option + 4, "-C=") == 0) {
1844     pvar->settings.CompressionLevel = atoi(option+7);
1845     if (pvar->settings.CompressionLevel < 0) {
1846     pvar->settings.CompressionLevel = 0;
1847     }
1848     else if (pvar->settings.CompressionLevel > 9) {
1849     pvar->settings.CompressionLevel = 9;
1850     }
1851 doda 6473 } else if (strcmp(option + 4, "-C") == 0) {
1852 maya 5869 pvar->settings.CompressionLevel = 6;
1853 doda 6473 } else if (strcmp(option + 4, "-c") == 0) {
1854 maya 5869 pvar->settings.CompressionLevel = 0;
1855     } else if (MATCH_STR_I(option + 4, "-icon=") == 0) {
1856     if ((_stricmp(option+10, "old") == 0) ||
1857     (_stricmp(option+10, "yellow") == 0) ||
1858     (_stricmp(option+10, "securett_yellow") == 0)) {
1859     pvar->settings.IconID = IDI_SECURETT_YELLOW;
1860     }
1861 maya 6386 else if ((_stricmp(option+10, "green") == 0) ||
1862     (_stricmp(option+10, "securett_green") == 0)) {
1863     pvar->settings.IconID = IDI_SECURETT_GREEN;
1864     }
1865 maya 5869 else {
1866     pvar->settings.IconID = IDI_SECURETT;
1867     }
1868 doda 6717 } else if (MATCH_STR(option + 4, "-subsystem=") == 0) {
1869     pvar->use_subsystem = TRUE;
1870     strncpy_s(pvar->subsystem_name,
1871     sizeof(pvar->subsystem_name),
1872     option + 15, _TRUNCATE);
1873 doda 7364 } else if (strcmp(option + 4, "-N") == 0) {
1874 doda 7363 pvar->nosession = TRUE;
1875 maya 5869
1876     // /ssh1 �� /ssh2 �I�v�V�������V�K���� (2006.9.16 maya)
1877 doda 6473 } else if (strcmp(option + 4, "1") == 0) {
1878 maya 5869 pvar->settings.Enabled = 1;
1879     pvar->settings.ssh_protocol_version = 1;
1880 doda 6473 } else if (strcmp(option + 4, "2") == 0) {
1881 maya 5869 pvar->settings.Enabled = 1;
1882     pvar->settings.ssh_protocol_version = 2;
1883    
1884     } else {
1885     char buf[1024];
1886    
1887     UTIL_get_lang_msg("MSG_UNKNOWN_OPTION_ERROR", pvar,
1888     "Unrecognized command-line option: %s");
1889     _snprintf_s(buf, sizeof(buf), _TRUNCATE, pvar->ts->UIMsg, option);
1890    
1891     MessageBox(NULL, buf, "TTSSH", MB_OK | MB_ICONEXCLAMATION);
1892     }
1893    
1894     // ttermpro.exe �� /T= �w�������p�������A������������ (2006.10.19 maya)
1895     } else if (MATCH_STR_I(option + 1, "t=") == 0) {
1896     if (strcmp(option + 3, "2") == 0) {
1897     pvar->settings.Enabled = 1;
1898     // /t=2��ttssh�������g������������
1899     } else {
1900     pvar->settings.Enabled = 0;
1901     action = OPTION_NONE; // Tera Term������������������������
1902     }
1903    
1904     // /1 ������ /2 �I�v�V�������V�K���� (2004.10.3 yutaka)
1905 doda 6473 } else if (strcmp(option + 1, "1") == 0) {
1906 maya 5869 // command line: /ssh /1 is SSH1 only
1907     pvar->settings.ssh_protocol_version = 1;
1908    
1909 doda 6473 } else if (strcmp(option + 1, "2") == 0) {
1910 maya 5869 // command line: /ssh /2 is SSH2 & SSH1
1911     pvar->settings.ssh_protocol_version = 2;
1912    
1913 doda 6473 } else if (strcmp(option + 1, "nossh") == 0) {
1914 maya 5869 // '/nossh' �I�v�V�����������B
1915     // TERATERM.INI ��SSH���L�������������������A������Cygterm���N��������������
1916     // �����������������B(2004.10.11 yutaka)
1917     pvar->settings.Enabled = 0;
1918    
1919 doda 6473 } else if (strcmp(option + 1, "telnet") == 0) {
1920 maya 5869 // '/telnet' ���w�������������������� '/nossh' ��������
1921     // SSH������������ (2006.9.16 maya)
1922     pvar->settings.Enabled = 0;
1923     // Tera Term �� Telnet �t���O���t����
1924     pvar->ts->Telnet = 1;
1925    
1926 doda 6473 } else if (MATCH_STR(option + 1, "auth=") == 0) {
1927 maya 5869 // SSH2�������O�C���I�v�V����������
1928     //
1929     // SYNOPSIS: /ssh /auth=passowrd /user=���[�U�� /passwd=�p�X���[�h
1930     // /ssh /auth=publickey /user=���[�U�� /passwd=�p�X���[�h /keyfile=�p�X
1931 doda 6472 // EXAMPLE: /ssh /auth=password /user=nike /passwd="a b""c" ; �p�X���[�h: �ua b"c�v
1932 maya 5869 // /ssh /auth=publickey /user=foo /passwd=bar /keyfile=d:\tmp\id_rsa
1933 doda 6472 // NOTICE: �p�X���[�h���p�X���������Z�~�R���������������������_�u���N�H�[�g " ������
1934     // �p�X���[�h���_�u���N�H�[�g�����������������A�������_�u���N�H�[�g "" ���u��������
1935 maya 5869 //
1936     pvar->ssh2_autologin = 1; // for SSH2 (2004.11.30 yutaka)
1937    
1938 doda 6473 if (_stricmp(option + 6, "password") == 0) { // �p�X���[�h
1939 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_PASSWORD;
1940     pvar->ssh2_authmethod = SSH_AUTH_PASSWORD;
1941    
1942 doda 7101 } else if (_stricmp(option + 6, "keyboard-interactive") == 0) { // keyboard-interactive�F��
1943     //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1944     pvar->ssh2_authmethod = SSH_AUTH_TIS;
1945    
1946 doda 6473 } else if (_stricmp(option + 6, "challenge") == 0) { // keyboard-interactive�F��
1947 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_TIS;
1948     pvar->ssh2_authmethod = SSH_AUTH_TIS;
1949    
1950 doda 6473 } else if (_stricmp(option + 6, "publickey") == 0) { // ���J���F��
1951 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1952     pvar->ssh2_authmethod = SSH_AUTH_RSA;
1953    
1954 doda 6473 } else if (_stricmp(option + 6, "pageant") == 0) { // ���J���F�� by Pageant
1955 maya 5869 //pvar->auth_state.cur_cred.method = SSH_AUTH_RSA;
1956     pvar->ssh2_authmethod = SSH_AUTH_PAGEANT;
1957    
1958     } else {
1959     // TODO:
1960     }
1961    
1962     } else if (MATCH_STR(option + 1, "user=") == 0) {
1963 doda 6140 _snprintf_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), _TRUNCATE, "%s", option+6);
1964 maya 5869
1965     } else if (MATCH_STR(option + 1, "passwd=") == 0) {
1966 doda 6140 _snprintf_s(pvar->ssh2_password, sizeof(pvar->ssh2_password), _TRUNCATE, "%s", option+8);
1967 maya 5869
1968     } else if (MATCH_STR(option + 1, "keyfile=") == 0) {
1969 doda 6140 _snprintf_s(pvar->ssh2_keyfile, sizeof(pvar->ssh2_keyfile), _TRUNCATE, "%s", option+9);
1970 maya 5869
1971 doda 6473 } else if (strcmp(option + 1, "ask4passwd") == 0) {
1972 maya 5869 // �p�X���[�h������ (2006.9.18 maya)
1973     pvar->ask4passwd = 1;
1974    
1975 doda 6473 } else if (strcmp(option + 1, "nosecuritywarning") == 0) {
1976 maya 5869 // known_hosts�`�F�b�N���������B���Y�I�v�V�������g�����A�Z�L�����e�B������������
1977     // �����A�B���I�v�V���������������B
1978     // (2009.10.4 yutaka)
1979     pvar->nocheck_known_hosts = TRUE;
1980    
1981     }
1982     else { // Other (not ttssh) option
1983     action = OPTION_NONE; // ttssh���I�v�V������������������������
1984     }
1985    
1986     // �p�X���[�h�������������������O�C��������������
1987     // /auth ���F�����\�b�h���w�������������p������ (2006.9.18 maya)
1988     if (pvar->ask4passwd == 1) {
1989     pvar->ssh2_autologin = 0;
1990     }
1991    
1992     }
1993     else if ((MATCH_STR_I(option, "ssh://") == 0) ||
1994     (MATCH_STR_I(option, "ssh1://") == 0) ||
1995     (MATCH_STR_I(option, "ssh2://") == 0) ||
1996     (MATCH_STR_I(option, "slogin://") == 0) ||
1997     (MATCH_STR_I(option, "slogin1://") == 0) ||
1998     (MATCH_STR_I(option, "slogin2://") == 0)) {
1999     //
2000     // ssh://user@host/ ����URL�`�����T�|�[�g
2001     // ���{�I�������� telnet:// URL��������
2002     //
2003     // �Q�l:
2004     // RFC3986: Uniform Resource Identifier (URI): Generic Syntax
2005     // RFC4248: The telnet URI Scheme
2006     //
2007     char *p, *p2, *p3;
2008     int optlen, hostlen;
2009    
2010     optlen = strlen(option);
2011    
2012     // ������':'���O�����������������������A������ssh�v���g�R���o�[�W������������
2013     p = _mbschr(option, ':');
2014     switch (*(p-1)) {
2015     case '1':
2016     pvar->settings.ssh_protocol_version = 1;
2017     break;
2018     case '2':
2019     pvar->settings.ssh_protocol_version = 2;
2020     break;
2021     }
2022    
2023     // authority part �����|�C���^������
2024     p += 3;
2025    
2026     // path part ������������
2027     if ((p2 = _mbschr(p, '/')) != NULL) {
2028     *p2 = 0;
2029     }
2030    
2031     // '@'�������������A���������O�����[�U����
2032     if ((p2 = _mbschr(p, '@')) != NULL) {
2033     *p2 = 0;
2034     // ':'���~���p�X���[�h
2035     if ((p3 = _mbschr(p, ':')) != NULL) {
2036     *p3 = 0;
2037     percent_decode(pvar->ssh2_password, sizeof(pvar->ssh2_password), p3 + 1);
2038     }
2039     percent_decode(pvar->ssh2_username, sizeof(pvar->ssh2_username), p);
2040     // p �� host part ������('@'����������)����������������
2041     p = p2 + 1;
2042     }
2043    
2044     // host part �� option �����������������Ascheme part ������
2045     // port�w����������������port���������������������m��������������
2046     hostlen = strlen(p);
2047     memmove_s(option, optlen, p, hostlen);
2048     option[hostlen] = 0;
2049    
2050     // �|�[�g�w������������":22"������
2051     if (option[0] == '[' && option[hostlen-1] == ']' || // IPv6 raw address without port
2052     option[0] != '[' && _mbschr(option, ':') == NULL) { // hostname or IPv4 raw address without port
2053     memcpy_s(option+hostlen, optlen-hostlen, ":22", 3);
2054     hostlen += 3;
2055     }
2056    
2057     // �|�[�g�w�����������������X�y�[�X������
2058     memset(option+hostlen, ' ', optlen-hostlen);
2059    
2060     pvar->settings.Enabled = 1;
2061    
2062     action = OPTION_REPLACE;
2063     }
2064     else if (_mbschr(option, '@') != NULL) {
2065     //
2066     // user@host �`�����T�|�[�g
2067     // ����������ssh�������T�|�[�g�����A���[�U����ttssh���������B
2068     // (ssh�������O -- ttssh�������W������������)
2069     // �����I��telnet authentication option���T�|�[�g��������
2070     // Tera Term�{�����������������������\���B
2071     //
2072     char *p;
2073     p = _mbschr(option, '@');
2074     *p = 0;
2075    
2076     strncpy_s(pvar->ssh2_username, sizeof(pvar->ssh2_username), option, _TRUNCATE);
2077    
2078     // ���[�U���������X�y�[�X�������B
2079     // ������TTX��Tera Term�{�������������������X�y�[�X�����������������A
2080     // �z�X�g�����������l�����K�v�������B
2081     memset(option, ' ', p-option+1);
2082    
2083     action = OPTION_REPLACE;
2084     }
2085    
2086    
2087     switch (action) {
2088     case OPTION_CLEAR:
2089     memset(cur, ' ', next-cur);
2090     break;
2091     case OPTION_REPLACE:
2092     memset(cur, ' ', next-cur);
2093     memcpy(cur+1, option, strlen(option));
2094     break;
2095     }
2096    
2097     cur = next;
2098     }
2099    
2100     free(option);
2101    
2102     FWDUI_load_settings(pvar);
2103    
2104     (pvar->ParseParam) (param, ts, DDETopic);
2105     }
2106 maya 3227
2107 doda 6801 static void PASCAL TTXGetSetupHooks(TTXSetupHooks *hooks)
2108 maya 3227 {
2109     pvar->ReadIniFile = *hooks->ReadIniFile;
2110     pvar->WriteIniFile = *hooks->WriteIniFile;
2111     pvar->ParseParam = *hooks->ParseParam;
2112    
2113     *hooks->ReadIniFile = TTXReadINIFile;
2114     *hooks->WriteIniFile = TTXWriteINIFile;
2115     *hooks->ParseParam = TTXParseParam;
2116     }
2117    
2118 doda 6801 static void PASCAL TTXSetWinSize(int rows, int cols)
2119 maya 3227 {
2120     SSH_notify_win_size(pvar, cols, rows);
2121     }
2122    
2123     static void insertMenuBeforeItem(HMENU menu, WORD beforeItemID, WORD flags,
2124 doda 6801 WORD newItemID, char *text)
2125 maya 3227 {
2126     int i, j;
2127    
2128     for (i = GetMenuItemCount(menu) - 1; i >= 0; i--) {
2129     HMENU submenu = GetSubMenu(menu, i);
2130    
2131     for (j = GetMenuItemCount(submenu) - 1; j >= 0; j--) {
2132     if (GetMenuItemID(submenu, j) == beforeItemID) {
2133     InsertMenu(submenu, j, MF_BYPOSITION | flags, newItemID, text);
2134     return;
2135     }
2136     }
2137     }
2138     }
2139    
2140 doda 4463 #define GetFileMenu(menu) GetSubMenuByChildID(menu, 50110) // ID_FILE_NEWCONNECTION
2141     #define GetEditMenu(menu) GetSubMenuByChildID(menu, 50210) // ID_EDIT_COPY2
2142     #define GetSetupMenu(menu) GetSubMenuByChildID(menu, 50310) // ID_SETUP_TERMINAL
2143     #define GetControlMenu(menu) GetSubMenuByChildID(menu, 50410) // ID_CONTROL_RESETTERMINAL
2144     #define GetHelpMenu(menu) GetSubMenuByChildID(menu, 50990) // ID_HELP_ABOUT
2145    
2146     HMENU GetSubMenuByChildID(HMENU menu, UINT id) {
2147     int i, j, items, subitems, cur_id;
2148     HMENU m;
2149    
2150     items = GetMenuItemCount(menu);
2151    
2152     for (i=0; i<items; i++) {
2153     if (m = GetSubMenu(menu, i)) {
2154     subitems = GetMenuItemCount(m);
2155     for (j=0; j<subitems; j++) {
2156     cur_id = GetMenuItemID(m, j);
2157     if (cur_id == id) {
2158     return m;
2159     }
2160     }
2161     }
2162     }
2163     return NULL;
2164     }
2165    
2166 doda 6801 static void PASCAL TTXModifyMenu(HMENU menu)
2167 maya 3227 {
2168 doda 4463 pvar->FileMenu = GetFileMenu(menu);
2169    
2170 maya 3227 /* inserts before ID_HELP_ABOUT */
2171     UTIL_get_lang_msg("MENU_ABOUT", pvar, "About &TTSSH...");
2172     insertMenuBeforeItem(menu, 50990, MF_ENABLED, ID_ABOUTMENU, pvar->ts->UIMsg);
2173    
2174     /* inserts before ID_SETUP_TCPIP */
2175     UTIL_get_lang_msg("MENU_SSH", pvar, "SS&H...");
2176     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHSETUPMENU, pvar->ts->UIMsg);
2177     /* inserts before ID_SETUP_TCPIP */
2178     UTIL_get_lang_msg("MENU_SSH_AUTH", pvar, "SSH &Authentication...");
2179     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHAUTHSETUPMENU, pvar->ts->UIMsg);
2180     /* inserts before ID_SETUP_TCPIP */
2181     UTIL_get_lang_msg("MENU_SSH_FORWARD", pvar, "SSH F&orwarding...");
2182     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHFWDSETUPMENU, pvar->ts->UIMsg);
2183     UTIL_get_lang_msg("MENU_SSH_KEYGEN", pvar, "SSH KeyGe&nerator...");
2184     insertMenuBeforeItem(menu, 50360, MF_ENABLED, ID_SSHKEYGENMENU, pvar->ts->UIMsg);
2185    
2186     /* inserts before ID_FILE_CHANGEDIR */
2187     UTIL_get_lang_msg("MENU_SSH_SCP", pvar, "SS&H SCP...");
2188 doda 4463 insertMenuBeforeItem(menu, 50170, MF_GRAYED, ID_SSHSCPMENU, pvar->ts->UIMsg);
2189 maya 3227 }
2190    
2191 doda 6801 static void PASCAL TTXModifyPopupMenu(HMENU menu) {
2192 doda 4463 if (menu == pvar->FileMenu) {
2193 maya 6997 if (pvar->cv->Ready && pvar->socket != INVALID_SOCKET)
2194 doda 4463 EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_ENABLED);
2195     else
2196     EnableMenuItem(menu, ID_SSHSCPMENU, MF_BYCOMMAND | MF_GRAYED);
2197     }
2198     }
2199    
2200 maya 6132 static void about_dlg_set_abouttext(PTInstVar pvar, HWND dlg, digest_algorithm dgst_alg)
2201 maya 3227 {
2202 maya 6135 char buf[1024], buf2[2048];
2203 yutakapon 5575 char *fp = NULL;
2204 maya 3227
2205     // TTSSH�_�C�A���O���\������SSH������������ (2004.10.30 yutaka)
2206     if (pvar->socket != INVALID_SOCKET) {
2207 maya 6135 buf2[0] = '\0';
2208 maya 6132
2209 maya 3227 if (SSHv1(pvar)) {
2210 maya 6135 UTIL_get_lang_msg("DLG_ABOUT_SERVERID", pvar, "Server ID:");
2211     strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2212     strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2213 maya 3227 SSH_get_server_ID_info(pvar, buf, sizeof(buf));
2214 maya 6135 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2215     strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2216    
2217 maya 3227 UTIL_get_lang_msg("DLG_ABOUT_PROTOCOL", pvar, "Using protocol:");
2218 maya 6135 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2219     strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2220 maya 6150 SSH_get_protocol_version_info(pvar, buf, sizeof(buf));
2221 maya 6135 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2222     strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);
2223    
2224 maya 3227 UTIL_get_lang_msg("DLG_ABOUT_ENCRYPTION", pvar, "Encryption:");
2225 maya 6135 strncat_s(buf2, sizeof(buf2), pvar->ts->UIMsg, _TRUNCATE);
2226     strncat_s(buf2, sizeof(buf2), " ", _TRUNCATE);
2227 maya 6150 CRYPT_get_cipher_info(pvar, buf, sizeof(buf));
2228 maya 6135 strncat_s(buf2, sizeof(buf2), buf, _TRUNCATE);
2229     strncat_s(buf2, sizeof(buf2), "\r\n", _TRUNCATE);