Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/filesys_log.cpp

Contents of /trunk/teraterm/teraterm/filesys_log.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 8863 - (show annotations) (download) (as text)
Sat Jul 25 16:00:58 2020 UTC (3 years, 8 months ago) by zmatsuo
Original Path: trunk/teraterm/teraterm/filesys.cpp
File MIME type: text/x-c++src
File size: 59349 byte(s) 
logダイアログをUnicode対応、動作を調整

- ダイアログはUnicode化した
  - ログのファイル名はANSI
- BOM、コードが設定できるようになった
  - 起動直後の自動ログ UTF-8,BOM なし
1 /*
2 * Copyright (C) 1994-1998 T. Teranishi
3 * (C) 2005-2020 TeraTerm Project
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /* TERATERM.EXE, file transfer routines */
31 #include <stdio.h>
32 #include <io.h>
33 #include <process.h>
34 #include <windows.h>
35 #include <htmlhelp.h>
36 #include <assert.h>
37
38 #include "teraterm.h"
39 #include "tttypes.h"
40 #include "ttftypes.h"
41 #include "ftdlg.h"
42 #include "protodlg.h"
43 #include "ttwinman.h"
44 #include "commlib.h"
45 #include "ttcommon.h"
46 #include "ttdde.h"
47 #include "ttlib.h"
48 #include "dlglib.h"
49 #include "vtterm.h"
50 #include "win16api.h"
51 #include "ftlib.h"
52 #include "buffer.h"
53 #include "helpid.h"
54 #include "layer_for_unicode.h"
55 #include "layer_for_unicode_crt.h"
56 #include "codeconv.h"
57
58 #include "filesys.h"
59 //#include "tt_res.h"
60 #include "filesys_log_res.h"
61
62 #define FS_BRACKET_NONE 0
63 #define FS_BRACKET_START 1
64 #define FS_BRACKET_END 2
65
66 static PFileVar LogVar = NULL;
67 PFileVar SendVar = NULL;
68 PFileVar FileVar = NULL;
69 static PCHAR ProtoVar = NULL;
70 static int ProtoId;
71
72 BOOL FileLog = FALSE;
73 BOOL BinLog = FALSE;
74 static BOOL FileRetrySend, FileRetryEcho, FileCRSend, FileReadEOF, BinaryMode;
75 static BYTE FileByte;
76
77 #define FILE_SEND_BUF_SIZE 8192
78 struct FileSendHandler {
79 CHAR buf[FILE_SEND_BUF_SIZE];
80 int pos;
81 int end;
82 };
83 static struct FileSendHandler FileSendHandler;
84 static int FileDlgRefresh;
85
86 static int FileBracketMode = FS_BRACKET_NONE;
87 static int FileBracketPtr = 0;
88 static char BracketStartStr[] = "\033[200~";
89 static char BracketEndStr[] = "\033[201~";
90
91 static BOOL FSend = FALSE;
92
93 static HMODULE HTTFILE = NULL;
94 static int TTFILECount = 0;
95
96 PGetSetupFname GetSetupFname;
97 static PGetTransFname GetTransFname;
98 PGetMultiFname GetMultiFname;
99 PGetGetFname GetGetFname;
100 PSetFileVar SetFileVar;
101 PGetXFname GetXFname;
102 PProtoInit ProtoInit;
103 static PProtoParse ProtoParse;
104 PProtoTimeOutProc ProtoTimeOutProc;
105 PProtoCancel ProtoCancel;
106 PTTFILESetUILanguageFile TTFILESetUILanguageFile;
107 PTTFILESetFileSendFilter TTFILESetFileSendFilter;
108
109 #define IdGetSetupFname 1
110 #define IdGetTransFname 2
111 #define IdGetMultiFname 3
112 #define IdGetGetFname 4
113 #define IdSetFileVar 5
114 #define IdGetXFname 6
115
116 #define IdProtoInit 7
117 #define IdProtoParse 8
118 #define IdProtoTimeOutProc 9
119 #define IdProtoCancel 10
120
121 #define IdTTFILESetUILanguageFile 11
122 #define IdTTFILESetFileSendFilter 12
123
124 /*
125 Line Head flag for timestamping
126 2007.05.24 Gentaro
127 */
128 enum enumLineEnd {
129 Line_Other = 0,
130 Line_LineHead = 1,
131 Line_FileHead = 2,
132 };
133
134 static enum enumLineEnd eLineEnd = Line_LineHead;
135
136
137 // �x�����������p�X���b�h�����b�Z�[�W
138 #define WM_DPC_LOGTHREAD_SEND (WM_APP + 1)
139
140 static void CloseFileSync(PFileVar ptr);
141
142
143 BOOL LoadTTFILE(void)
144 {
145 BOOL Err;
146
147 if (HTTFILE != NULL)
148 {
149 TTFILECount++;
150 return TRUE;
151 }
152 else
153 TTFILECount = 0;
154
155 HTTFILE = LoadHomeDLL("TTPFILE.DLL");
156 if (HTTFILE == NULL)
157 return FALSE;
158
159 Err = FALSE;
160
161 GetSetupFname = (PGetSetupFname)GetProcAddress(HTTFILE,
162 MAKEINTRESOURCE(IdGetSetupFname));
163 if (GetSetupFname==NULL)
164 Err = TRUE;
165
166 GetTransFname = (PGetTransFname)GetProcAddress(HTTFILE,
167 MAKEINTRESOURCE(IdGetTransFname));
168 if (GetTransFname==NULL)
169 Err = TRUE;
170
171 GetMultiFname = (PGetMultiFname)GetProcAddress(HTTFILE,
172 MAKEINTRESOURCE(IdGetMultiFname));
173 if (GetMultiFname==NULL)
174 Err = TRUE;
175
176 GetGetFname = (PGetGetFname)GetProcAddress(HTTFILE,
177 MAKEINTRESOURCE(IdGetGetFname));
178 if (GetGetFname==NULL)
179 Err = TRUE;
180
181 SetFileVar = (PSetFileVar)GetProcAddress(HTTFILE,
182 MAKEINTRESOURCE(IdSetFileVar));
183 if (SetFileVar==NULL)
184 Err = TRUE;
185
186 GetXFname = (PGetXFname)GetProcAddress(HTTFILE,
187 MAKEINTRESOURCE(IdGetXFname));
188 if (GetXFname==NULL)
189 Err = TRUE;
190
191 ProtoInit = (PProtoInit)GetProcAddress(HTTFILE,
192 MAKEINTRESOURCE(IdProtoInit));
193 if (ProtoInit==NULL)
194 Err = TRUE;
195
196 ProtoParse = (PProtoParse)GetProcAddress(HTTFILE,
197 MAKEINTRESOURCE(IdProtoParse));
198 if (ProtoParse==NULL)
199 Err = TRUE;
200
201 ProtoTimeOutProc = (PProtoTimeOutProc)GetProcAddress(HTTFILE,
202 MAKEINTRESOURCE(IdProtoTimeOutProc));
203 if (ProtoTimeOutProc==NULL)
204 Err = TRUE;
205
206 ProtoCancel = (PProtoCancel)GetProcAddress(HTTFILE,
207 MAKEINTRESOURCE(IdProtoCancel));
208 if (ProtoCancel==NULL)
209 Err = TRUE;
210
211 TTFILESetUILanguageFile = (PTTFILESetUILanguageFile)GetProcAddress(HTTFILE,
212 MAKEINTRESOURCE(IdTTFILESetUILanguageFile));
213 if (TTFILESetUILanguageFile==NULL) {
214 Err = TRUE;
215 }
216 else {
217 TTFILESetUILanguageFile(ts.UILanguageFile);
218 }
219
220 TTFILESetFileSendFilter = (PTTFILESetFileSendFilter)GetProcAddress(HTTFILE,
221 MAKEINTRESOURCE(IdTTFILESetFileSendFilter));
222 if (TTFILESetFileSendFilter==NULL) {
223 Err = TRUE;
224 }
225 else {
226 TTFILESetFileSendFilter(ts.FileSendFilter);
227 }
228
229 if (Err)
230 {
231 FreeLibrary(HTTFILE);
232 HTTFILE = NULL;
233 return FALSE;
234 }
235 else {
236 TTFILECount = 1;
237 return TRUE;
238 }
239 }
240
241 BOOL FreeTTFILE(void)
242 {
243 if (TTFILECount==0)
244 return FALSE;
245 TTFILECount--;
246 if (TTFILECount>0)
247 return TRUE;
248 if (HTTFILE!=NULL)
249 {
250 FreeLibrary(HTTFILE);
251 HTTFILE = NULL;
252 }
253 return TRUE;
254 }
255
256 static PFileTransDlg FLogDlg = NULL;
257 static PFileTransDlg SendDlg = NULL;
258 static PProtoDlg PtDlg = NULL;
259
260 static BOOL OpenFTDlg(PFileVar fv)
261 {
262 PFileTransDlg FTDlg;
263
264 FTDlg = new CFileTransDlg();
265
266 fv->StartTime = 0;
267 fv->ProgStat = 0;
268 cv.FilePause &= ~fv->OpId;
269
270 if (fv->OpId != OpLog) {
271 fv->HideDialog = ts.FTHideDialog;
272 }
273
274 if (FTDlg!=NULL)
275 {
276 FTDlg->Create(hInst, HVTWin, fv, &cv, &ts);
277 FTDlg->RefreshNum();
278 }
279
280 if (fv->OpId==OpLog)
281 FLogDlg = FTDlg; /* Log */
282 else
283 SendDlg = FTDlg; /* File send */
284
285 fv->StartTime = GetTickCount();
286
287 return (FTDlg!=NULL);
288 }
289
290 static void ShowFTDlg(WORD OpId)
291 {
292 if (OpId == OpLog) {
293 if (FLogDlg != NULL) {
294 FLogDlg->ShowWindow(SW_SHOWNORMAL);
295 SetForegroundWindow(FLogDlg->GetSafeHwnd());
296 }
297 }
298 else {
299 if (SendDlg != NULL) {
300 SendDlg->ShowWindow(SW_SHOWNORMAL);
301 SetForegroundWindow(SendDlg->GetSafeHwnd());
302 }
303 }
304 }
305
306 BOOL NewFileVar(PFileVar *fv)
307 {
308 if ((*fv)==NULL)
309 {
310 *fv = (PFileVar)malloc(sizeof(TFileVar));
311 if ((*fv)!=NULL)
312 {
313 char FileDirExpanded[MAX_PATH];
314 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
315 memset(*fv, 0, sizeof(TFileVar));
316 strncpy_s((*fv)->FullName, sizeof((*fv)->FullName), FileDirExpanded, _TRUNCATE);
317 AppendSlash((*fv)->FullName,sizeof((*fv)->FullName));
318 (*fv)->DirLen = strlen((*fv)->FullName);
319 (*fv)->FileOpen = FALSE;
320 (*fv)->OverWrite = ((ts.FTFlag & FT_RENAME) == 0);
321 (*fv)->HMainWin = HVTWin;
322 (*fv)->Success = FALSE;
323 (*fv)->NoMsg = FALSE;
324 (*fv)->HideDialog = FALSE;
325 }
326 }
327
328 return ((*fv)!=NULL);
329 }
330
331 void FreeFileVar(PFileVar *fv)
332 {
333 if ((*fv)!=NULL)
334 {
335 CloseFileSync(*fv);
336 //if ((*fv)->FileOpen) _lclose((*fv)->FileHandle);
337 if ((*fv)->FnStrMemHandle != 0)
338 {
339 GlobalUnlock((*fv)->FnStrMemHandle);
340 GlobalFree((*fv)->FnStrMemHandle);
341 }
342 free(*fv);
343 *fv = NULL;
344 }
345 }
346
347 /**
348 * �t�@�C�������������u������
349 * &h �z�X�g�����u�� (2007.5.14)
350 * &p TCP�|�[�g�������u�� (2009.6.12)
351 * &u ���O�I���������[�U��
352 */
353 static void ConvertLogname(char *c, int destlen)
354 {
355 char buf[MAXPATHLEN], buf2[MAXPATHLEN], *p = c;
356 char tmphost[1024];
357 char tmpuser[256+1];
358 DWORD len_user = sizeof(tmpuser);
359
360 memset(buf, 0, sizeof(buf));
361
362 while(*p != '\0') {
363 if (*p == '&' && *(p+1) != '\0') {
364 switch (*(p+1)) {
365 case 'h':
366 if (cv.Open) {
367 if (cv.PortType == IdTCPIP) {
368 // �z�X�g����IPv6�A�h���X�����A�t�@�C�������g�p�����������������������A
369 // �]�v�����������������B
370 // (2013.3.9 yutaka)
371 strncpy_s(tmphost, sizeof(tmphost), ts.HostName, _TRUNCATE);
372 //strncpy_s(tmphost, sizeof(tmphost), "2001:0db8:bd05:01d2:288a:1fc0:0001:10ee", _TRUNCATE);
373 replaceInvalidFileNameChar(tmphost, '_');
374 strncat_s(buf,sizeof(buf), tmphost, _TRUNCATE);
375 }
376 else if (cv.PortType == IdSerial) {
377 strncpy_s(buf2,sizeof(buf2),buf,_TRUNCATE);
378 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "%sCOM%d", buf2, ts.ComPort);
379 }
380 }
381 break;
382 case 'p':
383 if (cv.Open) {
384 if (cv.PortType == IdTCPIP) {
385 char port[6];
386 _snprintf_s(port, sizeof(port), _TRUNCATE, "%d", ts.TCPPort);
387 strncat_s(buf,sizeof(buf),port,_TRUNCATE);
388 }
389 }
390 break;
391 case 'u':
392 if (GetUserName(tmpuser, &len_user) != 0) {
393 strncat_s(buf,sizeof(buf),tmpuser,_TRUNCATE);
394 }
395 break;
396 default:
397 strncpy_s(buf2,sizeof(buf2),p,2);
398 strncat_s(buf,sizeof(buf),buf2,_TRUNCATE);
399 }
400 p++;
401 }
402 else {
403 strncpy_s(buf2,sizeof(buf2),p,1);
404 strncat_s(buf,sizeof(buf),buf2,_TRUNCATE);
405 }
406 p++;
407 }
408 strncpy_s(c, destlen, buf, _TRUNCATE);
409 }
410
411 static void FixLogOption(void)
412 {
413 if (ts.LogBinary) {
414 ts.LogTypePlainText = false;
415 ts.LogTimestamp = false;
416 }
417 }
418
419
420 // �X���b�h���I�����t�@�C�����N���[�Y
421 static void CloseFileSync(PFileVar ptr)
422 {
423 BOOL ret;
424
425 if (!ptr->FileOpen)
426 return;
427
428 if (ptr->LogThread != INVALID_HANDLE_VALUE) {
429 // �X���b�h���I������
430 ret = PostThreadMessage(ptr->LogThreadId, WM_QUIT, 0, 0);
431 if (ret != 0) {
432 // �X���b�h�L���[���G���L���[���������������������������s���B
433 WaitForSingleObject(ptr->LogThread, INFINITE);
434 }
435 else {
436 //DWORD code = GetLastError();
437 }
438 CloseHandle(ptr->LogThread);
439 ptr->LogThread = INVALID_HANDLE_VALUE;
440 }
441 CloseHandle(ptr->FileHandle);
442 }
443
444 // �x�����������p�X���b�h
445 static unsigned _stdcall DeferredLogWriteThread(void *arg)
446 {
447 MSG msg;
448 PFileVar fv = (PFileVar)arg;
449 PCHAR buf;
450 DWORD buflen;
451 DWORD wrote;
452
453 PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
454
455 // �X���b�h�L���[���������I�������������X���b�h�����������m�����B
456 if (fv->LogThreadEvent != NULL) {
457 SetEvent(fv->LogThreadEvent);
458 }
459
460 while (GetMessage(&msg, NULL, 0, 0) > 0) {
461 switch (msg.message) {
462 case WM_DPC_LOGTHREAD_SEND:
463 buf = (PCHAR)msg.wParam;
464 buflen = (DWORD)msg.lParam;
465 WriteFile(LogVar->FileHandle, buf, buflen, &wrote, NULL);
466 free(buf); // ����������������
467 break;
468
469 case WM_QUIT:
470 goto end;
471 break;
472 }
473 }
474
475 end:
476 _endthreadex(0);
477 return (0);
478 }
479
480 /**
481 * �_�C�A���O�����e�� ts ����������
482 *
483 * TODO
484 * �_�C�A���O�����������l�������I��������
485 * ����������������������������������������������?
486 */
487 static void SetLogFlags(HWND Dialog)
488 {
489 WORD BinFlag, val;
490
491 GetRB(Dialog, &BinFlag, IDC_FOPTBIN, IDC_FOPTBIN);
492 ts.LogBinary = BinFlag;
493
494 GetRB(Dialog, &val, IDC_FOPTAPPEND, IDC_FOPTAPPEND);
495 ts.Append = val;
496
497 if (!BinFlag) {
498 GetRB(Dialog, &val, IDC_PLAINTEXT, IDC_PLAINTEXT);
499 ts.LogTypePlainText = val;
500
501 GetRB(Dialog, &val, IDC_TIMESTAMP, IDC_TIMESTAMP);
502 ts.LogTimestamp = val;
503 }
504
505 GetRB(Dialog, &val, IDC_HIDEDIALOG, IDC_HIDEDIALOG);
506 ts.LogHideDialog = val;
507
508 GetRB(Dialog, &val, IDC_ALLBUFF_INFIRST, IDC_ALLBUFF_INFIRST);
509 ts.LogAllBuffIncludedInFirst = val;
510
511 ts.LogTimestampType = (GetCurSel(Dialog, IDC_TIMESTAMPTYPE) - 1);
512 }
513
514 /**
515 * ���O�t�@�C���`�F�b�N
516 *
517 * @param[in] filename
518 * @param[out] exist TURE/FALSE
519 * @param[out] bom 0 no BOM (or file not exist)
520 * 1 UTF-8
521 * 2 UTF-16LE
522 * 3 UTF-16BE
523 */
524 static void CheckLogFile(const wchar_t *filename, BOOL *exist, int *bom)
525 {
526 *exist = FALSE;
527 *bom = 0;
528
529 // �t�@�C������������?
530 DWORD logdir = _GetFileAttributesW(filename);
531 if ((logdir != INVALID_FILE_ATTRIBUTES) && ((logdir & FILE_ATTRIBUTE_DIRECTORY) == 0)) {
532 // �t�@�C����������
533 *exist = TRUE;
534
535 // BOM�L��/�����`�F�b�N
536 FILE *fp = __wfopen(filename, L"rb");
537 if (fp != NULL) {
538 unsigned char tmp[4];
539 size_t l = fread(tmp, 1, sizeof(tmp), fp);
540 fclose(fp);
541 if (l < 2) {
542 *bom = 0;
543 } else if (l >= 2 && tmp[0] == 0xff && tmp[1] == 0xfe) {
544 // UTF-16LE
545 *bom = 2;
546 } else if (l >= 2 && tmp[0] == 0xfe && tmp[1] == 0xff) {
547 // UTF-16BE
548 *bom = 3;
549 } else if (l >= 3 && tmp[0] == 0xef && tmp[1] == 0xbb && tmp[2] == 0xbf) {
550 // UTF-8
551 *bom = 1;
552 } else {
553 *bom = 0;
554 }
555 }
556 }
557 }
558
559 typedef struct {
560 FLogDlgInfo_t *info;
561 // work
562 BOOL file_exist;
563 int current_bom;
564 TTTSet *pts;
565 } LogDlgWork_t;
566
567 static void ArrangeControls(HWND Dialog, LogDlgWork_t *work)
568 {
569 if (work->file_exist) {
570 EnableWindow(GetDlgItem(Dialog, IDC_APPEND), TRUE);
571 }
572 else {
573 // �t�@�C�������� -> �V�K
574 EnableWindow(GetDlgItem(Dialog, IDC_APPEND), FALSE);
575 CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_NEW_OVERWRITE);
576 }
577
578 if (work->file_exist && IsDlgButtonChecked(Dialog, IDC_APPEND) == BST_CHECKED) {
579 // �t�@�C������������ && append
580 int bom = work->current_bom;
581 if (bom != 0) {
582 // BOM�L��
583 CheckDlgButton(Dialog, IDC_BOM, BST_CHECKED);
584 int cur =
585 bom == 1 ? 0 :
586 bom == 2 ? 1 :
587 bom == 3 ? 2 : 0;
588 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, cur, 0);
589 }
590 else {
591 // BOM����
592 CheckDlgButton(Dialog, IDC_BOM, BST_UNCHECKED);
593 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0);
594 }
595 if (IsDlgButtonChecked(Dialog, IDC_FOPTTEXT) == BST_CHECKED) {
596 EnableWindow(GetDlgItem(Dialog, IDC_BOM), FALSE);
597 if (bom != 0) {
598 // BOM�L��
599 EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), FALSE);
600 }
601 else {
602 // BOM����
603 EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), TRUE);
604 }
605 }
606 }
607 else {
608 // �t�@�C���������A�V�K
609 CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_NEW_OVERWRITE);
610 CheckDlgButton(Dialog, IDC_BOM, BST_CHECKED);
611 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0);
612 if (IsDlgButtonChecked(Dialog, IDC_FOPTTEXT) == BST_CHECKED) {
613 EnableWindow(GetDlgItem(Dialog, IDC_BOM), TRUE);
614 }
615 }
616 }
617
618 static void CheckLogFile(HWND Dialog, const wchar_t *filename, LogDlgWork_t *work)
619 {
620 BOOL exist;
621 int bom;
622 CheckLogFile(filename, &exist, &bom);
623 work->file_exist = exist;
624 work->current_bom = bom;
625 ArrangeControls(Dialog, work);
626 }
627
628 static INT_PTR CALLBACK LogFnHook(HWND Dialog, UINT Message, WPARAM wParam, LPARAM lParam)
629 {
630 static const DlgTextInfo TextInfos[] = {
631 { 0, "DLG_TABSHEET_TITLE_LOG" },
632 { IDC_FOPTBIN, "DLG_FOPT_BINARY" },
633 // { IDC_FOPTAPPEND, "DLG_FOPT_APPEND" },
634 { IDC_PLAINTEXT, "DLG_FOPT_PLAIN" },
635 { IDC_HIDEDIALOG, "DLG_FOPT_HIDEDIALOG" },
636 { IDC_ALLBUFF_INFIRST, "DLG_FOPT_ALLBUFFINFIRST" },
637 { IDC_TIMESTAMP, "DLG_FOPT_TIMESTAMP" },
638 };
639 static const I18nTextInfo timestamp_list[] = {
640 { "DLG_FOPT_TIMESTAMP_LOCAL", L"Local Time" },
641 { "DLG_FOPT_TIMESTAMP_UTC", L"UTC" },
642 { "DLG_FOPT_TIMESTAMP_ELAPSED_LOGGING", L"Elapsed Time (Logging)" },
643 { "DLG_FOPT_TIMESTAMP_ELAPSED_CONNECTION", L"Elapsed Time (Connection)" },
644 };
645 LogDlgWork_t *work = (LogDlgWork_t *)GetWindowLongPtr(Dialog, DWLP_USER);
646
647 if (Message == RegisterWindowMessage(HELPMSGSTRING)) {
648 // �R�����_�C�A���O�������w���v���b�Z�[�W���t��������
649 Message = WM_COMMAND;
650 wParam = IDHELP;
651 }
652 switch (Message) {
653 case WM_INITDIALOG: {
654 work = (LogDlgWork_t *)lParam;
655 TTTSet *pts = work->pts;
656 const char *UILanguageFile = pts->UILanguageFile;
657 SetWindowLongPtr(Dialog, DWLP_USER, (LONG_PTR)work);
658 ::DragAcceptFiles(Dialog, TRUE);
659
660 SetDlgTexts(Dialog, TextInfos, _countof(TextInfos), UILanguageFile);
661 SetI18nList("Tera Term", Dialog, IDC_TIMESTAMPTYPE, timestamp_list, _countof(timestamp_list),
662 UILanguageFile, 0);
663
664 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_ADDSTRING, 0, (LPARAM)"UTF-8");
665 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_ADDSTRING, 0, (LPARAM)"UTF-16LE");
666 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_ADDSTRING, 0, (LPARAM)"UTF-16BE");
667 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0);
668
669 _SetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, work->info->filename);
670 work->info->filename = NULL;
671
672 // Binary/Text �`�F�b�N�{�b�N�X
673 if (pts->LogBinary) {
674 CheckRadioButton(Dialog, IDC_FOPTBIN, IDC_FOPTTEXT, IDC_FOPTBIN);
675 }
676 else {
677 CheckRadioButton(Dialog, IDC_FOPTBIN, IDC_FOPTTEXT, IDC_FOPTTEXT);
678 }
679
680 // Plain Text �`�F�b�N�{�b�N�X
681 if (pts->LogBinary) {
682 // Binary�t���O���L�����������`�F�b�N��������
683 DisableDlgItem(Dialog, IDC_PLAINTEXT, IDC_PLAINTEXT);
684 }
685 else if (pts->LogTypePlainText) {
686 SetRB(Dialog, 1, IDC_PLAINTEXT, IDC_PLAINTEXT);
687 }
688
689 // Hide dialog�`�F�b�N�{�b�N�X (2008.1.30 maya)
690 if (pts->LogHideDialog) {
691 SetRB(Dialog, 1, IDC_HIDEDIALOG, IDC_HIDEDIALOG);
692 }
693
694 // Include screen buffer�`�F�b�N�{�b�N�X (2013.9.29 yutaka)
695 if (pts->LogAllBuffIncludedInFirst) {
696 SetRB(Dialog, 1, IDC_ALLBUFF_INFIRST, IDC_ALLBUFF_INFIRST);
697 }
698
699 // timestamp�`�F�b�N�{�b�N�X (2006.7.23 maya)
700 if (pts->LogBinary) {
701 // Binary�t���O���L�����������`�F�b�N��������
702 DisableDlgItem(Dialog, IDC_TIMESTAMP, IDC_TIMESTAMP);
703 }
704 else if (pts->LogTimestamp) {
705 SetRB(Dialog, 1, IDC_TIMESTAMP, IDC_TIMESTAMP);
706 }
707
708 // timestamp ����
709 int tstype = pts->LogTimestampType == TIMESTAMP_LOCAL ? 0 :
710 pts->LogTimestampType == TIMESTAMP_UTC ? 1 :
711 pts->LogTimestampType == TIMESTAMP_ELAPSED_LOGSTART ? 2 :
712 pts->LogTimestampType == TIMESTAMP_ELAPSED_CONNECTED ? 3 : 0;
713 SendDlgItemMessage(Dialog, IDC_TIMESTAMPTYPE, CB_SETCURSEL, tstype, 0);
714 if (pts->LogBinary || !pts->LogTimestamp) {
715 DisableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE);
716 }
717
718 CenterWindow(Dialog, GetParent(Dialog));
719
720 return TRUE;
721 }
722
723 case WM_COMMAND:
724 switch (LOWORD(wParam)) {
725 case IDOK: {
726 wchar_t filename[MAX_PATH];
727 _GetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, filename, _countof(filename));
728 work->info->filename = _wcsdup(filename);
729 work->info->append = IsDlgButtonChecked(Dialog, IDC_FOPTAPPEND) == BST_CHECKED;
730 work->info->bom = IsDlgButtonChecked(Dialog, IDC_BOM) == BST_CHECKED;
731 work->info->code = (int)SendDlgItemMessageA(Dialog, IDC_TEXTCODING_DROPDOWN, CB_GETCURSEL, 0, 0);
732 SetLogFlags(Dialog);
733 EndDialog(Dialog, IDOK);
734 break;
735 }
736 case IDCANCEL:
737 EndDialog(Dialog, IDCANCEL);
738 break;
739 case IDHELP:
740 OpenHelp(HH_HELP_CONTEXT, HlpFileLog, work->pts->UILanguageFile);
741 break;
742 case IDC_FOPT_FILENAME_BUTTON: {
743 /* save current dir */
744 const char *UILanguageFile = work->pts->UILanguageFile;
745 wchar_t curdir[MAXPATHLEN];
746 _GetCurrentDirectoryW(_countof(curdir), curdir);
747
748 wchar_t fname[MAX_PATH];
749 GetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, fname, _countof(fname));
750
751 wchar_t FNFilter[128*3];
752 get_lang_msgW("FILEDLG_ALL_FILTER", FNFilter, sizeof(FNFilter), L"All(*.*)\\0*.*\\0\\0", UILanguageFile);
753
754 wchar_t caption[MAX_PATH];
755 wchar_t uimsg[MAX_UIMSG];
756 #define TitLogW L"Log"
757 get_lang_msgW("FILEDLG_TRANS_TITLE_LOG", uimsg, _countof(uimsg), TitLogW, UILanguageFile);
758 wcsncpy_s(caption, _countof(caption), L"Tera Term: ", _TRUNCATE);
759 wcsncat_s(caption, _countof(caption), uimsg, _TRUNCATE);
760
761 OPENFILENAMEW ofn = {};
762 ofn.lStructSize = get_OPENFILENAME_SIZEW();
763 //ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
764 ofn.Flags |= OFN_EXPLORER | OFN_ENABLESIZING;
765 ofn.Flags |= OFN_SHOWHELP;
766 ofn.Flags |= OFN_NOCHANGEDIR; // ��������������������������������
767 ofn.hwndOwner = Dialog;
768 ofn.lpstrFilter = FNFilter;
769 ofn.nFilterIndex = 1;
770 ofn.lpstrFile = fname;
771 ofn.nMaxFile = _countof(fname);
772 ofn.lpstrTitle = caption;
773 BOOL Ok = GetSaveFileNameW(&ofn);
774 if (Ok) {
775 SetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, fname);
776 }
777
778 /* restore dir */
779 _SetCurrentDirectoryW(curdir);
780
781 break;
782 }
783 case IDC_FOPTBIN:
784 EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), FALSE);
785 EnableWindow(GetDlgItem(Dialog, IDC_BOM), FALSE);
786 DisableDlgItem(Dialog, IDC_PLAINTEXT, IDC_TIMESTAMP);
787 DisableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE);
788 break;
789 case IDC_FOPTTEXT:
790 ArrangeControls(Dialog, work);
791 EnableDlgItem(Dialog, IDC_PLAINTEXT, IDC_TIMESTAMP);
792 // FALLTHROUGH -- BinFlag �� off ������ Timestamp �������L��/��������������
793 case IDC_TIMESTAMP:
794 if (IsDlgButtonChecked(Dialog, IDC_TIMESTAMP) == BST_CHECKED) {
795 EnableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE);
796 }
797 else {
798 DisableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE);
799 }
800 break;
801 case IDC_FOPT_FILENAME_EDIT:
802 if (HIWORD(wParam) == EN_CHANGE){
803 wchar_t filename[MAX_PATH];
804 GetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, filename, _countof(filename));
805 CheckLogFile(Dialog, filename, work);
806 }
807 break;
808 case IDC_NEW_OVERWRITE:
809 if (IsDlgButtonChecked(Dialog, IDC_FOPTTEXT) == BST_CHECKED) {
810 EnableWindow(GetDlgItem(Dialog, IDC_BOM), TRUE);
811 EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), TRUE);
812 CheckDlgButton(Dialog, IDC_BOM, BST_CHECKED);
813 SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0);
814 }
815 break;
816 case IDC_APPEND:
817 ArrangeControls(Dialog, work);
818 break;
819 }
820 break;
821 case WM_DROPFILES: {
822 // �����h���b�v��������������1������������
823 HDROP hDrop = (HDROP)wParam;
824 const UINT len = _DragQueryFileW(hDrop, 0, NULL, 0);
825 if (len == 0) {
826 DragFinish(hDrop);
827 return TRUE;
828 }
829 wchar_t *filename = (wchar_t *)malloc(sizeof(wchar_t) * (len + 1));
830 _DragQueryFileW(hDrop, 0, filename, len + 1);
831 filename[len] = '\0';
832 CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_APPEND);
833 _SetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, filename);
834 SendDlgItemMessage(Dialog, IDC_FOPT_FILENAME_EDIT, EM_SETSEL, len, len);
835 free(filename);
836 DragFinish(hDrop);
837 return TRUE;
838 }
839 }
840 return FALSE;
841 }
842
843 static BOOL LogStart(void)
844 {
845 unsigned tid;
846
847 if ((FileLog) || (BinLog)) return FALSE;
848
849 assert(LogVar != NULL);
850
851 if (strlen(&(LogVar->FullName[LogVar->DirLen]))==0) {
852 // �t�@�C����������������������
853 return FALSE;
854 }
855
856 if (! LoadTTFILE()) return FALSE;
857
858 LogVar->OpId = OpLog;
859 (*SetFileVar)(LogVar);
860 FixLogOption();
861
862 if (ts.LogBinary > 0)
863 {
864 BinLog = TRUE;
865 FileLog = FALSE;
866 if (! CreateBinBuf())
867 {
868 FileTransEnd(OpLog);
869 return FALSE;
870 }
871 }
872 else {
873 BinLog = FALSE;
874 FileLog = TRUE;
875 if (! CreateLogBuf())
876 {
877 FileTransEnd(OpLog);
878 return FALSE;
879 }
880 }
881 cv.LStart = cv.LogPtr;
882 cv.LCount = 0;
883 if (ts.LogHideDialog)
884 LogVar->HideDialog = 1;
885
886 /* 2007.05.24 Gentaro */
887 eLineEnd = Line_LineHead;
888
889 if (ts.Append > 0)
890 {
891 int dwShareMode = FILE_SHARE_READ;
892 if (!ts.LogLockExclusive) {
893 dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
894 }
895 LogVar->FileHandle = CreateFile(LogVar->FullName, GENERIC_WRITE, dwShareMode, NULL,
896 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
897 if (LogVar->FileHandle != INVALID_HANDLE_VALUE){
898 SetFilePointer(LogVar->FileHandle, 0, NULL, FILE_END);
899 /* 2007.05.24 Gentaro
900 If log file already exists,
901 a newline is inserted before the first timestamp.
902 */
903 eLineEnd = Line_FileHead;
904 }
905 }
906 else {
907 int dwShareMode = FILE_SHARE_READ;
908 if (!ts.LogLockExclusive) {
909 dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
910 }
911 LogVar->FileHandle = CreateFile(LogVar->FullName, GENERIC_WRITE, dwShareMode, NULL,
912 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
913 }
914 LogVar->FileOpen = (LogVar->FileHandle != INVALID_HANDLE_VALUE);
915 if (! LogVar->FileOpen)
916 {
917 char msg[128];
918
919 // �t�@�C���I�[�v���G���[�������b�Z�[�W�\�������������B(2008.7.9 yutaka)
920 if (LogVar->NoMsg == FALSE) {
921 _snprintf_s(msg, sizeof(msg), _TRUNCATE, "Can not create a `%s' file. (%d)", LogVar->FullName, GetLastError());
922 MessageBox(NULL, msg, "Tera Term: File open error", MB_OK | MB_ICONERROR);
923 }
924
925 FileTransEnd(OpLog);
926 return FALSE;
927 }
928 LogVar->ByteCount = 0;
929
930 // Log rotate configuration
931 LogVar->RotateMode = ts.LogRotate;
932 LogVar->RotateSize = ts.LogRotateSize;
933 LogVar->RotateStep = ts.LogRotateStep;
934
935 // Log rotate���L���������A�����t�@�C���T�C�Y�����������B
936 // �������t�@�C�������������T�C�Y�����[�e�[�g�������������C���B
937 // (2016.4.9 yutaka)
938 if (LogVar->RotateMode != ROTATE_NONE) {
939 DWORD size = GetFileSize(LogVar->FileHandle, NULL);
940 if (size != -1)
941 LogVar->ByteCount = size;
942 }
943
944 if (! OpenFTDlg(LogVar)) {
945 FileTransEnd(OpLog);
946 return FALSE;
947 }
948
949 // �x�����������p�X���b�h���N�����B
950 // (2013.4.19 yutaka)
951 // DeferredLogWriteThread �X���b�h���N�������A�X���b�h�L���[�����������������O���A
952 // ���O�t�@�C�����N���[�Y(CloseFileSync)���s���������A�G���L���[�����s���A�f�b�h���b�N
953 // �����������������C�������B
954 // �X���b�h�����������s�������A���O�����C�x���g�I�u�W�F�N�g���g�����A�X���b�h�L���[��
955 // ���������������������������������B���O�t���C�x���g�I�u�W�F�N�g���g���������A
956 // �V�X�e��(Windows OS)�������j�[�N�����O�������K�v�������B
957 // (2016.9.23 yutaka)
958 LogVar->LogThreadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
959 LogVar->LogThread = (HANDLE)_beginthreadex(NULL, 0, DeferredLogWriteThread, LogVar, 0, &tid);
960 LogVar->LogThreadId = tid;
961 if (LogVar->LogThreadEvent != NULL) {
962 WaitForSingleObject(LogVar->LogThreadEvent, INFINITE);
963 CloseHandle(LogVar->LogThreadEvent);
964 }
965
966 // �����o�b�t�@�������f�[�^�������������o���������A
967 // ���O�������J�n�����B
968 // (2013.9.29 yutaka)
969 if (ts.LogAllBuffIncludedInFirst) {
970 DWORD ofs, size, written_size;
971 char buf[512];
972 const char *crlf = "\r\n";
973 DWORD crlf_len = 2;
974 for (ofs = 0 ; ; ofs++ ) {
975 // 1�����s�����������B���������������A�G�X�P�[�v�V�[�P���X�������������B
976 size = BuffGetAnyLineData(ofs, buf, sizeof(buf));
977 if (size == -1)
978 break;
979
980 #if 0
981 if (ts.DeferredLogWriteMode) { // �x����������
982 char *pbuf = (char *)malloc(size + 2);
983 memcpy(pbuf, buf, size);
984 pbuf[size] = '\r';
985 pbuf[size+1] = '\n';
986 Sleep(1); // �X���b�h�L���[�����������������A�R���e�L�X�g�X�C�b�`�������B
987 PostThreadMessage(LogVar->LogThreadId, WM_DPC_LOGTHREAD_SEND, (WPARAM)pbuf, size + 2);
988 } else { // �������B�l�b�g���[�N�o�R�����x���B
989 #endif
990 WriteFile(LogVar->FileHandle, buf, size, &written_size, NULL);
991 WriteFile(LogVar->FileHandle, crlf, crlf_len, &written_size, NULL);
992 #if 0
993 }
994 #endif
995 }
996 }
997
998 return TRUE;
999 }
1000
1001 void LogPut1(BYTE b)
1002 {
1003 cv.LogBuf[cv.LogPtr] = b;
1004 cv.LogPtr++;
1005 if (cv.LogPtr>=InBuffSize)
1006 cv.LogPtr = cv.LogPtr-InBuffSize;
1007
1008 if (FileLog)
1009 {
1010 if (cv.LCount>=InBuffSize)
1011 {
1012 cv.LCount = InBuffSize;
1013 cv.LStart = cv.LogPtr;
1014 }
1015 else
1016 cv.LCount++;
1017 }
1018 else
1019 cv.LCount = 0;
1020 }
1021
1022 static BOOL Get1(PCHAR Buf, int *Start, int *Count, PBYTE b)
1023 {
1024 if (*Count<=0) return FALSE;
1025 *b = Buf[*Start];
1026 (*Start)++;
1027 if (*Start>=InBuffSize)
1028 *Start = *Start-InBuffSize;
1029 (*Count)--;
1030 return TRUE;
1031 }
1032
1033
1034
1035 static CRITICAL_SECTION g_filelog_lock; /* ���b�N�p���� */
1036
1037 void logfile_lock_initialize(void)
1038 {
1039 InitializeCriticalSection(&g_filelog_lock);
1040 }
1041
1042 static inline void logfile_lock(void)
1043 {
1044 EnterCriticalSection(&g_filelog_lock);
1045 }
1046
1047 static inline void logfile_unlock(void)
1048 {
1049 LeaveCriticalSection(&g_filelog_lock);
1050 }
1051
1052 // �R�����g�����O����������
1053 static void CommentLogToFile(char *buf, int size)
1054 {
1055 DWORD wrote;
1056
1057 if (LogVar == NULL || !LogVar->FileOpen) {
1058 char uimsg[MAX_UIMSG];
1059 get_lang_msg("MSG_ERROR", uimsg, sizeof(uimsg), "ERROR", ts.UILanguageFile);
1060 get_lang_msg("MSG_COMMENT_LOG_OPEN_ERROR", ts.UIMsg, sizeof(ts.UIMsg),
1061 "It is not opened by the log file yet.", ts.UILanguageFile);
1062 ::MessageBox(NULL, ts.UIMsg, uimsg, MB_OK|MB_ICONEXCLAMATION);
1063 return;
1064 }
1065
1066 logfile_lock();
1067 WriteFile(LogVar->FileHandle, buf, size, &wrote, NULL);
1068 WriteFile(LogVar->FileHandle, "\r\n", 2, &wrote, NULL); // ���s
1069 /* Set Line End Flag
1070 2007.05.24 Gentaro
1071 */
1072 eLineEnd = Line_LineHead;
1073 logfile_unlock();
1074 }
1075
1076 // ���O�����[�e�[�g�����B
1077 // (2013.3.21 yutaka)
1078 static void LogRotate(void)
1079 {
1080 int loopmax = 10000; // XXX
1081 char filename[1024];
1082 char newfile[1024], oldfile[1024];
1083 int i, k;
1084 int dwShareMode = FILE_SHARE_READ;
1085 unsigned tid;
1086
1087 if (! LogVar->FileOpen) return;
1088
1089 if (LogVar->RotateMode == ROTATE_NONE)
1090 return;
1091
1092 if (LogVar->RotateMode == ROTATE_SIZE) {
1093 if (LogVar->ByteCount <= LogVar->RotateSize)
1094 return;
1095 //OutputDebugPrintf("%s: mode %d size %ld\n", __FUNCTION__, LogVar->RotateMode, LogVar->ByteCount);
1096 } else {
1097 return;
1098 }
1099
1100 logfile_lock();
1101 // ���O�T�C�Y���������������B
1102 LogVar->ByteCount = 0;
1103
1104 // �������������t�@�C�����N���[�Y�����A�������t�@�C�����I�[�v�������B
1105 CloseFileSync(LogVar);
1106 //_lclose(LogVar->FileHandle);
1107
1108 // �������[�e�[�V�������X�e�b�v�����w����������
1109 if (LogVar->RotateStep > 0)
1110 loopmax = LogVar->RotateStep;
1111
1112 for (i = 1 ; i <= loopmax ; i++) {
1113 _snprintf_s(filename, sizeof(filename), _TRUNCATE, "%s.%d", LogVar->FullName, i);
1114 if (_access_s(filename, 0) != 0)
1115 break;
1116 }
1117 if (i > loopmax) {
1118 // �������������������������A�������t�@�C�������p�������B
1119 i = loopmax;
1120 }
1121
1122 // ���t�@�C�������l�[���B
1123 for (k = i-1 ; k >= 0 ; k--) {
1124 if (k == 0)
1125 strncpy_s(oldfile, sizeof(oldfile), LogVar->FullName, _TRUNCATE);
1126 else
1127 _snprintf_s(oldfile, sizeof(oldfile), _TRUNCATE, "%s.%d", LogVar->FullName, k);
1128 _snprintf_s(newfile, sizeof(newfile), _TRUNCATE, "%s.%d", LogVar->FullName, k+1);
1129 remove(newfile);
1130 if (rename(oldfile, newfile) != 0) {
1131 OutputDebugPrintf("%s: rename %d\n", __FUNCTION__, errno);
1132 }
1133 }
1134
1135 // ���I�[�v��
1136 if (!ts.LogLockExclusive) {
1137 dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
1138 }
1139 LogVar->FileHandle = CreateFile(LogVar->FullName, GENERIC_WRITE, dwShareMode, NULL,
1140 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1141
1142 // �x�����������p�X���b�h���N�����B
1143 // (2013.4.19 yutaka)
1144 // DeferredLogWriteThread �X���b�h���N�������A�X���b�h�L���[�����������������O���A
1145 // ���O�t�@�C�����N���[�Y(CloseFileSync)���s���������A�G���L���[�����s���A�f�b�h���b�N
1146 // �����������������C�������B
1147 // �X���b�h�����������s�������A���O�����C�x���g�I�u�W�F�N�g���g�����A�X���b�h�L���[��
1148 // ���������������������������������B���O�t���C�x���g�I�u�W�F�N�g���g���������A
1149 // �V�X�e��(Windows OS)�������j�[�N�����O�������K�v�������B
1150 // (2016.9.26 yutaka)
1151 LogVar->LogThreadEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
1152 LogVar->LogThread = (HANDLE)_beginthreadex(NULL, 0, DeferredLogWriteThread, LogVar, 0, &tid);
1153 LogVar->LogThreadId = tid;
1154 if (LogVar->LogThreadEvent != NULL) {
1155 WaitForSingleObject(LogVar->LogThreadEvent, INFINITE);
1156 CloseHandle(LogVar->LogThreadEvent);
1157 }
1158
1159 logfile_unlock();
1160
1161 }
1162
1163 void LogToFile(void)
1164 {
1165 PCHAR Buf;
1166 int Start, Count;
1167 BYTE b;
1168 PCHAR WriteBuf;
1169 DWORD WriteBufMax, WriteBufLen;
1170 CHAR tmp[128];
1171 DWORD wrote;
1172
1173 if (! LogVar->FileOpen) return;
1174 if (FileLog)
1175 {
1176 Buf = cv.LogBuf;
1177 Start = cv.LStart;
1178 Count = cv.LCount;
1179 }
1180 else if (BinLog)
1181 {
1182 Buf = cv.BinBuf;
1183 Start = cv.BStart;
1184 Count = cv.BCount;
1185 }
1186 else
1187 return;
1188
1189 if (Buf==NULL) return;
1190 if (Count==0) return;
1191
1192 // ���b�N������(2004.8.6 yutaka)
1193 logfile_lock();
1194
1195 if (ts.DeferredLogWriteMode) {
1196 WriteBufMax = 8192;
1197 WriteBufLen = 0;
1198 WriteBuf = (PCHAR)malloc(WriteBufMax);
1199 while (Get1(Buf,&Start,&Count,&b)) {
1200 if (!FLogIsPause() && (! cv.ProtoFlag))
1201 {
1202 tmp[0] = 0;
1203 if ( ts.LogTimestamp && eLineEnd ) {
1204 char *strtime = NULL;
1205
1206 switch (ts.LogTimestampType) {
1207 case TIMESTAMP_LOCAL:
1208 strtime = mctimelocal(ts.LogTimestampFormat, FALSE);
1209 break;
1210 case TIMESTAMP_UTC:
1211 strtime = mctimelocal(ts.LogTimestampFormat, TRUE);
1212 break;
1213 case TIMESTAMP_ELAPSED_LOGSTART:
1214 strtime = strelapsed(LogVar->StartTime);
1215 break;
1216 case TIMESTAMP_ELAPSED_CONNECTED:
1217 strtime = strelapsed(cv.ConnectedTime);
1218 break;
1219 }
1220
1221 /* 2007.05.24 Gentaro */
1222 if( eLineEnd == Line_FileHead ){
1223 strncat_s(tmp, sizeof(tmp), "\r\n", _TRUNCATE);
1224 }
1225 strncat_s(tmp, sizeof(tmp), "[", _TRUNCATE);
1226 strncat_s(tmp, sizeof(tmp), strtime, _TRUNCATE);
1227 strncat_s(tmp, sizeof(tmp), "] ", _TRUNCATE);
1228 }
1229
1230 /* 2007.05.24 Gentaro */
1231 if( b == 0x0a ){
1232 eLineEnd = Line_LineHead; /* set endmark*/
1233 }
1234 else {
1235 eLineEnd = Line_Other; /* clear endmark*/
1236 }
1237
1238 if (WriteBufLen >= (WriteBufMax*4/5)) {
1239 WriteBufMax *= 2;
1240 WriteBuf = (PCHAR)realloc(WriteBuf, WriteBufMax);
1241 }
1242 memcpy(&WriteBuf[WriteBufLen], tmp, strlen(tmp));
1243 WriteBufLen += strlen(tmp);
1244 WriteBuf[WriteBufLen++] = b;
1245
1246 (LogVar->ByteCount)++;
1247 }
1248 }
1249
1250 PostThreadMessage(LogVar->LogThreadId, WM_DPC_LOGTHREAD_SEND, (WPARAM)WriteBuf, WriteBufLen);
1251
1252 } else {
1253
1254 while (Get1(Buf,&Start,&Count,&b))
1255 {
1256 if (!FLogIsPause() && (! cv.ProtoFlag))
1257 {
1258 if ( ts.LogTimestamp && eLineEnd ) {
1259 char *strtime = NULL;
1260
1261 switch (ts.LogTimestampType) {
1262 case TIMESTAMP_LOCAL:
1263 strtime = mctimelocal(ts.LogTimestampFormat, FALSE);
1264 break;
1265 case TIMESTAMP_UTC:
1266 strtime = mctimelocal(ts.LogTimestampFormat, TRUE);
1267 break;
1268 case TIMESTAMP_ELAPSED_LOGSTART:
1269 strtime = strelapsed(LogVar->StartTime);
1270 break;
1271 case TIMESTAMP_ELAPSED_CONNECTED:
1272 strtime = strelapsed(cv.ConnectedTime);
1273 break;
1274 }
1275 WriteFile(LogVar->FileHandle, "[", 1, &wrote, NULL);
1276 WriteFile(LogVar->FileHandle, strtime, strlen(strtime), &wrote, NULL);
1277 WriteFile(LogVar->FileHandle, "] ", 2, &wrote, NULL);
1278 }
1279
1280 /* 2007.05.24 Gentaro */
1281 if( b == 0x0a ){
1282 eLineEnd = Line_LineHead; /* set endmark*/
1283 }
1284 else {
1285 eLineEnd = Line_Other; /* clear endmark*/
1286 }
1287
1288 WriteFile(LogVar->FileHandle, (PCHAR)&b, 1, &wrote, NULL);
1289 (LogVar->ByteCount)++;
1290 }
1291 }
1292
1293 }
1294
1295 logfile_unlock();
1296
1297 if (FileLog)
1298 {
1299 cv.LStart = Start;
1300 cv.LCount = Count;
1301 }
1302 else {
1303 cv.BStart = Start;
1304 cv.BCount = Count;
1305 }
1306 if (FLogIsPause() || cv.ProtoFlag) return;
1307 if (FLogDlg!=NULL)
1308 FLogDlg->RefreshNum();
1309
1310 // ���O�E���[�e�[�g
1311 LogRotate();
1312
1313 }
1314
1315 BOOL CreateLogBuf(void)
1316 {
1317 if (cv.HLogBuf==NULL)
1318 {
1319 cv.HLogBuf = GlobalAlloc(GMEM_MOVEABLE,InBuffSize);
1320 cv.LogBuf = NULL;
1321 cv.LogPtr = 0;
1322 cv.LStart = 0;
1323 cv.LCount = 0;
1324 }
1325 return (cv.HLogBuf!=NULL);
1326 }
1327
1328 void FreeLogBuf(void)
1329 {
1330 if ((cv.HLogBuf==NULL) || FileLog)
1331 return;
1332 if (cv.LogBuf!=NULL)
1333 GlobalUnlock(cv.HLogBuf);
1334 GlobalFree(cv.HLogBuf);
1335 cv.HLogBuf = NULL;
1336 cv.LogBuf = NULL;
1337 cv.LogPtr = 0;
1338 cv.LStart = 0;
1339 cv.LCount = 0;
1340 }
1341
1342 BOOL CreateBinBuf(void)
1343 {
1344 if (cv.HBinBuf==NULL)
1345 {
1346 cv.HBinBuf = GlobalAlloc(GMEM_MOVEABLE,InBuffSize);
1347 cv.BinBuf = NULL;
1348 cv.BinPtr = 0;
1349 cv.BStart = 0;
1350 cv.BCount = 0;
1351 }
1352 return (cv.HBinBuf!=NULL);
1353 }
1354
1355 void FreeBinBuf(void)
1356 {
1357 if ((cv.HBinBuf==NULL) || BinLog)
1358 return;
1359 if (cv.BinBuf!=NULL)
1360 GlobalUnlock(cv.HBinBuf);
1361 GlobalFree(cv.HBinBuf);
1362 cv.HBinBuf = NULL;
1363 cv.BinBuf = NULL;
1364 cv.BinPtr = 0;
1365 cv.BStart = 0;
1366 cv.BCount = 0;
1367 }
1368
1369 void FileSendStart(void)
1370 {
1371 LONG Option = 0;
1372
1373 if (! cv.Ready || FSend) return;
1374 if (cv.ProtoFlag)
1375 {
1376 FreeFileVar(&SendVar);
1377 return;
1378 }
1379
1380 if (! LoadTTFILE())
1381 return;
1382 if (! NewFileVar(&SendVar))
1383 {
1384 FreeTTFILE();
1385 return;
1386 }
1387 SendVar->OpId = OpSendFile;
1388
1389 FSend = TRUE;
1390
1391 if (strlen(&(SendVar->FullName[SendVar->DirLen])) == 0) {
1392 char FileDirExpanded[MAX_PATH];
1393 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
1394 if (ts.TransBin)
1395 Option |= LOGDLG_BINARY;
1396 SendVar->FullName[0] = 0;
1397 if (! (*GetTransFname)(SendVar, FileDirExpanded, GTF_SEND, &Option)) {
1398 FileTransEnd(OpSendFile);
1399 return;
1400 }
1401 ts.TransBin = CheckFlag(Option, LOGDLG_BINARY);
1402 }
1403 else
1404 (*SetFileVar)(SendVar);
1405
1406 SendVar->FileHandle = CreateFile(SendVar->FullName, GENERIC_READ, FILE_SHARE_READ, NULL,
1407 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
1408 SendVar->FileOpen = (SendVar->FileHandle != INVALID_HANDLE_VALUE);
1409 if (! SendVar->FileOpen)
1410 {
1411 FileTransEnd(OpSendFile);
1412 return;
1413 }
1414 SendVar->ByteCount = 0;
1415 SendVar->FileSize = GetFSize(SendVar->FullName);
1416
1417 TalkStatus = IdTalkFile;
1418 FileRetrySend = FALSE;
1419 FileRetryEcho = FALSE;
1420 FileCRSend = FALSE;
1421 FileReadEOF = FALSE;
1422 FileSendHandler.pos = 0;
1423 FileSendHandler.end = 0;
1424 FileDlgRefresh = 0;
1425
1426 if (BracketedPasteMode()) {
1427 FileBracketMode = FS_BRACKET_START;
1428 FileBracketPtr = 0;
1429 BinaryMode = TRUE;
1430 }
1431 else {
1432 FileBracketMode = FS_BRACKET_NONE;
1433 BinaryMode = ts.TransBin;
1434 }
1435
1436 if (! OpenFTDlg(SendVar))
1437 FileTransEnd(OpSendFile);
1438 }
1439
1440 void FileTransEnd(WORD OpId)
1441 /* OpId = 0: close Log and FileSend
1442 OpLog: close Log
1443 OpSendFile: close FileSend */
1444 {
1445 if (((OpId==0) || (OpId==OpLog)) && (FileLog || BinLog))
1446 {
1447 FileLog = FALSE;
1448 BinLog = FALSE;
1449 if (FLogDlg!=NULL)
1450 {
1451 FLogDlg->DestroyWindow();
1452 FLogDlg = NULL;
1453 }
1454 FreeFileVar(&LogVar);
1455 FreeLogBuf();
1456 FreeBinBuf();
1457 FreeTTFILE();
1458 }
1459
1460 if (((OpId==0) || (OpId==OpSendFile)) && FSend)
1461 {
1462 FSend = FALSE;
1463 TalkStatus = IdTalkKeyb;
1464 if (SendDlg!=NULL)
1465 {
1466 SendDlg->DestroyWindow();
1467 SendDlg = NULL;
1468 }
1469 FreeFileVar(&SendVar);
1470 FreeTTFILE();
1471 }
1472
1473 EndDdeCmnd(0);
1474 }
1475
1476 void FileTransPause(WORD OpId, BOOL Pause)
1477 {
1478 if (Pause) {
1479 cv.FilePause |= OpId;
1480 }
1481 else {
1482 cv.FilePause &= ~OpId;
1483 }
1484 }
1485
1486 int FSOut1(BYTE b)
1487 {
1488 if (BinaryMode)
1489 return CommBinaryOut(&cv,(PCHAR)&b,1);
1490 else if ((b>=0x20) || (b==0x09) || (b==0x0A) || (b==0x0D))
1491 return CommTextOut(&cv,(PCHAR)&b,1);
1492 else
1493 return 1;
1494 }
1495
1496 int FSEcho1(BYTE b)
1497 {
1498 if (BinaryMode)
1499 return CommBinaryEcho(&cv,(PCHAR)&b,1);
1500 else
1501 return CommTextEcho(&cv,(PCHAR)&b,1);
1502 }
1503
1504 // �������������������������g��
1505 // - BinaryMode == true
1506 // - FileBracketMode == false
1507 // - cv.TelFlag == false
1508 // - ts.LocalEcho == 0
1509 void FileSendBinayBoost(void)
1510 {
1511 WORD c, fc;
1512 LONG BCOld;
1513 DWORD read_bytes;
1514
1515 if ((SendDlg == NULL) ||
1516 ((cv.FilePause & OpSendFile) != 0))
1517 return;
1518
1519 BCOld = SendVar->ByteCount;
1520
1521 if (FileRetrySend)
1522 {
1523 c = CommRawOut(&cv, &(FileSendHandler.buf[FileSendHandler.pos]),
1524 FileSendHandler.end - FileSendHandler.pos);
1525 FileSendHandler.pos += c;
1526 FileRetrySend = (FileSendHandler.end != FileSendHandler.pos);
1527 if (FileRetrySend)
1528 return;
1529 }
1530
1531 do {
1532 if (FileSendHandler.pos == FileSendHandler.end) {
1533 ReadFile(SendVar->FileHandle, &(FileSendHandler.buf[0]), sizeof(FileSendHandler.buf), &read_bytes, NULL);
1534 fc = LOWORD(read_bytes);
1535 FileSendHandler.pos = 0;
1536 FileSendHandler.end = fc;
1537 } else {
1538 fc = FileSendHandler.end - FileSendHandler.end;
1539 }
1540
1541 if (fc != 0)
1542 {
1543 c = CommRawOut(&cv, &(FileSendHandler.buf[FileSendHandler.pos]),
1544 FileSendHandler.end - FileSendHandler.pos);
1545 FileSendHandler.pos += c;
1546 FileRetrySend = (FileSendHandler.end != FileSendHandler.pos);
1547 SendVar->ByteCount = SendVar->ByteCount + c;
1548 if (FileRetrySend)
1549 {
1550 if (SendVar->ByteCount != BCOld)
1551 SendDlg->RefreshNum();
1552 return;
1553 }
1554 }
1555 FileDlgRefresh = SendVar->ByteCount;
1556 SendDlg->RefreshNum();
1557 BCOld = SendVar->ByteCount;
1558 if (fc != 0)
1559 return;
1560 } while (fc != 0);
1561
1562 FileTransEnd(OpSendFile);
1563 }
1564
1565 void FileSend(void)
1566 {
1567 WORD c, fc;
1568 LONG BCOld;
1569 DWORD read_bytes;
1570
1571 if (cv.PortType == IdSerial && ts.FileSendHighSpeedMode &&
1572 BinaryMode && !FileBracketMode && !cv.TelFlag &&
1573 (ts.LocalEcho == 0) && (ts.Baud >= 115200)) {
1574 return FileSendBinayBoost();
1575 }
1576
1577 if ((SendDlg==NULL) ||
1578 ((cv.FilePause & OpSendFile) !=0))
1579 return;
1580
1581 BCOld = SendVar->ByteCount;
1582
1583 if (FileRetrySend)
1584 {
1585 FileRetryEcho = (ts.LocalEcho>0);
1586 c = FSOut1(FileByte);
1587 FileRetrySend = (c==0);
1588 if (FileRetrySend)
1589 return;
1590 }
1591
1592 if (FileRetryEcho)
1593 {
1594 c = FSEcho1(FileByte);
1595 FileRetryEcho = (c==0);
1596 if (FileRetryEcho)
1597 return;
1598 }
1599
1600 do {
1601 if (FileBracketMode == FS_BRACKET_START) {
1602 FileByte = BracketStartStr[FileBracketPtr++];
1603 fc = 1;
1604
1605 if (FileBracketPtr >= sizeof(BracketStartStr) - 1) {
1606 FileBracketMode = FS_BRACKET_END;
1607 FileBracketPtr = 0;
1608 BinaryMode = ts.TransBin;
1609 }
1610 }
1611 else if (! FileReadEOF) {
1612 ReadFile(SendVar->FileHandle, &FileByte, 1, &read_bytes, NULL);
1613 fc = LOWORD(read_bytes);
1614 SendVar->ByteCount = SendVar->ByteCount + fc;
1615
1616 if (FileCRSend && (fc==1) && (FileByte==0x0A)) {
1617 ReadFile(SendVar->FileHandle, &FileByte, 1, &read_bytes, NULL);
1618 fc = LOWORD(read_bytes);
1619 SendVar->ByteCount = SendVar->ByteCount + fc;
1620 }
1621 }
1622 else {
1623 fc = 0;
1624 }
1625
1626 if (fc == 0 && FileBracketMode == FS_BRACKET_END) {
1627 FileReadEOF = TRUE;
1628 FileByte = BracketEndStr[FileBracketPtr++];
1629 fc = 1;
1630 BinaryMode = TRUE;
1631
1632 if (FileBracketPtr >= sizeof(BracketEndStr) - 1) {
1633 FileBracketMode = FS_BRACKET_NONE;
1634 FileBracketPtr = 0;
1635 }
1636 }
1637
1638
1639 if (fc!=0)
1640 {
1641 c = FSOut1(FileByte);
1642 FileCRSend = (ts.TransBin==0) && (FileByte==0x0D);
1643 FileRetrySend = (c==0);
1644 if (FileRetrySend)
1645 {
1646 if (SendVar->ByteCount != BCOld)
1647 SendDlg->RefreshNum();
1648 return;
1649 }
1650 if (ts.LocalEcho>0)
1651 {
1652 c = FSEcho1(FileByte);
1653 FileRetryEcho = (c==0);
1654 if (FileRetryEcho)
1655 return;
1656 }
1657 }
1658 if ((fc==0) || ((SendVar->ByteCount % 100 == 0) && (FileBracketPtr == 0))) {
1659 SendDlg->RefreshNum();
1660 BCOld = SendVar->ByteCount;
1661 if (fc!=0)
1662 return;
1663 }
1664 } while (fc!=0);
1665
1666 FileTransEnd(OpSendFile);
1667 }
1668
1669 /**
1670 * ���O���|�[�Y����
1671 * ���� FLogChangeButton() ������
1672 */
1673 void FLogPause(BOOL Pause)
1674 {
1675 if (FLogDlg!=NULL)
1676 FLogDlg->ChangeButton(Pause);
1677 FileTransPause(OpLog, Pause);
1678 }
1679
1680 static BOOL OpenProtoDlg(PFileVar fv, int IdProto, int Mode, WORD Opt1, WORD Opt2)
1681 {
1682 int vsize;
1683 PProtoDlg pd;
1684
1685 ProtoId = IdProto;
1686
1687 switch (ProtoId) {
1688 case PROTO_KMT:
1689 vsize = sizeof(TKmtVar);
1690 break;
1691 case PROTO_XM:
1692 vsize = sizeof(TXVar);
1693 break;
1694 case PROTO_YM:
1695 vsize = sizeof(TYVar);
1696 break;
1697 case PROTO_ZM:
1698 vsize = sizeof(TZVar);
1699 break;
1700 case PROTO_BP:
1701 vsize = sizeof(TBPVar);
1702 break;
1703 case PROTO_QV:
1704 vsize = sizeof(TQVVar);
1705 break;
1706 default:
1707 vsize = 0;
1708 assert(FALSE);
1709 break;
1710 }
1711 ProtoVar = (PCHAR)malloc(vsize);
1712 if (ProtoVar==NULL)
1713 return FALSE;
1714
1715 switch (ProtoId) {
1716 case PROTO_KMT:
1717 ((PKmtVar)ProtoVar)->KmtMode = Mode;
1718 break;
1719 case PROTO_XM:
1720 ((PXVar)ProtoVar)->XMode = Mode;
1721 ((PXVar)ProtoVar)->XOpt = Opt1;
1722 ((PXVar)ProtoVar)->TextFlag = 1 - (Opt2 & 1);
1723 break;
1724 case PROTO_YM:
1725 ((PYVar)ProtoVar)->YMode = Mode;
1726 ((PYVar)ProtoVar)->YOpt = Opt1;
1727 break;
1728 case PROTO_ZM:
1729 ((PZVar)ProtoVar)->BinFlag = (Opt1 & 1) != 0;
1730 ((PZVar)ProtoVar)->ZMode = Mode;
1731 break;
1732 case PROTO_BP:
1733 ((PBPVar)ProtoVar)->BPMode = Mode;
1734 break;
1735 case PROTO_QV:
1736 ((PQVVar)ProtoVar)->QVMode = Mode;
1737 break;
1738 }
1739
1740 pd = new CProtoDlg();
1741 if (pd==NULL)
1742 {
1743 free(ProtoVar);
1744 ProtoVar = NULL;
1745 return FALSE;
1746 }
1747 pd->Create(hInst, HVTWin, fv, &ts);
1748
1749 (*ProtoInit)(ProtoId,FileVar,ProtoVar,&cv,&ts);
1750
1751 PtDlg = pd;
1752 return TRUE;
1753 }
1754
1755 static void CloseProtoDlg(void)
1756 {
1757 if (PtDlg!=NULL)
1758 {
1759 PtDlg->DestroyWindow();
1760 PtDlg = NULL;
1761
1762 ::KillTimer(FileVar->HMainWin,IdProtoTimer);
1763 if ((ProtoId==PROTO_QV) &&
1764 (((PQVVar)ProtoVar)->QVMode==IdQVSend))
1765 CommTextOut(&cv,"\015",1);
1766 if (FileVar->LogFlag)
1767 CloseHandle(FileVar->LogFile);
1768 FileVar->LogFile = 0;
1769 if (ProtoVar!=NULL)
1770 {
1771 free(ProtoVar);
1772 ProtoVar = NULL;
1773 }
1774 }
1775 }
1776
1777 static BOOL ProtoStart(void)
1778 {
1779 if (cv.ProtoFlag)
1780 return FALSE;
1781 if (FSend)
1782 {
1783 FreeFileVar(&FileVar);
1784 return FALSE;
1785 }
1786
1787 if (! LoadTTFILE())
1788 return FALSE;
1789 NewFileVar(&FileVar);
1790
1791 if (FileVar==NULL)
1792 {
1793 FreeTTFILE();
1794 return FALSE;
1795 }
1796 cv.ProtoFlag = TRUE;
1797 return TRUE;
1798 }
1799
1800 void ProtoEnd(void)
1801 {
1802 if (! cv.ProtoFlag)
1803 return;
1804 cv.ProtoFlag = FALSE;
1805
1806 /* Enable transmit delay (serial port) */
1807 cv.DelayFlag = TRUE;
1808 TalkStatus = IdTalkKeyb;
1809
1810 CloseProtoDlg();
1811
1812 if ((FileVar!=NULL) && FileVar->Success)
1813 EndDdeCmnd(1);
1814 else
1815 EndDdeCmnd(0);
1816
1817 FreeTTFILE();
1818 FreeFileVar(&FileVar);
1819 }
1820
1821 /**
1822 * OnIdle()#teraterm.cpp�����R�[��������
1823 * cv.ProtoFlag �� 0 ���O������
1824 * @retval 0 continue
1825 * 1/2 ActiveWin(�O���[�o������)���l(IdVT=1/IdTek=2)
1826 * �� ������������������������
1827 */
1828 int ProtoDlgParse(void)
1829 {
1830 int P;
1831
1832 P = ActiveWin;
1833 if (PtDlg==NULL)
1834 return P;
1835
1836 if ((*ProtoParse)(ProtoId,FileVar,ProtoVar,&cv))
1837 P = 0; /* continue */
1838 else {
1839 CommSend(&cv);
1840 ProtoEnd();
1841 }
1842 return P;
1843 }
1844
1845 void ProtoDlgTimeOut(void)
1846 {
1847 if (PtDlg!=NULL)
1848 (*ProtoTimeOutProc)(ProtoId,FileVar,ProtoVar,&cv);
1849 }
1850
1851 void ProtoDlgCancel(void)
1852 {
1853 if ((PtDlg!=NULL) &&
1854 (*ProtoCancel)(ProtoId,FileVar,ProtoVar,&cv))
1855 ProtoEnd();
1856 }
1857
1858 void KermitStart(int mode)
1859 {
1860 WORD w;
1861
1862 if (! ProtoStart())
1863 return;
1864
1865 switch (mode) {
1866 case IdKmtSend:
1867 FileVar->OpId = OpKmtSend;
1868 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
1869 {
1870 char FileDirExpanded[MAX_PATH];
1871 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
1872 if (!(*GetMultiFname)(FileVar, FileDirExpanded, GMF_KERMIT, &w) ||
1873 (FileVar->NumFname==0))
1874 {
1875 ProtoEnd();
1876 return;
1877 }
1878 }
1879 else
1880 (*SetFileVar)(FileVar);
1881 break;
1882 case IdKmtReceive:
1883 FileVar->OpId = OpKmtRcv;
1884 break;
1885 case IdKmtGet:
1886 FileVar->OpId = OpKmtSend;
1887 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
1888 {
1889 if (! (*GetGetFname)(FileVar->HMainWin,FileVar) ||
1890 (strlen(FileVar->FullName)==0))
1891 {
1892 ProtoEnd();
1893 return;
1894 }
1895 }
1896 else
1897 (*SetFileVar)(FileVar);
1898 break;
1899 case IdKmtFinish:
1900 FileVar->OpId = OpKmtFin;
1901 break;
1902 default:
1903 ProtoEnd();
1904 return;
1905 }
1906 TalkStatus = IdTalkQuiet;
1907
1908 /* disable transmit delay (serial port) */
1909 cv.DelayFlag = FALSE;
1910
1911 if (! OpenProtoDlg(FileVar,PROTO_KMT,mode,0,0))
1912 ProtoEnd();
1913 }
1914
1915 void XMODEMStart(int mode)
1916 {
1917 LONG Option;
1918 int tmp;
1919
1920 if (! ProtoStart())
1921 return;
1922
1923 if (mode==IdXReceive)
1924 FileVar->OpId = OpXRcv;
1925 else
1926 FileVar->OpId = OpXSend;
1927
1928 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
1929 {
1930 char FileDirExpanded[MAX_PATH];
1931 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
1932 Option = MAKELONG(ts.XmodemBin,ts.XmodemOpt);
1933 if (! (*GetXFname)(FileVar->HMainWin,
1934 mode==IdXReceive,&Option,FileVar,FileDirExpanded))
1935 {
1936 ProtoEnd();
1937 return;
1938 }
1939 tmp = HIWORD(Option);
1940 if (mode == IdXReceive) {
1941 if (IsXoptCRC(tmp)) {
1942 if (IsXopt1k(ts.XmodemOpt)) {
1943 ts.XmodemOpt = Xopt1kCRC;
1944 }
1945 else {
1946 ts.XmodemOpt = XoptCRC;
1947 }
1948 }
1949 else {
1950 if (IsXopt1k(ts.XmodemOpt)) {
1951 ts.XmodemOpt = Xopt1kCksum;
1952 }
1953 else {
1954 ts.XmodemOpt = XoptCheck;
1955 }
1956 }
1957 ts.XmodemBin = LOWORD(Option);
1958 }
1959 else {
1960 if (IsXopt1k(tmp)) {
1961 if (IsXoptCRC(ts.XmodemOpt)) {
1962 ts.XmodemOpt = Xopt1kCRC;
1963 }
1964 else {
1965 ts.XmodemOpt = Xopt1kCksum;
1966 }
1967 }
1968 else {
1969 if (IsXoptCRC(ts.XmodemOpt)) {
1970 ts.XmodemOpt = XoptCRC;
1971 }
1972 else {
1973 ts.XmodemOpt = XoptCheck;
1974 }
1975 }
1976 }
1977 }
1978 else
1979 (*SetFileVar)(FileVar);
1980
1981 if (mode==IdXReceive)
1982 FileVar->FileHandle = _lcreat(FileVar->FullName,0);
1983 else
1984 FileVar->FileHandle = _lopen(FileVar->FullName,OF_READ);
1985
1986 FileVar->FileOpen = FileVar->FileHandle != INVALID_HANDLE_VALUE;
1987 if (! FileVar->FileOpen)
1988 {
1989 ProtoEnd();
1990 return;
1991 }
1992 TalkStatus = IdTalkQuiet;
1993
1994 /* disable transmit delay (serial port) */
1995 cv.DelayFlag = FALSE;
1996
1997 if (! OpenProtoDlg(FileVar,PROTO_XM,mode,
1998 ts.XmodemOpt,ts.XmodemBin))
1999 ProtoEnd();
2000 }
2001
2002 void YMODEMStart(int mode)
2003 {
2004 WORD Opt;
2005
2006 if (! ProtoStart())
2007 return;
2008
2009 if (mode==IdYSend)
2010 {
2011 char FileDirExpanded[MAX_PATH];
2012 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
2013
2014 // �t�@�C���]�������I�v�V������"Yopt1K"�����������B
2015 // TODO: "Yopt1K", "YoptG", "YoptSingle"�������������������AIDD_FOPT���g�������K�v�����B
2016 Opt = Yopt1K;
2017 FileVar->OpId = OpYSend;
2018 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
2019 {
2020 if (! (*GetMultiFname)(FileVar,FileDirExpanded,GMF_Y,&Opt) ||
2021 (FileVar->NumFname==0))
2022 {
2023 ProtoEnd();
2024 return;
2025 }
2026 //ts.XmodemBin = Opt;
2027 }
2028 else
2029 (*SetFileVar)(FileVar);
2030 }
2031 else {
2032 FileVar->OpId = OpYRcv;
2033 // �t�@�C���]�������I�v�V������"Yopt1K"�����������B
2034 Opt = Yopt1K;
2035 (*SetFileVar)(FileVar);
2036 }
2037
2038 TalkStatus = IdTalkQuiet;
2039
2040 /* disable transmit delay (serial port) */
2041 cv.DelayFlag = FALSE;
2042
2043 if (! OpenProtoDlg(FileVar,PROTO_YM,mode,Opt,0))
2044 ProtoEnd();
2045 }
2046
2047 void ZMODEMStart(int mode)
2048 {
2049 WORD Opt;
2050
2051 if (! ProtoStart())
2052 return;
2053
2054 if (mode == IdZSend || mode == IdZAutoS)
2055 {
2056 Opt = ts.XmodemBin;
2057 FileVar->OpId = OpZSend;
2058 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
2059 {
2060 char FileDirExpanded[MAX_PATH];
2061 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
2062 if (! (*GetMultiFname)(FileVar,FileDirExpanded,GMF_Z,&Opt) ||
2063 (FileVar->NumFname==0))
2064 {
2065 if (mode == IdZAutoS) {
2066 CommRawOut(&cv, "\030\030\030\030\030\030\030\030\b\b\b\b\b\b\b\b\b\b", 18);
2067 }
2068 ProtoEnd();
2069 return;
2070 }
2071 ts.XmodemBin = Opt;
2072 }
2073 else
2074 (*SetFileVar)(FileVar);
2075 }
2076 else /* IdZReceive or IdZAutoR */
2077 FileVar->OpId = OpZRcv;
2078
2079 TalkStatus = IdTalkQuiet;
2080
2081 /* disable transmit delay (serial port) */
2082 cv.DelayFlag = FALSE;
2083
2084 if (! OpenProtoDlg(FileVar,PROTO_ZM,mode,Opt,0))
2085 ProtoEnd();
2086 }
2087
2088 void BPStart(int mode)
2089 {
2090 LONG Option = 0;
2091
2092 if (! ProtoStart())
2093 return;
2094 if (mode==IdBPSend)
2095 {
2096 FileVar->OpId = OpBPSend;
2097 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
2098 {
2099 char FileDirExpanded[MAX_PATH];
2100 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
2101 FileVar->FullName[0] = 0;
2102 if (! (*GetTransFname)(FileVar, FileDirExpanded, GTF_BP, &Option))
2103 {
2104 ProtoEnd();
2105 return;
2106 }
2107 }
2108 else
2109 (*SetFileVar)(FileVar);
2110 }
2111 else /* IdBPReceive or IdBPAuto */
2112 FileVar->OpId = OpBPRcv;
2113
2114 TalkStatus = IdTalkQuiet;
2115
2116 /* disable transmit delay (serial port) */
2117 cv.DelayFlag = FALSE;
2118
2119 if (! OpenProtoDlg(FileVar,PROTO_BP,mode,0,0))
2120 ProtoEnd();
2121 }
2122
2123 void QVStart(int mode)
2124 {
2125 WORD W;
2126
2127 if (! ProtoStart())
2128 return;
2129
2130 if (mode==IdQVSend)
2131 {
2132 FileVar->OpId = OpQVSend;
2133 if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0)
2134 {
2135 char FileDirExpanded[MAX_PATH];
2136 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
2137 if (! (*GetMultiFname)(FileVar,FileDirExpanded,GMF_QV, &W) ||
2138 (FileVar->NumFname==0))
2139 {
2140 ProtoEnd();
2141 return;
2142 }
2143 }
2144 else
2145 (*SetFileVar)(FileVar);
2146 }
2147 else
2148 FileVar->OpId = OpQVRcv;
2149
2150 TalkStatus = IdTalkQuiet;
2151
2152 /* disable transmit delay (serial port) */
2153 cv.DelayFlag = FALSE;
2154
2155 if (! OpenProtoDlg(FileVar,PROTO_QV,mode,0,0))
2156 ProtoEnd();
2157 }
2158
2159 /**
2160 * ���O���[�e�[�g������
2161 * ���O���T�C�Y��<size>�o�C�g���������������A���[�e�[�V��������������������
2162 */
2163 void FLogRotateSize(size_t size)
2164 {
2165 if (LogVar == NULL) {
2166 return;
2167 }
2168 LogVar->RotateMode = ROTATE_SIZE;
2169 LogVar->RotateSize = size;
2170 }
2171
2172 /**
2173 * ���O���[�e�[�g������
2174 * ���O�t�@�C������������������
2175 */
2176 void FLogRotateRotate(int step)
2177 {
2178 if (LogVar == NULL) {
2179 return;
2180 }
2181 LogVar->RotateStep = step;
2182 }
2183
2184 /**
2185 * ���O���[�e�[�g������
2186 * ���[�e�[�V���������~
2187 */
2188 void FLogRotateHalt(void)
2189 {
2190 if (LogVar == NULL) {
2191 return;
2192 }
2193 LogVar->RotateMode = ROTATE_NONE;
2194 LogVar->RotateSize = 0;
2195 LogVar->RotateStep = 0;
2196 }
2197
2198 static INT_PTR CALLBACK OnCommentDlgProc(HWND hDlgWnd, UINT msg, WPARAM wp, LPARAM lp)
2199 {
2200 static const DlgTextInfo TextInfos[] = {
2201 { 0, "DLG_COMMENT_TITLE" },
2202 { IDOK, "BTN_OK" }
2203 };
2204 char buf[256];
2205 UINT ret;
2206
2207 switch (msg) {
2208 case WM_INITDIALOG:
2209 //SetDlgItemText(hDlgWnd, IDC_EDIT_COMMENT, "�T���v��");
2210 // �G�f�B�b�g�R���g���[�����t�H�[�J�X��������
2211 SetFocus(GetDlgItem(hDlgWnd, IDC_EDIT_COMMENT));
2212 SetDlgTexts(hDlgWnd, TextInfos, _countof(TextInfos), ts.UILanguageFile);
2213 return FALSE;
2214
2215 case WM_COMMAND:
2216 switch (LOWORD(wp)) {
2217 case IDOK:
2218 memset(buf, 0, sizeof(buf));
2219 ret = GetDlgItemTextA(hDlgWnd, IDC_EDIT_COMMENT, buf, sizeof(buf) - 1);
2220 if (ret > 0) { // �e�L�X�g��������
2221 //buf[sizeof(buf) - 1] = '\0'; // null-terminate
2222 CommentLogToFile(buf, ret);
2223 }
2224 TTEndDialog(hDlgWnd, IDOK);
2225 break;
2226 default:
2227 return FALSE;
2228 }
2229 break;
2230 case WM_CLOSE:
2231 TTEndDialog(hDlgWnd, 0);
2232 return TRUE;
2233
2234 default:
2235 return FALSE;
2236 }
2237 return TRUE;
2238 }
2239
2240 void FLogAddCommentDlg(HINSTANCE hInst, HWND hWnd)
2241 {
2242 // ���O�t�@�C�����R�����g���������� (2004.8.6 yutaka)
2243 TTDialogBox(hInst, MAKEINTRESOURCE(IDD_COMMENT_DIALOG),
2244 HVTWin, OnCommentDlgProc);
2245 }
2246
2247 void FLogClose(void)
2248 {
2249 if (LogVar != NULL)
2250 FileTransEnd(OpLog);
2251 }
2252
2253 BOOL FLogOpen(const char *fname)
2254 {
2255 BOOL ret;
2256
2257 if ((LogVar==NULL) && !NewFileVar(&LogVar)) {
2258 return FALSE;
2259 }
2260
2261 LogVar->DirLen = 0;
2262 LogVar->NoMsg = TRUE;
2263 strncpy_s(LogVar->FullName, sizeof(LogVar->FullName), fname, _TRUNCATE);
2264 ret = LogStart();
2265 return ret;
2266 }
2267
2268 BOOL FLogIsOpend(void)
2269 {
2270 // LogVar->FileOpen
2271 return LogVar != NULL;
2272 }
2273
2274 void FLogWriteStr(const char *str)
2275 {
2276 if (LogVar != NULL)
2277 {
2278 DWORD wrote;
2279 size_t len = strlen(str);
2280 WriteFile(LogVar->FileHandle, str, len, &wrote, NULL);
2281 LogVar->ByteCount =
2282 LogVar->ByteCount + len;
2283 if (FLogDlg!=NULL)
2284 FLogDlg->RefreshNum();
2285 }
2286 }
2287
2288 void FLogInfo(char *param_ptr, size_t param_len)
2289 {
2290 if (LogVar) {
2291 param_ptr[0] = '0'
2292 + (ts.LogBinary != 0)
2293 + ((ts.Append != 0) << 1)
2294 + ((ts.LogTypePlainText != 0) << 2)
2295 + ((ts.LogTimestamp != 0) << 3)
2296 + ((ts.LogHideDialog != 0) << 4);
2297 strncpy_s(param_ptr + 1, param_len - 1, LogVar->FullName, _TRUNCATE);
2298 }
2299 else {
2300 param_ptr[0] = '0' - 1;
2301 param_ptr[1] = 0;
2302 }
2303 }
2304
2305 /**
2306 * ���������O�t�@�C����������
2307 */
2308 const char *FLogGetFilename()
2309 {
2310 if (LogVar == NULL) {
2311 return NULL;
2312 }
2313 return LogVar->FullName;
2314 }
2315
2316 /**
2317 * ���O�_�C�A���O���J��
2318 * @param[in,out] info.filename �t�@�C���������l
2319 * OK���A�t�@�C�����A�s�v����������free()��������
2320 * @retval TRUE [ok] ����������
2321 * @retval FALSE �L�����Z��������
2322 */
2323 BOOL FLogOpenDialog(HINSTANCE hInst, HWND hWnd, FLogDlgInfo_t *info)
2324 {
2325 LogDlgWork_t *work = (LogDlgWork_t *)calloc(sizeof(LogDlgWork_t), 1);
2326 char *filenameA = ToCharW(info->filename);
2327 char *srcfnameA = FLogGetLogFilename(filenameA);
2328 wchar_t *srcfnameW = ToWcharA(srcfnameA);
2329 free(filenameA);
2330 free(srcfnameA);
2331 work->info = info;
2332 work->info->filename = srcfnameW;
2333 work->pts = &ts;
2334 INT_PTR ret = TTDialogBoxParam(
2335 hInst, MAKEINTRESOURCE(IDD_LOGDLG),
2336 hWnd, LogFnHook, (LPARAM)work);
2337 free(srcfnameW);
2338 free(work);
2339 return ret == IDOK ? TRUE : FALSE;
2340 }
2341
2342 /**
2343 * ���O�t�@�C����������
2344 * ���O�t�@�C�����p���C�����s��
2345 * - strftime() ���������t�W�J
2346 * - �������������O�t�@�C���t�H���_������
2347 * - �z�X�g��,�|�[�g�����W�J
2348 *
2349 * @param[in] log_filename �t�@�C����(����/��������������ok)
2350 * NULL�������f�t�H���g�t�@�C����������
2351 * strftime�`��ok
2352 * @return �t���p�X�t�@�C����
2353 * �s�v���������� free() ��������
2354 */
2355 char *FLogGetLogFilename(const char *log_filename)
2356 {
2357 // �t�H���_
2358 char FileDirExpanded[MAX_PATH];
2359 char *logdir;
2360 if (strlen(ts.LogDefaultPath) > 0) {
2361 logdir = ts.LogDefaultPath;
2362 }
2363 else if (strlen(ts.FileDir) > 0) {
2364 ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded));
2365 logdir = FileDirExpanded;
2366 }
2367 else {
2368 logdir = ts.HomeDir;
2369 }
2370
2371 // ���������t�@�C����
2372 char base_name[MAX_PATH];
2373 if (log_filename == NULL) {
2374 strncpy_s(base_name, _countof(base_name), ts.LogDefaultName, _TRUNCATE);
2375 }
2376 else {
2377 strncpy_s(base_name, _countof(base_name), log_filename, _TRUNCATE);
2378 }
2379
2380 // �t���p�X��
2381 char full_path[MAX_PATH];
2382 ConvFName(logdir, base_name, sizeof(base_name), "", full_path, sizeof(full_path));
2383 ParseStrftimeFileName(full_path, sizeof(full_path));
2384 ConvertLogname(full_path, sizeof(full_path));
2385
2386 return _strdup(full_path);
2387 }
2388
2389 BOOL FLogIsPause()
2390 {
2391 return ((cv.FilePause & OpLog) !=0);
2392 }
2393
2394 void FLogWindow(int nCmdShow)
2395 {
2396 if (FLogDlg == NULL)
2397 return;
2398
2399 HWND HWndLog = FLogDlg->m_hWnd;
2400 ShowWindow(HWndLog, nCmdShow);
2401 if (nCmdShow == SW_RESTORE) {
2402 // �g���X�^�C�� WS_EX_NOACTIVATE ��������������
2403 SetForegroundWindow(HWndLog);
2404 }
2405 }
2406
2407 void FLogShowDlg(void)
2408 {
2409 ShowFTDlg(OpLog);
2410 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help