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 5620 - (hide annotations) (download) (as text)
Thu Jun 26 12:48:19 2014 UTC (9 years, 9 months ago) by yutakapon
Original Path: trunk/ttssh2/ttxssh/ttxssh.c
File MIME type: text/x-csrc
File size: 179473 byte(s) 
チケット #33822 notify_nonfatal_errorの一部停止

ポート転送でローカルアプリケーションにデータ送信する処理で、送信失敗した場合の
エラーポップアップメッセージ（＆ログ採取）を抑止することができる設定を追加した。
デフォルトは無効。

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