| 1 |
/* |
| 2 |
* (C) 2020 TeraTerm Project |
| 3 |
* All rights reserved. |
| 4 |
* |
| 5 |
* Redistribution and use in source and binary forms, with or without |
| 6 |
* modification, are permitted provided that the following conditions |
| 7 |
* are met: |
| 8 |
* |
| 9 |
* 1. Redistributions of source code must retain the above copyright |
| 10 |
* notice, this list of conditions and the following disclaimer. |
| 11 |
* 2. Redistributions in binary form must reproduce the above copyright |
| 12 |
* notice, this list of conditions and the following disclaimer in the |
| 13 |
* documentation and/or other materials provided with the distribution. |
| 14 |
* 3. The name of the author may not be used to endorse or promote products |
| 15 |
* derived from this software without specific prior written permission. |
| 16 |
* |
| 17 |
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR |
| 18 |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| 19 |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| 20 |
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 21 |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 22 |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 23 |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 24 |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 25 |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 26 |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 |
*/ |
| 28 |
|
| 29 |
/* TERATERM.EXE, log routines */ |
| 30 |
#include <stdio.h> |
| 31 |
#if !defined(_CRTDBG_MAP_ALLOC) |
| 32 |
#define _CRTDBG_MAP_ALLOC |
| 33 |
#endif |
| 34 |
#include <stdlib.h> |
| 35 |
#include <crtdbg.h> |
| 36 |
#include <process.h> |
| 37 |
#include <windows.h> |
| 38 |
#include <htmlhelp.h> |
| 39 |
#include <assert.h> |
| 40 |
|
| 41 |
#include "teraterm.h" |
| 42 |
#include "tttypes.h" |
| 43 |
#include "ttftypes.h" |
| 44 |
#include "ftdlg.h" |
| 45 |
#include "ttwinman.h" |
| 46 |
#include "commlib.h" |
| 47 |
#include "ttcommon.h" |
| 48 |
#include "ttlib.h" |
| 49 |
#include "dlglib.h" |
| 50 |
#include "vtterm.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 |
#include "asprintf.h" |
| 58 |
|
| 59 |
#include "filesys_log_res.h" |
| 60 |
#include "filesys_log.h" |
| 61 |
|
| 62 |
/* |
| 63 |
Line Head flag for timestamping |
| 64 |
2007.05.24 Gentaro |
| 65 |
*/ |
| 66 |
enum enumLineEnd { |
| 67 |
Line_Other = 0, |
| 68 |
Line_LineHead = 1, |
| 69 |
Line_FileHead = 2, |
| 70 |
}; |
| 71 |
|
| 72 |
typedef struct { |
| 73 |
wchar_t *FullName; |
| 74 |
wchar_t *FileName; |
| 75 |
|
| 76 |
HANDLE FileHandle; |
| 77 |
LONG FileSize, ByteCount; |
| 78 |
|
| 79 |
DWORD StartTime; |
| 80 |
|
| 81 |
enum enumLineEnd eLineEnd; |
| 82 |
|
| 83 |
// log rotate |
| 84 |
int RotateMode; // enum rotate_mode RotateMode; |
| 85 |
LONG RotateSize; |
| 86 |
int RotateStep; |
| 87 |
|
| 88 |
HANDLE LogThread; |
| 89 |
DWORD LogThreadId; |
| 90 |
HANDLE LogThreadEvent; |
| 91 |
|
| 92 |
BOOL IsPause; |
| 93 |
|
| 94 |
PFileTransDlg FLogDlg; |
| 95 |
|
| 96 |
int log_code; |
| 97 |
|
| 98 |
} TFileVar_; |
| 99 |
typedef TFileVar_ *PFileVar_; |
| 100 |
|
| 101 |
#define PFileVar PFileVar_ |
| 102 |
#define TFileVar TFileVar_ |
| 103 |
|
| 104 |
static PFileVar LogVar = NULL; |
| 105 |
|
| 106 |
static BOOL FileLog = FALSE; |
| 107 |
static BOOL BinLog = FALSE; |
| 108 |
|
| 109 |
static PCHAR cv_LogBuf; |
| 110 |
static int cv_LogPtr, cv_LStart, cv_LCount; |
| 111 |
static PCHAR cv_BinBuf; |
| 112 |
static int cv_BinPtr, cv_BStart, cv_BCount; |
| 113 |
static int cv_BinSkip; |
| 114 |
|
| 115 |
// �x�����������p�X���b�h�����b�Z�[�W |
| 116 |
#define WM_DPC_LOGTHREAD_SEND (WM_APP + 1) |
| 117 |
|
| 118 |
static void FileTransEnd_(void); |
| 119 |
static void Log1Bin(BYTE b); |
| 120 |
static void LogBinSkip(int add); |
| 121 |
static BOOL CreateLogBuf(void); |
| 122 |
static BOOL CreateBinBuf(void); |
| 123 |
void LogPut1(BYTE b); |
| 124 |
static void OutputStr(const wchar_t *str); |
| 125 |
|
| 126 |
static BOOL OpenFTDlg_(PFileVar fv) |
| 127 |
{ |
| 128 |
PFileTransDlg FTDlg = new CFileTransDlg(); |
| 129 |
if (FTDlg == NULL) { |
| 130 |
return FALSE; |
| 131 |
} |
| 132 |
|
| 133 |
wchar_t *DlgCaption; |
| 134 |
wchar_t uimsg[MAX_UIMSG]; |
| 135 |
#define TitLogW L"Log" |
| 136 |
get_lang_msgW("FILEDLG_TRANS_TITLE_LOG", uimsg, _countof(uimsg), TitLogW, ts.UILanguageFile); |
| 137 |
aswprintf(&DlgCaption, L"Tera Term: %s", uimsg); |
| 138 |
|
| 139 |
CFileTransDlgInfo info; |
| 140 |
info.UILanguageFile = ts.UILanguageFile; |
| 141 |
info.OpId = OpLog; |
| 142 |
info.DlgCaption = DlgCaption; |
| 143 |
info.FileName = fv->FileName; |
| 144 |
info.FullName = fv->FullName; |
| 145 |
info.HideDialog = ts.LogHideDialog ? TRUE : FALSE; |
| 146 |
info.HMainWin = HVTWin; |
| 147 |
FTDlg->Create(hInst, &info); |
| 148 |
FTDlg->RefreshNum(0, fv->FileSize, fv->ByteCount); |
| 149 |
|
| 150 |
fv->FLogDlg = FTDlg; |
| 151 |
|
| 152 |
free(DlgCaption); |
| 153 |
return TRUE; |
| 154 |
} |
| 155 |
|
| 156 |
/** |
| 157 |
* �t�@�C�������������u������ |
| 158 |
* &h �z�X�g�����u�� (2007.5.14) |
| 159 |
* &p TCP�|�[�g�������u�� (2009.6.12) |
| 160 |
* &u ���O�I���������[�U�� |
| 161 |
*/ |
| 162 |
static void ConvertLogname(char *c, int destlen) |
| 163 |
{ |
| 164 |
char buf[MAXPATHLEN], buf2[MAXPATHLEN], *p = c; |
| 165 |
char tmphost[1024]; |
| 166 |
char tmpuser[256+1]; |
| 167 |
DWORD len_user = sizeof(tmpuser); |
| 168 |
|
| 169 |
memset(buf, 0, sizeof(buf)); |
| 170 |
|
| 171 |
while(*p != '\0') { |
| 172 |
if (*p == '&' && *(p+1) != '\0') { |
| 173 |
switch (*(p+1)) { |
| 174 |
case 'h': |
| 175 |
if (cv.Open) { |
| 176 |
if (cv.PortType == IdTCPIP) { |
| 177 |
// �z�X�g����IPv6�A�h���X�����A�t�@�C�������g�p�����������������������A |
| 178 |
// �]�v�����������������B |
| 179 |
// (2013.3.9 yutaka) |
| 180 |
strncpy_s(tmphost, sizeof(tmphost), ts.HostName, _TRUNCATE); |
| 181 |
//strncpy_s(tmphost, sizeof(tmphost), "2001:0db8:bd05:01d2:288a:1fc0:0001:10ee", _TRUNCATE); |
| 182 |
replaceInvalidFileNameChar(tmphost, '_'); |
| 183 |
strncat_s(buf,sizeof(buf), tmphost, _TRUNCATE); |
| 184 |
} |
| 185 |
else if (cv.PortType == IdSerial) { |
| 186 |
strncpy_s(buf2,sizeof(buf2),buf,_TRUNCATE); |
| 187 |
_snprintf_s(buf, sizeof(buf), _TRUNCATE, "%sCOM%d", buf2, ts.ComPort); |
| 188 |
} |
| 189 |
} |
| 190 |
break; |
| 191 |
case 'p': |
| 192 |
if (cv.Open) { |
| 193 |
if (cv.PortType == IdTCPIP) { |
| 194 |
char port[6]; |
| 195 |
_snprintf_s(port, sizeof(port), _TRUNCATE, "%d", ts.TCPPort); |
| 196 |
strncat_s(buf,sizeof(buf),port,_TRUNCATE); |
| 197 |
} |
| 198 |
} |
| 199 |
break; |
| 200 |
case 'u': |
| 201 |
if (GetUserName(tmpuser, &len_user) != 0) { |
| 202 |
strncat_s(buf,sizeof(buf),tmpuser,_TRUNCATE); |
| 203 |
} |
| 204 |
break; |
| 205 |
default: |
| 206 |
strncpy_s(buf2,sizeof(buf2),p,2); |
| 207 |
strncat_s(buf,sizeof(buf),buf2,_TRUNCATE); |
| 208 |
} |
| 209 |
p++; |
| 210 |
} |
| 211 |
else { |
| 212 |
strncpy_s(buf2,sizeof(buf2),p,1); |
| 213 |
strncat_s(buf,sizeof(buf),buf2,_TRUNCATE); |
| 214 |
} |
| 215 |
p++; |
| 216 |
} |
| 217 |
strncpy_s(c, destlen, buf, _TRUNCATE); |
| 218 |
} |
| 219 |
|
| 220 |
static void FixLogOption(void) |
| 221 |
{ |
| 222 |
if (ts.LogBinary) { |
| 223 |
ts.LogTypePlainText = false; |
| 224 |
ts.LogTimestamp = false; |
| 225 |
} |
| 226 |
} |
| 227 |
|
| 228 |
|
| 229 |
// �X���b�h���I�����t�@�C�����N���[�Y |
| 230 |
static void CloseFileSync(PFileVar ptr) |
| 231 |
{ |
| 232 |
BOOL ret; |
| 233 |
|
| 234 |
if (ptr->FileHandle == INVALID_HANDLE_VALUE) { |
| 235 |
return; |
| 236 |
} |
| 237 |
|
| 238 |
if (ptr->LogThread != INVALID_HANDLE_VALUE) { |
| 239 |
// �X���b�h���I������ |
| 240 |
ret = PostThreadMessage(ptr->LogThreadId, WM_QUIT, 0, 0); |
| 241 |
if (ret != 0) { |
| 242 |
// �X���b�h�L���[���G���L���[���������������������������s���B |
| 243 |
WaitForSingleObject(ptr->LogThread, INFINITE); |
| 244 |
} |
| 245 |
else { |
| 246 |
//DWORD code = GetLastError(); |
| 247 |
} |
| 248 |
CloseHandle(ptr->LogThread); |
| 249 |
ptr->LogThread = INVALID_HANDLE_VALUE; |
| 250 |
} |
| 251 |
CloseHandle(ptr->FileHandle); |
| 252 |
ptr->FileHandle = INVALID_HANDLE_VALUE; |
| 253 |
} |
| 254 |
|
| 255 |
// �x�����������p�X���b�h |
| 256 |
static unsigned _stdcall DeferredLogWriteThread(void *arg) |
| 257 |
{ |
| 258 |
MSG msg; |
| 259 |
PFileVar fv = (PFileVar)arg; |
| 260 |
PCHAR buf; |
| 261 |
DWORD buflen; |
| 262 |
DWORD wrote; |
| 263 |
|
| 264 |
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE); |
| 265 |
|
| 266 |
// �X���b�h�L���[���������I�������������X���b�h�����������m�����B |
| 267 |
if (fv->LogThreadEvent != NULL) { |
| 268 |
SetEvent(fv->LogThreadEvent); |
| 269 |
} |
| 270 |
|
| 271 |
while (GetMessage(&msg, NULL, 0, 0) > 0) { |
| 272 |
switch (msg.message) { |
| 273 |
case WM_DPC_LOGTHREAD_SEND: |
| 274 |
buf = (PCHAR)msg.wParam; |
| 275 |
buflen = (DWORD)msg.lParam; |
| 276 |
WriteFile(LogVar->FileHandle, buf, buflen, &wrote, NULL); |
| 277 |
free(buf); // ���������������� |
| 278 |
break; |
| 279 |
|
| 280 |
case WM_QUIT: |
| 281 |
goto end; |
| 282 |
break; |
| 283 |
} |
| 284 |
} |
| 285 |
|
| 286 |
end: |
| 287 |
_endthreadex(0); |
| 288 |
return (0); |
| 289 |
} |
| 290 |
|
| 291 |
// �x�����������p�X���b�h���N�����B |
| 292 |
// (2013.4.19 yutaka) |
| 293 |
// DeferredLogWriteThread �X���b�h���N�������A�X���b�h�L���[�����������������O���A |
| 294 |
// ���O�t�@�C�����N���[�Y(CloseFileSync)���s���������A�G���L���[�����s���A�f�b�h���b�N |
| 295 |
// �����������������C�������B |
| 296 |
// �X���b�h�����������s�������A���O�����C�x���g�I�u�W�F�N�g���g�����A�X���b�h�L���[�� |
| 297 |
// ���������������������������������B���O�t���C�x���g�I�u�W�F�N�g���g���������A |
| 298 |
// �V�X�e��(Windows OS)�������j�[�N�����O�������K�v�������B |
| 299 |
// (2016.9.23 yutaka) |
| 300 |
static void StartThread(PFileVar fv) |
| 301 |
{ |
| 302 |
unsigned tid; |
| 303 |
fv->LogThreadEvent = CreateEvent(NULL, TRUE, FALSE, NULL); |
| 304 |
fv->LogThread = (HANDLE)_beginthreadex(NULL, 0, DeferredLogWriteThread, fv, 0, &tid); |
| 305 |
fv->LogThreadId = tid; |
| 306 |
if (fv->LogThreadEvent != NULL) { |
| 307 |
WaitForSingleObject(fv->LogThreadEvent, INFINITE); |
| 308 |
CloseHandle(fv->LogThreadEvent); |
| 309 |
} |
| 310 |
} |
| 311 |
|
| 312 |
/** |
| 313 |
* �_�C�A���O�����e�� ts ���������� |
| 314 |
* |
| 315 |
* TODO |
| 316 |
* �_�C�A���O�����������l�������I�������� |
| 317 |
* ����������������������������������������������? |
| 318 |
*/ |
| 319 |
static void SetLogFlags(HWND Dialog) |
| 320 |
{ |
| 321 |
WORD BinFlag, val; |
| 322 |
|
| 323 |
GetRB(Dialog, &BinFlag, IDC_FOPTBIN, IDC_FOPTBIN); |
| 324 |
ts.LogBinary = BinFlag; |
| 325 |
|
| 326 |
GetRB(Dialog, &val, IDC_APPEND, IDC_APPEND); |
| 327 |
ts.Append = val; |
| 328 |
|
| 329 |
if (!BinFlag) { |
| 330 |
GetRB(Dialog, &val, IDC_PLAINTEXT, IDC_PLAINTEXT); |
| 331 |
ts.LogTypePlainText = val; |
| 332 |
|
| 333 |
GetRB(Dialog, &val, IDC_TIMESTAMP, IDC_TIMESTAMP); |
| 334 |
ts.LogTimestamp = val; |
| 335 |
} |
| 336 |
|
| 337 |
GetRB(Dialog, &val, IDC_HIDEDIALOG, IDC_HIDEDIALOG); |
| 338 |
ts.LogHideDialog = val; |
| 339 |
|
| 340 |
GetRB(Dialog, &val, IDC_ALLBUFF_INFIRST, IDC_ALLBUFF_INFIRST); |
| 341 |
ts.LogAllBuffIncludedInFirst = val; |
| 342 |
|
| 343 |
ts.LogTimestampType = (GetCurSel(Dialog, IDC_TIMESTAMPTYPE) - 1); |
| 344 |
} |
| 345 |
|
| 346 |
/** |
| 347 |
* ���O�t�@�C���`�F�b�N |
| 348 |
* |
| 349 |
* @param[in] filename |
| 350 |
* @param[out] exist TURE/FALSE |
| 351 |
* @param[out] bom 0 no BOM (or file not exist) |
| 352 |
* 1 UTF-8 |
| 353 |
* 2 UTF-16LE |
| 354 |
* 3 UTF-16BE |
| 355 |
*/ |
| 356 |
static void CheckLogFile(const wchar_t *filename, BOOL *exist, int *bom) |
| 357 |
{ |
| 358 |
*exist = FALSE; |
| 359 |
*bom = 0; |
| 360 |
|
| 361 |
// �t�@�C������������? |
| 362 |
DWORD logdir = _GetFileAttributesW(filename); |
| 363 |
if ((logdir != INVALID_FILE_ATTRIBUTES) && ((logdir & FILE_ATTRIBUTE_DIRECTORY) == 0)) { |
| 364 |
// �t�@�C���������� |
| 365 |
*exist = TRUE; |
| 366 |
|
| 367 |
// BOM�L��/�����`�F�b�N |
| 368 |
FILE *fp = __wfopen(filename, L"rb"); |
| 369 |
if (fp != NULL) { |
| 370 |
unsigned char tmp[4]; |
| 371 |
size_t l = fread(tmp, 1, sizeof(tmp), fp); |
| 372 |
fclose(fp); |
| 373 |
if (l < 2) { |
| 374 |
*bom = 0; |
| 375 |
} else if (l >= 2 && tmp[0] == 0xff && tmp[1] == 0xfe) { |
| 376 |
// UTF-16LE |
| 377 |
*bom = 2; |
| 378 |
} else if (l >= 2 && tmp[0] == 0xfe && tmp[1] == 0xff) { |
| 379 |
// UTF-16BE |
| 380 |
*bom = 3; |
| 381 |
} else if (l >= 3 && tmp[0] == 0xef && tmp[1] == 0xbb && tmp[2] == 0xbf) { |
| 382 |
// UTF-8 |
| 383 |
*bom = 1; |
| 384 |
} else { |
| 385 |
*bom = 0; |
| 386 |
} |
| 387 |
} |
| 388 |
} |
| 389 |
} |
| 390 |
|
| 391 |
typedef struct { |
| 392 |
FLogDlgInfo_t *info; |
| 393 |
// work |
| 394 |
BOOL file_exist; |
| 395 |
int current_bom; |
| 396 |
TTTSet *pts; |
| 397 |
} LogDlgWork_t; |
| 398 |
|
| 399 |
static void ArrangeControls(HWND Dialog, LogDlgWork_t *work) |
| 400 |
{ |
| 401 |
if (work->file_exist) { |
| 402 |
EnableWindow(GetDlgItem(Dialog, IDC_APPEND), TRUE); |
| 403 |
if (work->pts->Append > 0) { |
| 404 |
CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_APPEND); |
| 405 |
} |
| 406 |
} |
| 407 |
else { |
| 408 |
// �t�@�C�������� -> �V�K |
| 409 |
EnableWindow(GetDlgItem(Dialog, IDC_APPEND), FALSE); |
| 410 |
CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_NEW_OVERWRITE); |
| 411 |
} |
| 412 |
|
| 413 |
if (work->file_exist && IsDlgButtonChecked(Dialog, IDC_APPEND) == BST_CHECKED) { |
| 414 |
// �t�@�C������������ && append |
| 415 |
int bom = work->current_bom; |
| 416 |
if (bom != 0) { |
| 417 |
// BOM�L�� |
| 418 |
CheckDlgButton(Dialog, IDC_BOM, BST_CHECKED); |
| 419 |
int cur = |
| 420 |
bom == 1 ? 0 : |
| 421 |
bom == 2 ? 1 : |
| 422 |
bom == 3 ? 2 : 0; |
| 423 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, cur, 0); |
| 424 |
} |
| 425 |
else { |
| 426 |
// BOM���� |
| 427 |
CheckDlgButton(Dialog, IDC_BOM, BST_UNCHECKED); |
| 428 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0); |
| 429 |
} |
| 430 |
if (IsDlgButtonChecked(Dialog, IDC_FOPTTEXT) == BST_CHECKED) { |
| 431 |
EnableWindow(GetDlgItem(Dialog, IDC_BOM), FALSE); |
| 432 |
if (bom != 0) { |
| 433 |
// BOM�L�� |
| 434 |
EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), FALSE); |
| 435 |
} |
| 436 |
else { |
| 437 |
// BOM���� |
| 438 |
EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), TRUE); |
| 439 |
} |
| 440 |
} |
| 441 |
} |
| 442 |
else { |
| 443 |
// �t�@�C�������� ���� append��������(������) |
| 444 |
CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_NEW_OVERWRITE); |
| 445 |
CheckDlgButton(Dialog, IDC_BOM, BST_CHECKED); |
| 446 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0); |
| 447 |
if (IsDlgButtonChecked(Dialog, IDC_FOPTTEXT) == BST_CHECKED) { |
| 448 |
EnableWindow(GetDlgItem(Dialog, IDC_BOM), TRUE); |
| 449 |
} |
| 450 |
} |
| 451 |
} |
| 452 |
|
| 453 |
static void CheckLogFile(HWND Dialog, const wchar_t *filename, LogDlgWork_t *work) |
| 454 |
{ |
| 455 |
BOOL exist; |
| 456 |
int bom; |
| 457 |
CheckLogFile(filename, &exist, &bom); |
| 458 |
work->file_exist = exist; |
| 459 |
work->current_bom = bom; |
| 460 |
ArrangeControls(Dialog, work); |
| 461 |
} |
| 462 |
|
| 463 |
static INT_PTR CALLBACK LogFnHook(HWND Dialog, UINT Message, WPARAM wParam, LPARAM lParam) |
| 464 |
{ |
| 465 |
static const DlgTextInfo TextInfos[] = { |
| 466 |
{ 0, "DLG_TABSHEET_TITLE_LOG" }, |
| 467 |
{ IDC_FOPTBIN, "DLG_FOPT_BINARY" }, |
| 468 |
{ IDC_APPEND, "DLG_FOPT_APPEND" }, |
| 469 |
{ IDC_PLAINTEXT, "DLG_FOPT_PLAIN" }, |
| 470 |
{ IDC_HIDEDIALOG, "DLG_FOPT_HIDEDIALOG" }, |
| 471 |
{ IDC_ALLBUFF_INFIRST, "DLG_FOPT_ALLBUFFINFIRST" }, |
| 472 |
{ IDC_TIMESTAMP, "DLG_FOPT_TIMESTAMP" }, |
| 473 |
}; |
| 474 |
static const I18nTextInfo timestamp_list[] = { |
| 475 |
{ "DLG_FOPT_TIMESTAMP_LOCAL", L"Local Time" }, |
| 476 |
{ "DLG_FOPT_TIMESTAMP_UTC", L"UTC" }, |
| 477 |
{ "DLG_FOPT_TIMESTAMP_ELAPSED_LOGGING", L"Elapsed Time (Logging)" }, |
| 478 |
{ "DLG_FOPT_TIMESTAMP_ELAPSED_CONNECTION", L"Elapsed Time (Connection)" }, |
| 479 |
}; |
| 480 |
LogDlgWork_t *work = (LogDlgWork_t *)GetWindowLongPtr(Dialog, DWLP_USER); |
| 481 |
|
| 482 |
if (Message == RegisterWindowMessage(HELPMSGSTRING)) { |
| 483 |
// �R�����_�C�A���O�������w���v���b�Z�[�W���t�������� |
| 484 |
Message = WM_COMMAND; |
| 485 |
wParam = IDHELP; |
| 486 |
} |
| 487 |
switch (Message) { |
| 488 |
case WM_INITDIALOG: { |
| 489 |
work = (LogDlgWork_t *)lParam; |
| 490 |
TTTSet *pts = work->pts; |
| 491 |
const char *UILanguageFile = pts->UILanguageFile; |
| 492 |
SetWindowLongPtr(Dialog, DWLP_USER, (LONG_PTR)work); |
| 493 |
::DragAcceptFiles(Dialog, TRUE); |
| 494 |
|
| 495 |
SetDlgTexts(Dialog, TextInfos, _countof(TextInfos), UILanguageFile); |
| 496 |
SetI18nList("Tera Term", Dialog, IDC_TIMESTAMPTYPE, timestamp_list, _countof(timestamp_list), |
| 497 |
UILanguageFile, 0); |
| 498 |
|
| 499 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_ADDSTRING, 0, (LPARAM)"UTF-8"); |
| 500 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_ADDSTRING, 0, (LPARAM)"UTF-16LE"); |
| 501 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_ADDSTRING, 0, (LPARAM)"UTF-16BE"); |
| 502 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0); |
| 503 |
|
| 504 |
_SetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, work->info->filename); |
| 505 |
work->info->filename = NULL; |
| 506 |
|
| 507 |
// Binary/Text �`�F�b�N�{�b�N�X |
| 508 |
if (pts->LogBinary) { |
| 509 |
CheckRadioButton(Dialog, IDC_FOPTBIN, IDC_FOPTTEXT, IDC_FOPTBIN); |
| 510 |
} |
| 511 |
else { |
| 512 |
CheckRadioButton(Dialog, IDC_FOPTBIN, IDC_FOPTTEXT, IDC_FOPTTEXT); |
| 513 |
} |
| 514 |
|
| 515 |
// Plain Text �`�F�b�N�{�b�N�X |
| 516 |
if (pts->LogBinary) { |
| 517 |
// Binary�t���O���L�����������`�F�b�N�������� |
| 518 |
DisableDlgItem(Dialog, IDC_PLAINTEXT, IDC_PLAINTEXT); |
| 519 |
} |
| 520 |
else if (pts->LogTypePlainText) { |
| 521 |
SetRB(Dialog, 1, IDC_PLAINTEXT, IDC_PLAINTEXT); |
| 522 |
} |
| 523 |
|
| 524 |
// Hide dialog�`�F�b�N�{�b�N�X (2008.1.30 maya) |
| 525 |
if (pts->LogHideDialog) { |
| 526 |
SetRB(Dialog, 1, IDC_HIDEDIALOG, IDC_HIDEDIALOG); |
| 527 |
} |
| 528 |
|
| 529 |
// Include screen buffer�`�F�b�N�{�b�N�X (2013.9.29 yutaka) |
| 530 |
if (pts->LogAllBuffIncludedInFirst) { |
| 531 |
SetRB(Dialog, 1, IDC_ALLBUFF_INFIRST, IDC_ALLBUFF_INFIRST); |
| 532 |
} |
| 533 |
|
| 534 |
// timestamp�`�F�b�N�{�b�N�X (2006.7.23 maya) |
| 535 |
if (pts->LogBinary) { |
| 536 |
// Binary�t���O���L�����������`�F�b�N�������� |
| 537 |
DisableDlgItem(Dialog, IDC_TIMESTAMP, IDC_TIMESTAMP); |
| 538 |
} |
| 539 |
else if (pts->LogTimestamp) { |
| 540 |
SetRB(Dialog, 1, IDC_TIMESTAMP, IDC_TIMESTAMP); |
| 541 |
} |
| 542 |
|
| 543 |
// timestamp ���� |
| 544 |
int tstype = pts->LogTimestampType == TIMESTAMP_LOCAL ? 0 : |
| 545 |
pts->LogTimestampType == TIMESTAMP_UTC ? 1 : |
| 546 |
pts->LogTimestampType == TIMESTAMP_ELAPSED_LOGSTART ? 2 : |
| 547 |
pts->LogTimestampType == TIMESTAMP_ELAPSED_CONNECTED ? 3 : 0; |
| 548 |
SendDlgItemMessage(Dialog, IDC_TIMESTAMPTYPE, CB_SETCURSEL, tstype, 0); |
| 549 |
if (pts->LogBinary || !pts->LogTimestamp) { |
| 550 |
DisableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE); |
| 551 |
} |
| 552 |
|
| 553 |
CenterWindow(Dialog, GetParent(Dialog)); |
| 554 |
|
| 555 |
return TRUE; |
| 556 |
} |
| 557 |
|
| 558 |
case WM_COMMAND: |
| 559 |
switch (LOWORD(wParam)) { |
| 560 |
case IDOK: { |
| 561 |
wchar_t filename[MAX_PATH]; |
| 562 |
_GetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, filename, _countof(filename)); |
| 563 |
work->info->filename = _wcsdup(filename); |
| 564 |
work->info->append = IsDlgButtonChecked(Dialog, IDC_APPEND) == BST_CHECKED; |
| 565 |
work->info->bom = IsDlgButtonChecked(Dialog, IDC_BOM) == BST_CHECKED; |
| 566 |
work->info->code = (int)SendDlgItemMessageA(Dialog, IDC_TEXTCODING_DROPDOWN, CB_GETCURSEL, 0, 0); |
| 567 |
SetLogFlags(Dialog); |
| 568 |
EndDialog(Dialog, IDOK); |
| 569 |
break; |
| 570 |
} |
| 571 |
case IDCANCEL: |
| 572 |
EndDialog(Dialog, IDCANCEL); |
| 573 |
break; |
| 574 |
case IDHELP: |
| 575 |
OpenHelp(HH_HELP_CONTEXT, HlpFileLog, work->pts->UILanguageFile); |
| 576 |
break; |
| 577 |
case IDC_FOPT_FILENAME_BUTTON: { |
| 578 |
/* save current dir */ |
| 579 |
const char *UILanguageFile = work->pts->UILanguageFile; |
| 580 |
wchar_t curdir[MAXPATHLEN]; |
| 581 |
_GetCurrentDirectoryW(_countof(curdir), curdir); |
| 582 |
|
| 583 |
wchar_t fname[MAX_PATH]; |
| 584 |
GetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, fname, _countof(fname)); |
| 585 |
|
| 586 |
wchar_t FNFilter[128*3]; |
| 587 |
get_lang_msgW("FILEDLG_ALL_FILTER", FNFilter, sizeof(FNFilter), L"All(*.*)\\0*.*\\0\\0", UILanguageFile); |
| 588 |
|
| 589 |
wchar_t caption[MAX_PATH]; |
| 590 |
wchar_t uimsg[MAX_UIMSG]; |
| 591 |
#define TitLogW L"Log" |
| 592 |
get_lang_msgW("FILEDLG_TRANS_TITLE_LOG", uimsg, _countof(uimsg), TitLogW, UILanguageFile); |
| 593 |
wcsncpy_s(caption, _countof(caption), L"Tera Term: ", _TRUNCATE); |
| 594 |
wcsncat_s(caption, _countof(caption), uimsg, _TRUNCATE); |
| 595 |
|
| 596 |
OPENFILENAMEW ofn = {}; |
| 597 |
ofn.lStructSize = get_OPENFILENAME_SIZEW(); |
| 598 |
//ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT; |
| 599 |
ofn.Flags |= OFN_EXPLORER | OFN_ENABLESIZING; |
| 600 |
ofn.Flags |= OFN_SHOWHELP; |
| 601 |
ofn.Flags |= OFN_NOCHANGEDIR; // �������������������������������� |
| 602 |
ofn.hwndOwner = Dialog; |
| 603 |
ofn.lpstrFilter = FNFilter; |
| 604 |
ofn.nFilterIndex = 1; |
| 605 |
ofn.lpstrFile = fname; |
| 606 |
ofn.nMaxFile = _countof(fname); |
| 607 |
ofn.lpstrTitle = caption; |
| 608 |
BOOL Ok = GetSaveFileNameW(&ofn); |
| 609 |
if (Ok) { |
| 610 |
SetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, fname); |
| 611 |
} |
| 612 |
|
| 613 |
/* restore dir */ |
| 614 |
_SetCurrentDirectoryW(curdir); |
| 615 |
|
| 616 |
break; |
| 617 |
} |
| 618 |
case IDC_FOPTBIN: |
| 619 |
EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), FALSE); |
| 620 |
EnableWindow(GetDlgItem(Dialog, IDC_BOM), FALSE); |
| 621 |
DisableDlgItem(Dialog, IDC_PLAINTEXT, IDC_TIMESTAMP); |
| 622 |
DisableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE); |
| 623 |
break; |
| 624 |
case IDC_FOPTTEXT: |
| 625 |
ArrangeControls(Dialog, work); |
| 626 |
EnableDlgItem(Dialog, IDC_PLAINTEXT, IDC_TIMESTAMP); |
| 627 |
// FALLTHROUGH -- BinFlag �� off ������ Timestamp �������L��/�������������� |
| 628 |
case IDC_TIMESTAMP: |
| 629 |
if (IsDlgButtonChecked(Dialog, IDC_TIMESTAMP) == BST_CHECKED) { |
| 630 |
EnableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE); |
| 631 |
} |
| 632 |
else { |
| 633 |
DisableDlgItem(Dialog, IDC_TIMESTAMPTYPE, IDC_TIMESTAMPTYPE); |
| 634 |
} |
| 635 |
break; |
| 636 |
case IDC_FOPT_FILENAME_EDIT: |
| 637 |
if (HIWORD(wParam) == EN_CHANGE){ |
| 638 |
wchar_t filename[MAX_PATH]; |
| 639 |
GetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, filename, _countof(filename)); |
| 640 |
CheckLogFile(Dialog, filename, work); |
| 641 |
} |
| 642 |
break; |
| 643 |
case IDC_NEW_OVERWRITE: |
| 644 |
if (IsDlgButtonChecked(Dialog, IDC_FOPTTEXT) == BST_CHECKED) { |
| 645 |
EnableWindow(GetDlgItem(Dialog, IDC_BOM), TRUE); |
| 646 |
EnableWindow(GetDlgItem(Dialog, IDC_TEXTCODING_DROPDOWN), TRUE); |
| 647 |
CheckDlgButton(Dialog, IDC_BOM, BST_CHECKED); |
| 648 |
SendDlgItemMessage(Dialog, IDC_TEXTCODING_DROPDOWN, CB_SETCURSEL, 0, 0); |
| 649 |
} |
| 650 |
break; |
| 651 |
case IDC_APPEND: |
| 652 |
ArrangeControls(Dialog, work); |
| 653 |
break; |
| 654 |
} |
| 655 |
break; |
| 656 |
case WM_DROPFILES: { |
| 657 |
// �����h���b�v��������������1������������ |
| 658 |
HDROP hDrop = (HDROP)wParam; |
| 659 |
const UINT len = _DragQueryFileW(hDrop, 0, NULL, 0); |
| 660 |
if (len == 0) { |
| 661 |
DragFinish(hDrop); |
| 662 |
return TRUE; |
| 663 |
} |
| 664 |
wchar_t *filename = (wchar_t *)malloc(sizeof(wchar_t) * (len + 1)); |
| 665 |
_DragQueryFileW(hDrop, 0, filename, len + 1); |
| 666 |
filename[len] = '\0'; |
| 667 |
CheckRadioButton(Dialog, IDC_NEW_OVERWRITE, IDC_APPEND, IDC_APPEND); |
| 668 |
_SetDlgItemTextW(Dialog, IDC_FOPT_FILENAME_EDIT, filename); |
| 669 |
SendDlgItemMessage(Dialog, IDC_FOPT_FILENAME_EDIT, EM_SETSEL, len, len); |
| 670 |
free(filename); |
| 671 |
DragFinish(hDrop); |
| 672 |
return TRUE; |
| 673 |
} |
| 674 |
} |
| 675 |
return FALSE; |
| 676 |
} |
| 677 |
|
| 678 |
static void OpenLogFile(PFileVar fv) |
| 679 |
{ |
| 680 |
int dwShareMode = FILE_SHARE_READ; |
| 681 |
if (!ts.LogLockExclusive) { |
| 682 |
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; |
| 683 |
} |
| 684 |
LogVar->FileHandle = _CreateFileW(LogVar->FullName, GENERIC_WRITE, dwShareMode, NULL, |
| 685 |
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); |
| 686 |
} |
| 687 |
|
| 688 |
static BOOL LogStart(const wchar_t *fname) |
| 689 |
{ |
| 690 |
PFileVar fv = LogVar; |
| 691 |
|
| 692 |
fv->FullName = _wcsdup(fname); |
| 693 |
fv->FileName = NULL; |
| 694 |
FixLogOption(); |
| 695 |
|
| 696 |
if (ts.LogBinary > 0) |
| 697 |
{ |
| 698 |
BinLog = TRUE; |
| 699 |
FileLog = FALSE; |
| 700 |
if (! CreateBinBuf()) |
| 701 |
{ |
| 702 |
return FALSE; |
| 703 |
} |
| 704 |
} |
| 705 |
else { |
| 706 |
BinLog = FALSE; |
| 707 |
FileLog = TRUE; |
| 708 |
if (! CreateLogBuf()) |
| 709 |
{ |
| 710 |
return FALSE; |
| 711 |
} |
| 712 |
} |
| 713 |
cv_LStart = cv_LogPtr; |
| 714 |
cv_LCount = 0; |
| 715 |
|
| 716 |
OpenLogFile(fv); |
| 717 |
if (LogVar->FileHandle == INVALID_HANDLE_VALUE) { |
| 718 |
return FALSE; |
| 719 |
} |
| 720 |
|
| 721 |
/* 2007.05.24 Gentaro */ |
| 722 |
fv->eLineEnd = Line_LineHead; |
| 723 |
if (ts.Append > 0) |
| 724 |
{ |
| 725 |
SetFilePointer(LogVar->FileHandle, 0, NULL, FILE_END); |
| 726 |
/* 2007.05.24 Gentaro |
| 727 |
If log file already exists, |
| 728 |
a newline is inserted before the first timestamp. |
| 729 |
*/ |
| 730 |
fv->eLineEnd = Line_FileHead; |
| 731 |
} |
| 732 |
|
| 733 |
// Log rotate configuration |
| 734 |
LogVar->RotateMode = ts.LogRotate; |
| 735 |
LogVar->RotateSize = ts.LogRotateSize; |
| 736 |
LogVar->RotateStep = ts.LogRotateStep; |
| 737 |
|
| 738 |
// Log rotate���L���������A�����t�@�C���T�C�Y�����������B |
| 739 |
// �������t�@�C�������������T�C�Y�����[�e�[�g�������������C���B |
| 740 |
// (2016.4.9 yutaka) |
| 741 |
if (LogVar->RotateMode != ROTATE_NONE) { |
| 742 |
DWORD size = GetFileSize(LogVar->FileHandle, NULL); |
| 743 |
if (size == -1) { |
| 744 |
return FALSE; |
| 745 |
} |
| 746 |
LogVar->ByteCount = size; |
| 747 |
} |
| 748 |
else { |
| 749 |
LogVar->ByteCount = 0; |
| 750 |
} |
| 751 |
|
| 752 |
if (! OpenFTDlg_(LogVar)) { |
| 753 |
return FALSE; |
| 754 |
} |
| 755 |
|
| 756 |
LogVar->IsPause = FALSE; |
| 757 |
LogVar->StartTime = GetTickCount(); |
| 758 |
|
| 759 |
if (ts.DeferredLogWriteMode) { |
| 760 |
StartThread(LogVar); |
| 761 |
} |
| 762 |
|
| 763 |
// �����o�b�t�@�������f�[�^�������������o���������A |
| 764 |
// ���O�������J�n�����B |
| 765 |
// (2013.9.29 yutaka) |
| 766 |
if (ts.LogAllBuffIncludedInFirst) { |
| 767 |
DWORD ofs, size, written_size; |
| 768 |
char buf[512]; |
| 769 |
const char *crlf = "\r\n"; |
| 770 |
DWORD crlf_len = 2; |
| 771 |
for (ofs = 0 ; ; ofs++ ) { |
| 772 |
// 1�����s�����������B���������������A�G�X�P�[�v�V�[�P���X�������������B |
| 773 |
size = BuffGetAnyLineData(ofs, buf, sizeof(buf)); |
| 774 |
if (size == -1) |
| 775 |
break; |
| 776 |
|
| 777 |
#if 0 |
| 778 |
if (ts.DeferredLogWriteMode) { // �x���������� |
| 779 |
char *pbuf = (char *)malloc(size + 2); |
| 780 |
memcpy(pbuf, buf, size); |
| 781 |
pbuf[size] = '\r'; |
| 782 |
pbuf[size+1] = '\n'; |
| 783 |
Sleep(1); // �X���b�h�L���[�����������������A�R���e�L�X�g�X�C�b�`�������B |
| 784 |
PostThreadMessage(LogVar->LogThreadId, WM_DPC_LOGTHREAD_SEND, (WPARAM)pbuf, size + 2); |
| 785 |
} else { // �������B�l�b�g���[�N�o�R�����x���B |
| 786 |
#endif |
| 787 |
WriteFile(LogVar->FileHandle, buf, size, &written_size, NULL); |
| 788 |
WriteFile(LogVar->FileHandle, crlf, crlf_len, &written_size, NULL); |
| 789 |
#if 0 |
| 790 |
} |
| 791 |
#endif |
| 792 |
} |
| 793 |
} |
| 794 |
|
| 795 |
if (FileLog) { |
| 796 |
cv.Log1Byte = LogPut1; |
| 797 |
} |
| 798 |
if (BinLog) { |
| 799 |
cv.Log1Bin = Log1Bin; |
| 800 |
cv.LogBinSkip = LogBinSkip; |
| 801 |
} |
| 802 |
|
| 803 |
return TRUE; |
| 804 |
} |
| 805 |
|
| 806 |
/** |
| 807 |
* ���O��1byte�������� |
| 808 |
* �o�b�t�@�������������� |
| 809 |
* ���������������� LogToFile() ���s������ |
| 810 |
*/ |
| 811 |
void LogPut1(BYTE b) |
| 812 |
{ |
| 813 |
cv_LogBuf[cv_LogPtr] = b; |
| 814 |
cv_LogPtr++; |
| 815 |
if (cv_LogPtr>=InBuffSize) |
| 816 |
cv_LogPtr = cv_LogPtr-InBuffSize; |
| 817 |
|
| 818 |
if (FileLog) |
| 819 |
{ |
| 820 |
if (cv_LCount>=InBuffSize) |
| 821 |
{ |
| 822 |
cv_LCount = InBuffSize; |
| 823 |
cv_LStart = cv_LogPtr; |
| 824 |
} |
| 825 |
else |
| 826 |
cv_LCount++; |
| 827 |
} |
| 828 |
else |
| 829 |
cv_LCount = 0; |
| 830 |
} |
| 831 |
|
| 832 |
static BOOL Get1(PCHAR Buf, int *Start, int *Count, PBYTE b) |
| 833 |
{ |
| 834 |
if (*Count<=0) return FALSE; |
| 835 |
*b = Buf[*Start]; |
| 836 |
(*Start)++; |
| 837 |
if (*Start>=InBuffSize) |
| 838 |
*Start = *Start-InBuffSize; |
| 839 |
(*Count)--; |
| 840 |
return TRUE; |
| 841 |
} |
| 842 |
|
| 843 |
|
| 844 |
|
| 845 |
static CRITICAL_SECTION g_filelog_lock; /* ���b�N�p���� */ |
| 846 |
|
| 847 |
void logfile_lock_initialize(void) |
| 848 |
{ |
| 849 |
InitializeCriticalSection(&g_filelog_lock); |
| 850 |
} |
| 851 |
|
| 852 |
static inline void logfile_lock(void) |
| 853 |
{ |
| 854 |
EnterCriticalSection(&g_filelog_lock); |
| 855 |
} |
| 856 |
|
| 857 |
static inline void logfile_unlock(void) |
| 858 |
{ |
| 859 |
LeaveCriticalSection(&g_filelog_lock); |
| 860 |
} |
| 861 |
|
| 862 |
// ���O�����[�e�[�g�����B |
| 863 |
// (2013.3.21 yutaka) |
| 864 |
static void LogRotate(void) |
| 865 |
{ |
| 866 |
int loopmax = 10000; // XXX |
| 867 |
int i, k; |
| 868 |
|
| 869 |
if (LogVar->RotateMode == ROTATE_NONE) |
| 870 |
return; |
| 871 |
|
| 872 |
if (LogVar->RotateMode == ROTATE_SIZE) { |
| 873 |
if (LogVar->ByteCount <= LogVar->RotateSize) |
| 874 |
return; |
| 875 |
//OutputDebugPrintf("%s: mode %d size %ld\n", __FUNCTION__, LogVar->RotateMode, LogVar->ByteCount); |
| 876 |
} else { |
| 877 |
return; |
| 878 |
} |
| 879 |
|
| 880 |
logfile_lock(); |
| 881 |
// ���O�T�C�Y���������������B |
| 882 |
LogVar->ByteCount = 0; |
| 883 |
|
| 884 |
// �������������t�@�C�����N���[�Y�����A�������t�@�C�����I�[�v�������B |
| 885 |
CloseFileSync(LogVar); |
| 886 |
|
| 887 |
// �������[�e�[�V�������X�e�b�v�����w���������� |
| 888 |
if (LogVar->RotateStep > 0) |
| 889 |
loopmax = LogVar->RotateStep; |
| 890 |
|
| 891 |
for (i = 1 ; i <= loopmax ; i++) { |
| 892 |
wchar_t *filename; |
| 893 |
aswprintf(&filename, L"%s.%d", LogVar->FullName, i); |
| 894 |
DWORD attr = _GetFileAttributesW(filename); |
| 895 |
free(filename); |
| 896 |
if (attr == INVALID_FILE_ATTRIBUTES) |
| 897 |
break; |
| 898 |
} |
| 899 |
if (i > loopmax) { |
| 900 |
// �������������������������A�������t�@�C�������p�������B |
| 901 |
i = loopmax; |
| 902 |
} |
| 903 |
|
| 904 |
// ���t�@�C�������l�[���B |
| 905 |
for (k = i-1 ; k >= 0 ; k--) { |
| 906 |
wchar_t *oldfile; |
| 907 |
if (k == 0) |
| 908 |
oldfile = _wcsdup(LogVar->FullName); |
| 909 |
else |
| 910 |
aswprintf(&oldfile, L"%s.%d", LogVar->FullName, k); |
| 911 |
wchar_t *newfile; |
| 912 |
aswprintf(&newfile, L"%s.%d", LogVar->FullName, k+1); |
| 913 |
_DeleteFileW(newfile); |
| 914 |
if (_MoveFileW(oldfile, newfile) == 0) { |
| 915 |
OutputDebugPrintf("%s: rename %d\n", __FUNCTION__, errno); |
| 916 |
} |
| 917 |
free(oldfile); |
| 918 |
free(newfile); |
| 919 |
} |
| 920 |
|
| 921 |
// ���I�[�v�� |
| 922 |
OpenLogFile(LogVar); |
| 923 |
if (ts.DeferredLogWriteMode) { |
| 924 |
StartThread(LogVar); |
| 925 |
} |
| 926 |
|
| 927 |
logfile_unlock(); |
| 928 |
} |
| 929 |
|
| 930 |
/** |
| 931 |
* �o�b�t�@�������O���t�@�C������������ |
| 932 |
*/ |
| 933 |
static void LogToFile(void) |
| 934 |
{ |
| 935 |
PCHAR Buf; |
| 936 |
int Start, Count; |
| 937 |
BYTE b; |
| 938 |
PCHAR WriteBuf; |
| 939 |
DWORD WriteBufMax, WriteBufLen; |
| 940 |
CHAR tmp[128]; |
| 941 |
DWORD wrote; |
| 942 |
PFileVar fv = LogVar; |
| 943 |
|
| 944 |
if (FileLog) |
| 945 |
{ |
| 946 |
Buf = cv_LogBuf; |
| 947 |
Start = cv_LStart; |
| 948 |
Count = cv_LCount; |
| 949 |
} |
| 950 |
else if (BinLog) |
| 951 |
{ |
| 952 |
Buf = cv_BinBuf; |
| 953 |
Start = cv_BStart; |
| 954 |
Count = cv_BCount; |
| 955 |
} |
| 956 |
else |
| 957 |
return; |
| 958 |
|
| 959 |
if (Buf==NULL) return; |
| 960 |
if (Count==0) return; |
| 961 |
|
| 962 |
// ���b�N������(2004.8.6 yutaka) |
| 963 |
logfile_lock(); |
| 964 |
|
| 965 |
if (ts.DeferredLogWriteMode) { |
| 966 |
WriteBufMax = 8192; |
| 967 |
WriteBufLen = 0; |
| 968 |
WriteBuf = (PCHAR)malloc(WriteBufMax); |
| 969 |
while (Get1(Buf,&Start,&Count,&b)) { |
| 970 |
if (!FLogIsPause() && (! cv.ProtoFlag)) |
| 971 |
{ |
| 972 |
tmp[0] = 0; |
| 973 |
if ( ts.LogTimestamp && fv->eLineEnd ) { |
| 974 |
char *strtime = NULL; |
| 975 |
|
| 976 |
switch (ts.LogTimestampType) { |
| 977 |
case TIMESTAMP_LOCAL: |
| 978 |
strtime = mctimelocal(ts.LogTimestampFormat, FALSE); |
| 979 |
break; |
| 980 |
case TIMESTAMP_UTC: |
| 981 |
strtime = mctimelocal(ts.LogTimestampFormat, TRUE); |
| 982 |
break; |
| 983 |
case TIMESTAMP_ELAPSED_LOGSTART: |
| 984 |
strtime = strelapsed(LogVar->StartTime); |
| 985 |
break; |
| 986 |
case TIMESTAMP_ELAPSED_CONNECTED: |
| 987 |
strtime = strelapsed(cv.ConnectedTime); |
| 988 |
break; |
| 989 |
} |
| 990 |
|
| 991 |
/* 2007.05.24 Gentaro */ |
| 992 |
if(fv->eLineEnd == Line_FileHead ){ |
| 993 |
strncat_s(tmp, sizeof(tmp), "\r\n", _TRUNCATE); |
| 994 |
} |
| 995 |
strncat_s(tmp, sizeof(tmp), "[", _TRUNCATE); |
| 996 |
strncat_s(tmp, sizeof(tmp), strtime, _TRUNCATE); |
| 997 |
strncat_s(tmp, sizeof(tmp), "] ", _TRUNCATE); |
| 998 |
} |
| 999 |
|
| 1000 |
/* 2007.05.24 Gentaro */ |
| 1001 |
if( b == 0x0a ){ |
| 1002 |
fv->eLineEnd = Line_LineHead; /* set endmark*/ |
| 1003 |
} |
| 1004 |
else { |
| 1005 |
fv->eLineEnd = Line_Other; /* clear endmark*/ |
| 1006 |
} |
| 1007 |
|
| 1008 |
if (WriteBufLen >= (WriteBufMax*4/5)) { |
| 1009 |
WriteBufMax *= 2; |
| 1010 |
WriteBuf = (PCHAR)realloc(WriteBuf, WriteBufMax); |
| 1011 |
} |
| 1012 |
memcpy(&WriteBuf[WriteBufLen], tmp, strlen(tmp)); |
| 1013 |
WriteBufLen += strlen(tmp); |
| 1014 |
WriteBuf[WriteBufLen++] = b; |
| 1015 |
|
| 1016 |
(LogVar->ByteCount)++; |
| 1017 |
} |
| 1018 |
} |
| 1019 |
|
| 1020 |
PostThreadMessage(LogVar->LogThreadId, WM_DPC_LOGTHREAD_SEND, (WPARAM)WriteBuf, WriteBufLen); |
| 1021 |
|
| 1022 |
} else { |
| 1023 |
|
| 1024 |
while (Get1(Buf,&Start,&Count,&b)) |
| 1025 |
{ |
| 1026 |
if (!FLogIsPause() && (! cv.ProtoFlag)) |
| 1027 |
{ |
| 1028 |
if ( ts.LogTimestamp && fv->eLineEnd ) { |
| 1029 |
char *strtime = NULL; |
| 1030 |
|
| 1031 |
switch (ts.LogTimestampType) { |
| 1032 |
case TIMESTAMP_LOCAL: |
| 1033 |
strtime = mctimelocal(ts.LogTimestampFormat, FALSE); |
| 1034 |
break; |
| 1035 |
case TIMESTAMP_UTC: |
| 1036 |
strtime = mctimelocal(ts.LogTimestampFormat, TRUE); |
| 1037 |
break; |
| 1038 |
case TIMESTAMP_ELAPSED_LOGSTART: |
| 1039 |
strtime = strelapsed(LogVar->StartTime); |
| 1040 |
break; |
| 1041 |
case TIMESTAMP_ELAPSED_CONNECTED: |
| 1042 |
strtime = strelapsed(cv.ConnectedTime); |
| 1043 |
break; |
| 1044 |
} |
| 1045 |
WriteFile(LogVar->FileHandle, "[", 1, &wrote, NULL); |
| 1046 |
WriteFile(LogVar->FileHandle, strtime, strlen(strtime), &wrote, NULL); |
| 1047 |
WriteFile(LogVar->FileHandle, "] ", 2, &wrote, NULL); |
| 1048 |
} |
| 1049 |
|
| 1050 |
/* 2007.05.24 Gentaro */ |
| 1051 |
if( b == 0x0a ){ |
| 1052 |
fv->eLineEnd = Line_LineHead; /* set endmark*/ |
| 1053 |
} |
| 1054 |
else { |
| 1055 |
fv->eLineEnd = Line_Other; /* clear endmark*/ |
| 1056 |
} |
| 1057 |
|
| 1058 |
WriteFile(LogVar->FileHandle, (PCHAR)&b, 1, &wrote, NULL); |
| 1059 |
(LogVar->ByteCount)++; |
| 1060 |
} |
| 1061 |
} |
| 1062 |
|
| 1063 |
} |
| 1064 |
|
| 1065 |
logfile_unlock(); |
| 1066 |
|
| 1067 |
if (FileLog) |
| 1068 |
{ |
| 1069 |
cv_LStart = Start; |
| 1070 |
cv_LCount = Count; |
| 1071 |
} |
| 1072 |
else { |
| 1073 |
cv_BStart = Start; |
| 1074 |
cv_BCount = Count; |
| 1075 |
} |
| 1076 |
if (FLogIsPause() || cv.ProtoFlag) return; |
| 1077 |
LogVar->FLogDlg->RefreshNum(LogVar->StartTime, LogVar->FileSize, LogVar->ByteCount); |
| 1078 |
|
| 1079 |
|
| 1080 |
// ���O�E���[�e�[�g |
| 1081 |
LogRotate(); |
| 1082 |
} |
| 1083 |
|
| 1084 |
static BOOL CreateLogBuf(void) |
| 1085 |
{ |
| 1086 |
if (cv_LogBuf==NULL) |
| 1087 |
{ |
| 1088 |
cv_LogBuf = (char *)malloc(InBuffSize); |
| 1089 |
cv_LogPtr = 0; |
| 1090 |
cv_LStart = 0; |
| 1091 |
cv_LCount = 0; |
| 1092 |
} |
| 1093 |
return (cv_LogBuf!=NULL); |
| 1094 |
} |
| 1095 |
|
| 1096 |
static void FreeLogBuf(void) |
| 1097 |
{ |
| 1098 |
free(cv_LogBuf); |
| 1099 |
cv_LogBuf = NULL; |
| 1100 |
cv_LogPtr = 0; |
| 1101 |
cv_LStart = 0; |
| 1102 |
cv_LCount = 0; |
| 1103 |
} |
| 1104 |
|
| 1105 |
static BOOL CreateBinBuf(void) |
| 1106 |
{ |
| 1107 |
if (cv_BinBuf==NULL) |
| 1108 |
{ |
| 1109 |
cv_BinBuf = (PCHAR)malloc(InBuffSize); |
| 1110 |
cv_BinPtr = 0; |
| 1111 |
cv_BStart = 0; |
| 1112 |
cv_BCount = 0; |
| 1113 |
} |
| 1114 |
return (cv_BinBuf!=NULL); |
| 1115 |
} |
| 1116 |
|
| 1117 |
static void FreeBinBuf(void) |
| 1118 |
{ |
| 1119 |
free(cv_BinBuf); |
| 1120 |
cv_BinBuf = NULL; |
| 1121 |
cv_BinPtr = 0; |
| 1122 |
cv_BStart = 0; |
| 1123 |
cv_BCount = 0; |
| 1124 |
} |
| 1125 |
|
| 1126 |
static void FileTransEnd_(void) |
| 1127 |
{ |
| 1128 |
if (LogVar == NULL) { |
| 1129 |
return; |
| 1130 |
} |
| 1131 |
FileLog = FALSE; |
| 1132 |
BinLog = FALSE; |
| 1133 |
cv.Log1Byte = NULL; |
| 1134 |
cv.Log1Bin = NULL; |
| 1135 |
cv.LogBinSkip = NULL; |
| 1136 |
PFileTransDlg FLogDlg = LogVar->FLogDlg; |
| 1137 |
if (FLogDlg != NULL) { |
| 1138 |
FLogDlg->DestroyWindow(); |
| 1139 |
FLogDlg = NULL; |
| 1140 |
} |
| 1141 |
CloseFileSync(LogVar); |
| 1142 |
FreeLogBuf(); |
| 1143 |
FreeBinBuf(); |
| 1144 |
free(LogVar); |
| 1145 |
LogVar = NULL; |
| 1146 |
} |
| 1147 |
|
| 1148 |
/** |
| 1149 |
* ���O���|�[�Y���� |
| 1150 |
*/ |
| 1151 |
void FLogPause(BOOL Pause) |
| 1152 |
{ |
| 1153 |
if (LogVar == NULL) { |
| 1154 |
return; |
| 1155 |
} |
| 1156 |
LogVar->IsPause = Pause; |
| 1157 |
LogVar->FLogDlg->ChangeButton(Pause); |
| 1158 |
} |
| 1159 |
|
| 1160 |
/** |
| 1161 |
* ���O���[�e�[�g������ |
| 1162 |
* ���O���T�C�Y��<size>�o�C�g���������������A���[�e�[�V�������������������� |
| 1163 |
*/ |
| 1164 |
void FLogRotateSize(size_t size) |
| 1165 |
{ |
| 1166 |
if (LogVar == NULL) { |
| 1167 |
return; |
| 1168 |
} |
| 1169 |
LogVar->RotateMode = ROTATE_SIZE; |
| 1170 |
LogVar->RotateSize = size; |
| 1171 |
} |
| 1172 |
|
| 1173 |
/** |
| 1174 |
* ���O���[�e�[�g������ |
| 1175 |
* ���O�t�@�C������������������ |
| 1176 |
*/ |
| 1177 |
void FLogRotateRotate(int step) |
| 1178 |
{ |
| 1179 |
if (LogVar == NULL) { |
| 1180 |
return; |
| 1181 |
} |
| 1182 |
LogVar->RotateStep = step; |
| 1183 |
} |
| 1184 |
|
| 1185 |
/** |
| 1186 |
* ���O���[�e�[�g������ |
| 1187 |
* ���[�e�[�V���������~ |
| 1188 |
*/ |
| 1189 |
void FLogRotateHalt(void) |
| 1190 |
{ |
| 1191 |
if (LogVar == NULL) { |
| 1192 |
return; |
| 1193 |
} |
| 1194 |
LogVar->RotateMode = ROTATE_NONE; |
| 1195 |
LogVar->RotateSize = 0; |
| 1196 |
LogVar->RotateStep = 0; |
| 1197 |
} |
| 1198 |
|
| 1199 |
static INT_PTR CALLBACK OnCommentDlgProc(HWND hDlgWnd, UINT msg, WPARAM wp, LPARAM lp) |
| 1200 |
{ |
| 1201 |
static const DlgTextInfo TextInfos[] = { |
| 1202 |
{ 0, "DLG_COMMENT_TITLE" }, |
| 1203 |
{ IDOK, "BTN_OK" } |
| 1204 |
}; |
| 1205 |
|
| 1206 |
switch (msg) { |
| 1207 |
case WM_INITDIALOG: |
| 1208 |
// �G�f�B�b�g�R���g���[�����t�H�[�J�X�������� |
| 1209 |
SetFocus(GetDlgItem(hDlgWnd, IDC_EDIT_COMMENT)); |
| 1210 |
SetDlgTexts(hDlgWnd, TextInfos, _countof(TextInfos), ts.UILanguageFile); |
| 1211 |
return FALSE; |
| 1212 |
|
| 1213 |
case WM_COMMAND: |
| 1214 |
switch (LOWORD(wp)) { |
| 1215 |
case IDOK: { |
| 1216 |
size_t len = _SendDlgItemMessageW(hDlgWnd, IDC_EDIT_COMMENT, WM_GETTEXTLENGTH, 0, 0); |
| 1217 |
len += 1; |
| 1218 |
wchar_t *buf = (wchar_t *)malloc(len * sizeof(wchar_t)); |
| 1219 |
_GetDlgItemTextW(hDlgWnd, IDC_EDIT_COMMENT, buf, len); |
| 1220 |
FLogWriteStr(buf); |
| 1221 |
FLogWriteStr(L"\n"); // TODO ���s�R�[�h |
| 1222 |
free(buf); |
| 1223 |
TTEndDialog(hDlgWnd, IDOK); |
| 1224 |
break; |
| 1225 |
} |
| 1226 |
default: |
| 1227 |
return FALSE; |
| 1228 |
} |
| 1229 |
break; |
| 1230 |
|
| 1231 |
case WM_CLOSE: |
| 1232 |
TTEndDialog(hDlgWnd, 0); |
| 1233 |
return TRUE; |
| 1234 |
|
| 1235 |
default: |
| 1236 |
return FALSE; |
| 1237 |
} |
| 1238 |
return TRUE; |
| 1239 |
} |
| 1240 |
|
| 1241 |
/** |
| 1242 |
* ���O�t�@�C�����R�����g���������� (2004.8.6 yutaka) |
| 1243 |
*/ |
| 1244 |
void FLogAddCommentDlg(HINSTANCE hInst, HWND hWnd) |
| 1245 |
{ |
| 1246 |
if (LogVar == NULL) { |
| 1247 |
return; |
| 1248 |
} |
| 1249 |
TTDialogBox(hInst, MAKEINTRESOURCE(IDD_COMMENT_DIALOG), |
| 1250 |
HVTWin, OnCommentDlgProc); |
| 1251 |
} |
| 1252 |
|
| 1253 |
void FLogClose(void) |
| 1254 |
{ |
| 1255 |
if (LogVar == NULL) { |
| 1256 |
return; |
| 1257 |
} |
| 1258 |
|
| 1259 |
FileTransEnd_(); |
| 1260 |
} |
| 1261 |
|
| 1262 |
/** |
| 1263 |
* ���O���I�[�v������ |
| 1264 |
* @param[in] fname ���O�t�@�C����, CreateFile()���n������ |
| 1265 |
* |
| 1266 |
* ���O�t�@�C������strftime���W�J�������s���������B |
| 1267 |
* FLogGetLogFilename() �� FLogOpenDialog() �� |
| 1268 |
* �t�@�C�����������������B |
| 1269 |
*/ |
| 1270 |
BOOL FLogOpen(const wchar_t *fname) |
| 1271 |
{ |
| 1272 |
BOOL ret; |
| 1273 |
|
| 1274 |
if (LogVar != NULL) { |
| 1275 |
return FALSE; |
| 1276 |
} |
| 1277 |
if ((FileLog) || (BinLog)) return FALSE; |
| 1278 |
|
| 1279 |
// |
| 1280 |
PFileVar fv = (PFileVar)malloc(sizeof(TFileVar)); |
| 1281 |
if (fv == NULL) { |
| 1282 |
return FALSE; |
| 1283 |
} |
| 1284 |
LogVar = fv; |
| 1285 |
memset(fv, 0, sizeof(TFileVar)); |
| 1286 |
fv->FileHandle = INVALID_HANDLE_VALUE; |
| 1287 |
fv->LogThread = INVALID_HANDLE_VALUE; |
| 1288 |
fv->eLineEnd = Line_LineHead; |
| 1289 |
fv->log_code = 0; // UTF-8 |
| 1290 |
|
| 1291 |
ret = LogStart(fname); |
| 1292 |
if (ret == FALSE) { |
| 1293 |
FileTransEnd_(); |
| 1294 |
} |
| 1295 |
|
| 1296 |
return ret; |
| 1297 |
} |
| 1298 |
|
| 1299 |
BOOL FLogIsOpend(void) |
| 1300 |
{ |
| 1301 |
return LogVar != NULL; |
| 1302 |
} |
| 1303 |
|
| 1304 |
BOOL FLogIsOpendText(void) |
| 1305 |
{ |
| 1306 |
return LogVar != NULL && FileLog; |
| 1307 |
} |
| 1308 |
|
| 1309 |
BOOL FLogIsOpendBin(void) |
| 1310 |
{ |
| 1311 |
return LogVar != NULL && BinLog; |
| 1312 |
} |
| 1313 |
|
| 1314 |
void FLogWriteStr(const wchar_t *str) |
| 1315 |
{ |
| 1316 |
if (LogVar != NULL) { |
| 1317 |
#if 0 |
| 1318 |
DWORD wrote; |
| 1319 |
size_t len = wcslen(str) * sizeof(wchar_t); |
| 1320 |
logfile_lock(); |
| 1321 |
WriteFile(LogVar->FileHandle, str, len, &wrote, NULL); |
| 1322 |
LogVar->eLineEnd = Line_LineHead; |
| 1323 |
logfile_unlock(); |
| 1324 |
LogVar->ByteCount = |
| 1325 |
LogVar->ByteCount + len; |
| 1326 |
LogVar->FLogDlg->RefreshNum(LogVar->StartTime, LogVar->FileSize, LogVar->ByteCount); |
| 1327 |
#endif |
| 1328 |
OutputStr(str); |
| 1329 |
} |
| 1330 |
} |
| 1331 |
|
| 1332 |
void FLogInfo(char *param_ptr, size_t param_len) |
| 1333 |
{ |
| 1334 |
if (LogVar) { |
| 1335 |
param_ptr[0] = '0' |
| 1336 |
+ (ts.LogBinary != 0) |
| 1337 |
+ ((ts.Append != 0) << 1) |
| 1338 |
+ ((ts.LogTypePlainText != 0) << 2) |
| 1339 |
+ ((ts.LogTimestamp != 0) << 3) |
| 1340 |
+ ((ts.LogHideDialog != 0) << 4); |
| 1341 |
char *filenameU8 = ToU8W(LogVar->FullName); |
| 1342 |
strncpy_s(param_ptr + 1, param_len - 1, filenameU8, _TRUNCATE); |
| 1343 |
free(filenameU8); |
| 1344 |
} |
| 1345 |
else { |
| 1346 |
param_ptr[0] = '0' - 1; |
| 1347 |
param_ptr[1] = 0; |
| 1348 |
} |
| 1349 |
} |
| 1350 |
|
| 1351 |
/** |
| 1352 |
* ���������O�t�@�C���������� |
| 1353 |
*/ |
| 1354 |
const wchar_t *FLogGetFilename(void) |
| 1355 |
{ |
| 1356 |
if (LogVar == NULL) { |
| 1357 |
return NULL; |
| 1358 |
} |
| 1359 |
return LogVar->FullName; |
| 1360 |
} |
| 1361 |
|
| 1362 |
/** |
| 1363 |
* ���O�_�C�A���O���J�� |
| 1364 |
* @param[in,out] info.filename �t�@�C���������l |
| 1365 |
* OK���A�t�@�C�����A�s�v����������free()�������� |
| 1366 |
* @retval TRUE [ok] ���������� |
| 1367 |
* @retval FALSE �L�����Z�������� |
| 1368 |
*/ |
| 1369 |
BOOL FLogOpenDialog(HINSTANCE hInst, HWND hWnd, FLogDlgInfo_t *info) |
| 1370 |
{ |
| 1371 |
LogDlgWork_t *work = (LogDlgWork_t *)calloc(sizeof(LogDlgWork_t), 1); |
| 1372 |
wchar_t *srcfnameW = FLogGetLogFilename(info->filename); |
| 1373 |
work->info = info; |
| 1374 |
work->info->filename = srcfnameW; |
| 1375 |
work->pts = &ts; |
| 1376 |
INT_PTR ret = TTDialogBoxParam( |
| 1377 |
hInst, MAKEINTRESOURCE(IDD_LOGDLG), |
| 1378 |
hWnd, LogFnHook, (LPARAM)work); |
| 1379 |
free(srcfnameW); |
| 1380 |
free(work); |
| 1381 |
return ret == IDOK ? TRUE : FALSE; |
| 1382 |
} |
| 1383 |
|
| 1384 |
/** |
| 1385 |
* ���O�t�@�C���������� |
| 1386 |
* ���O�t�@�C�����p���C�����s�� |
| 1387 |
* - strftime() ���������t�W�J |
| 1388 |
* - �������������O�t�@�C���t�H���_������ |
| 1389 |
* - �z�X�g��,�|�[�g�����W�J |
| 1390 |
* |
| 1391 |
* @param[in] log_filename �t�@�C����(����/��������������ok) |
| 1392 |
* NULL�������f�t�H���g�t�@�C���������� |
| 1393 |
* strftime�`��ok |
| 1394 |
* @return �t���p�X�t�@�C���� |
| 1395 |
* �s�v���������� free() �������� |
| 1396 |
*/ |
| 1397 |
wchar_t *FLogGetLogFilename(const wchar_t *log_filename) |
| 1398 |
{ |
| 1399 |
// �t�H���_ |
| 1400 |
char FileDirExpanded[MAX_PATH]; |
| 1401 |
const char *logdir; |
| 1402 |
if (strlen(ts.LogDefaultPath) > 0) { |
| 1403 |
logdir = ts.LogDefaultPath; |
| 1404 |
} |
| 1405 |
else if (strlen(ts.FileDir) > 0) { |
| 1406 |
ExpandEnvironmentStrings(ts.FileDir, FileDirExpanded, sizeof(FileDirExpanded)); |
| 1407 |
logdir = FileDirExpanded; |
| 1408 |
} |
| 1409 |
else { |
| 1410 |
logdir = ts.HomeDir; |
| 1411 |
} |
| 1412 |
|
| 1413 |
// ���������t�@�C���� |
| 1414 |
char base_name[MAX_PATH]; |
| 1415 |
if (log_filename == NULL) { |
| 1416 |
strncpy_s(base_name, _countof(base_name), ts.LogDefaultName, _TRUNCATE); |
| 1417 |
} |
| 1418 |
else { |
| 1419 |
char *filenameA = ToCharW(log_filename); |
| 1420 |
strncpy_s(base_name, _countof(base_name), filenameA, _TRUNCATE); |
| 1421 |
free(filenameA); |
| 1422 |
} |
| 1423 |
|
| 1424 |
// �t���p�X�� |
| 1425 |
char full_path[MAX_PATH]; |
| 1426 |
ConvFName(logdir, base_name, sizeof(base_name), "", full_path, sizeof(full_path)); |
| 1427 |
ParseStrftimeFileName(full_path, sizeof(full_path)); |
| 1428 |
ConvertLogname(full_path, sizeof(full_path)); |
| 1429 |
|
| 1430 |
return ToWcharA(full_path); |
| 1431 |
} |
| 1432 |
|
| 1433 |
BOOL FLogIsPause() |
| 1434 |
{ |
| 1435 |
if (LogVar == NULL) { |
| 1436 |
return FALSE; |
| 1437 |
} |
| 1438 |
return LogVar->IsPause; |
| 1439 |
} |
| 1440 |
|
| 1441 |
void FLogWindow(int nCmdShow) |
| 1442 |
{ |
| 1443 |
if (LogVar == NULL) { |
| 1444 |
return; |
| 1445 |
} |
| 1446 |
|
| 1447 |
HWND HWndLog = LogVar->FLogDlg->m_hWnd; |
| 1448 |
ShowWindow(HWndLog, nCmdShow); |
| 1449 |
if (nCmdShow == SW_RESTORE) { |
| 1450 |
// �g���X�^�C�� WS_EX_NOACTIVATE �������������� |
| 1451 |
SetForegroundWindow(HWndLog); |
| 1452 |
} |
| 1453 |
} |
| 1454 |
|
| 1455 |
void FLogShowDlg(void) |
| 1456 |
{ |
| 1457 |
if (LogVar == NULL) { |
| 1458 |
return; |
| 1459 |
} |
| 1460 |
HWND HWndLog = LogVar->FLogDlg->m_hWnd; |
| 1461 |
ShowWindow(HWndLog, SW_SHOWNORMAL); |
| 1462 |
SetForegroundWindow(HWndLog); |
| 1463 |
} |
| 1464 |
|
| 1465 |
/** |
| 1466 |
* ���O��1byte�������� |
| 1467 |
* LogPut1() ������? |
| 1468 |
*/ |
| 1469 |
//void Log1Bin(PComVar cv, BYTE b) |
| 1470 |
static void Log1Bin(BYTE b) |
| 1471 |
{ |
| 1472 |
if (LogVar->IsPause || cv.ProtoFlag) { |
| 1473 |
return; |
| 1474 |
} |
| 1475 |
if (cv_BinSkip > 0) { |
| 1476 |
cv_BinSkip--; |
| 1477 |
return; |
| 1478 |
} |
| 1479 |
cv_BinBuf[cv_BinPtr] = b; |
| 1480 |
cv_BinPtr++; |
| 1481 |
if (cv_BinPtr>=InBuffSize) { |
| 1482 |
cv_BinPtr = cv_BinPtr-InBuffSize; |
| 1483 |
} |
| 1484 |
if (cv_BCount>=InBuffSize) { |
| 1485 |
cv_BCount = InBuffSize; |
| 1486 |
cv_BStart = cv_BinPtr; |
| 1487 |
} |
| 1488 |
else { |
| 1489 |
cv_BCount++; |
| 1490 |
} |
| 1491 |
} |
| 1492 |
|
| 1493 |
static void LogBinSkip(int add) |
| 1494 |
{ |
| 1495 |
if (cv_BinBuf != NULL) { |
| 1496 |
cv_BinSkip += add; |
| 1497 |
} |
| 1498 |
} |
| 1499 |
|
| 1500 |
/** |
| 1501 |
* ���O�o�b�t�@���������������f�[�^���o�C�g�������� |
| 1502 |
*/ |
| 1503 |
int FLogGetCount(void) |
| 1504 |
{ |
| 1505 |
if (FileLog) { |
| 1506 |
return cv_LCount; |
| 1507 |
} |
| 1508 |
if (BinLog) { |
| 1509 |
return cv_BCount; |
| 1510 |
} |
| 1511 |
return 0; |
| 1512 |
} |
| 1513 |
|
| 1514 |
/** |
| 1515 |
* ���O�o�b�t�@�������o�C�g�������� |
| 1516 |
*/ |
| 1517 |
int FLogGetFreeCount(void) |
| 1518 |
{ |
| 1519 |
if (FileLog) { |
| 1520 |
return InBuffSize - cv_LCount; |
| 1521 |
} |
| 1522 |
if (BinLog) { |
| 1523 |
return InBuffSize - cv_BCount; |
| 1524 |
} |
| 1525 |
return 0; |
| 1526 |
} |
| 1527 |
|
| 1528 |
/** |
| 1529 |
* �o�b�t�@�������O���t�@�C������������ |
| 1530 |
*/ |
| 1531 |
void FLogWriteFile(void) |
| 1532 |
{ |
| 1533 |
if (cv_LogBuf!=NULL) |
| 1534 |
{ |
| 1535 |
if (FileLog) { |
| 1536 |
LogToFile(); |
| 1537 |
} |
| 1538 |
} |
| 1539 |
|
| 1540 |
if (cv_BinBuf!=NULL) |
| 1541 |
{ |
| 1542 |
if (BinLog) { |
| 1543 |
LogToFile(); |
| 1544 |
} |
| 1545 |
// GlobalUnlock(cv_HBinBuf); |
| 1546 |
// cv_BinBuf = NULL; |
| 1547 |
} |
| 1548 |
} |
| 1549 |
|
| 1550 |
void FLogPutUTF32(unsigned int u32) |
| 1551 |
{ |
| 1552 |
PFileVar fv = LogVar; |
| 1553 |
size_t i; |
| 1554 |
BOOL log_available = (cv_LogBuf != 0); |
| 1555 |
|
| 1556 |
if (!log_available) { |
| 1557 |
// ���O�����o�������� |
| 1558 |
return; |
| 1559 |
} |
| 1560 |
|
| 1561 |
switch(fv->log_code) { |
| 1562 |
case 0: { |
| 1563 |
// UTF-8 |
| 1564 |
char u8_buf[4]; |
| 1565 |
size_t u8_len = UTF32ToUTF8(u32, u8_buf, _countof(u8_buf)); |
| 1566 |
for (i = 0; i < u8_len; i++) { |
| 1567 |
BYTE b = u8_buf[i]; |
| 1568 |
LogPut1(b); |
| 1569 |
} |
| 1570 |
break; |
| 1571 |
} |
| 1572 |
case 1: |
| 1573 |
case 2: { |
| 1574 |
// UTF-16 |
| 1575 |
wchar_t u16[2]; |
| 1576 |
size_t u16_len = UTF32ToUTF16(u32, u16, _countof(u16)); |
| 1577 |
size_t i; |
| 1578 |
for (i = 0; i < u16_len; i++) { |
| 1579 |
if (fv->log_code == 1) { |
| 1580 |
// UTF-16LE |
| 1581 |
LogPut1(u16[i] & 0xff); |
| 1582 |
LogPut1((u16[i] >> 8) & 0xff); |
| 1583 |
} |
| 1584 |
else { |
| 1585 |
// UTF-16BE |
| 1586 |
LogPut1((u16[i] >> 8) & 0xff); |
| 1587 |
LogPut1(u16[i] & 0xff); |
| 1588 |
} |
| 1589 |
} |
| 1590 |
} |
| 1591 |
} |
| 1592 |
} |
| 1593 |
|
| 1594 |
void FLogOutputBOM(void) |
| 1595 |
{ |
| 1596 |
PFileVar fv = LogVar; |
| 1597 |
|
| 1598 |
switch(fv->log_code) { |
| 1599 |
case 0: |
| 1600 |
// UTF-8 |
| 1601 |
LogPut1(0xef); |
| 1602 |
LogPut1(0xbb); |
| 1603 |
LogPut1(0xbf); |
| 1604 |
break; |
| 1605 |
case 1: |
| 1606 |
// UTF-16LE |
| 1607 |
LogPut1(0xfe); |
| 1608 |
LogPut1(0xff); |
| 1609 |
break; |
| 1610 |
case 2: |
| 1611 |
// UTF-16BE |
| 1612 |
LogPut1(0xff); |
| 1613 |
LogPut1(0xfe); |
| 1614 |
break; |
| 1615 |
default: |
| 1616 |
break; |
| 1617 |
} |
| 1618 |
} |
| 1619 |
|
| 1620 |
void FLogSetCode(int code) |
| 1621 |
{ |
| 1622 |
PFileVar fv = LogVar; |
| 1623 |
fv->log_code = code; |
| 1624 |
} |
| 1625 |
|
| 1626 |
static void OutputStr(const wchar_t *str) |
| 1627 |
{ |
| 1628 |
size_t len; |
| 1629 |
|
| 1630 |
assert(str != NULL); |
| 1631 |
|
| 1632 |
len = wcslen(str); |
| 1633 |
while(*str != 0) { |
| 1634 |
unsigned int u32; |
| 1635 |
size_t u16_len = UTF16ToUTF32(str, len, &u32); |
| 1636 |
switch (u16_len) { |
| 1637 |
case 0: |
| 1638 |
default: |
| 1639 |
// ������������ |
| 1640 |
str++; |
| 1641 |
len--; |
| 1642 |
break; |
| 1643 |
case 1: |
| 1644 |
case 2: { |
| 1645 |
FLogPutUTF32(u32); |
| 1646 |
str += u16_len; |
| 1647 |
len -= u16_len; |
| 1648 |
break; |
| 1649 |
} |
| 1650 |
} |
| 1651 |
} |
| 1652 |
} |
Tera Term
Parent Directory
Revision Log