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 6841 - (hide annotations) (download) (as text)
Tue Jul 4 15:02:28 2017 UTC (6 years, 9 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 183660 byte(s) 
TeraTerm Project としてのライセンス表記を追加

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