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 7944 - (hide annotations) (download) (as text)
Mon Aug 12 18:48:20 2019 UTC (4 years, 8 months ago) by maya
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 173770 byte(s) 
コメント修正

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