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 6969 - (hide annotations) (download) (as text)
Thu Nov 2 11:37:41 2017 UTC (6 years, 5 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 183855 byte(s) 
OpenSSH の EtM 方式の MAC に対応。#31495

以下の MAC 方式に対応。
  ・hmac-sha2-256-etm@openssh.com
  ・hmac-sha2-512-etm@openssh.com
  ・hmac-sha1-etm@openssh.com
  ・hmac-md5-etm@openssh.com (*1)
  ・hmac-ripemd160-etm@openssh.com (*1, *2)
  ・hmac-sha1-96-etm@openssh.com (*1, *3)
  ・hmac-md5-96-etm@openssh.com (*1, *3)

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