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 9210 - (hide annotations) (download) (as text)
Sat Apr 17 08:36:59 2021 UTC (2 years, 11 months ago) by nmaya
File MIME type: text/x-csrc
File size: 160775 byte(s) 
ファイルを分割・コードを移動・関数名を整理・新しい OpenSSH からインポート

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