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