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 5839 - (hide annotations) (download) (as text)
Wed Apr 29 16:23:18 2015 UTC (8 years, 11 months ago) by yutakapon
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 185457 byte(s) 
チケット #35047 SSH サーバホスト公開鍵の自動更新

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