1 |
/* Tera Term |
2 |
Copyright(C) 1994-1998 T. Teranishi |
3 |
All rights reserved. */ |
4 |
|
5 |
/* TERATERM.EXE, file transfer routines */ |
6 |
#include "stdafx.h" |
7 |
#include "teraterm.h" |
8 |
#include "tttypes.h" |
9 |
#include "ttftypes.h" |
10 |
#include "tt_res.h" |
11 |
#include "ftdlg.h" |
12 |
#include "protodlg.h" |
13 |
#include "ttwinman.h" |
14 |
#include "commlib.h" |
15 |
#include "ttcommon.h" |
16 |
#include "ttdde.h" |
17 |
#include "ttlib.h" |
18 |
#include "helpid.h" |
19 |
#include "dlglib.h" |
20 |
|
21 |
#include "filesys.h" |
22 |
#include "ftlib.h" |
23 |
|
24 |
PFileVar LogVar = NULL; |
25 |
PFileVar SendVar = NULL; |
26 |
PFileVar FileVar = NULL; |
27 |
static PCHAR ProtoVar = NULL; |
28 |
static int ProtoId; |
29 |
|
30 |
static BYTE LogLast = 0; |
31 |
BOOL FileLog = FALSE; |
32 |
BOOL BinLog = FALSE; |
33 |
BOOL DDELog = FALSE; |
34 |
static BOOL FileRetrySend, FileRetryEcho, FileCRSend; |
35 |
static BYTE FileByte; |
36 |
|
37 |
static BOOL FSend = FALSE; |
38 |
|
39 |
HWND HWndLog = NULL; //steven add |
40 |
|
41 |
static HMODULE HTTFILE = NULL; |
42 |
static int TTFILECount = 0; |
43 |
|
44 |
PGetSetupFname GetSetupFname; |
45 |
PGetTransFname GetTransFname; |
46 |
PGetMultiFname GetMultiFname; |
47 |
PGetGetFname GetGetFname; |
48 |
PSetFileVar SetFileVar; |
49 |
PGetXFname GetXFname; |
50 |
PProtoInit ProtoInit; |
51 |
PProtoParse ProtoParse; |
52 |
PProtoTimeOutProc ProtoTimeOutProc; |
53 |
PProtoCancel ProtoCancel; |
54 |
|
55 |
#define IdGetSetupFname 1 |
56 |
#define IdGetTransFname 2 |
57 |
#define IdGetMultiFname 3 |
58 |
#define IdGetGetFname 4 |
59 |
#define IdSetFileVar 5 |
60 |
#define IdGetXFname 6 |
61 |
|
62 |
#define IdProtoInit 7 |
63 |
#define IdProtoParse 8 |
64 |
#define IdProtoTimeOutProc 9 |
65 |
#define IdProtoCancel 10 |
66 |
|
67 |
/* |
68 |
Line Head flag for timestamping |
69 |
2007.05.24 Gentaro |
70 |
*/ |
71 |
enum enumLineEnd { |
72 |
Line_Other = 0, |
73 |
Line_LineHead = 1, |
74 |
Line_FileHead = 2, |
75 |
}; |
76 |
|
77 |
enum enumLineEnd eLineEnd = Line_LineHead; |
78 |
|
79 |
BOOL LoadTTFILE() |
80 |
{ |
81 |
BOOL Err; |
82 |
|
83 |
if (HTTFILE != NULL) |
84 |
{ |
85 |
TTFILECount++; |
86 |
return TRUE; |
87 |
} |
88 |
else |
89 |
TTFILECount = 0; |
90 |
|
91 |
HTTFILE = LoadLibrary("TTPFILE.DLL"); |
92 |
if (HTTFILE == NULL) |
93 |
return FALSE; |
94 |
|
95 |
TTFILESetUILanguageFile(ts.UILanguageFile); |
96 |
TTFILESetFileSendFilter(ts.FileSendFilter); |
97 |
|
98 |
Err = FALSE; |
99 |
GetSetupFname = (PGetSetupFname)GetProcAddress(HTTFILE, |
100 |
MAKEINTRESOURCE(IdGetSetupFname)); |
101 |
if (GetSetupFname==NULL) |
102 |
Err = TRUE; |
103 |
|
104 |
GetTransFname = (PGetTransFname)GetProcAddress(HTTFILE, |
105 |
MAKEINTRESOURCE(IdGetTransFname)); |
106 |
if (GetTransFname==NULL) |
107 |
Err = TRUE; |
108 |
|
109 |
GetMultiFname = (PGetMultiFname)GetProcAddress(HTTFILE, |
110 |
MAKEINTRESOURCE(IdGetMultiFname)); |
111 |
if (GetMultiFname==NULL) |
112 |
Err = TRUE; |
113 |
|
114 |
GetGetFname = (PGetGetFname)GetProcAddress(HTTFILE, |
115 |
MAKEINTRESOURCE(IdGetGetFname)); |
116 |
if (GetGetFname==NULL) |
117 |
Err = TRUE; |
118 |
|
119 |
SetFileVar = (PSetFileVar)GetProcAddress(HTTFILE, |
120 |
MAKEINTRESOURCE(IdSetFileVar)); |
121 |
if (SetFileVar==NULL) |
122 |
Err = TRUE; |
123 |
|
124 |
GetXFname = (PGetXFname)GetProcAddress(HTTFILE, |
125 |
MAKEINTRESOURCE(IdGetXFname)); |
126 |
if (GetXFname==NULL) |
127 |
Err = TRUE; |
128 |
|
129 |
ProtoInit = (PProtoInit)GetProcAddress(HTTFILE, |
130 |
MAKEINTRESOURCE(IdProtoInit)); |
131 |
if (ProtoInit==NULL) |
132 |
Err = TRUE; |
133 |
|
134 |
ProtoParse = (PProtoParse)GetProcAddress(HTTFILE, |
135 |
MAKEINTRESOURCE(IdProtoParse)); |
136 |
if (ProtoParse==NULL) |
137 |
Err = TRUE; |
138 |
|
139 |
ProtoTimeOutProc = (PProtoTimeOutProc)GetProcAddress(HTTFILE, |
140 |
MAKEINTRESOURCE(IdProtoTimeOutProc)); |
141 |
if (ProtoTimeOutProc==NULL) |
142 |
Err = TRUE; |
143 |
|
144 |
ProtoCancel = (PProtoCancel)GetProcAddress(HTTFILE, |
145 |
MAKEINTRESOURCE(IdProtoCancel)); |
146 |
if (ProtoCancel==NULL) |
147 |
Err = TRUE; |
148 |
|
149 |
if (Err) |
150 |
{ |
151 |
FreeLibrary(HTTFILE); |
152 |
HTTFILE = NULL; |
153 |
return FALSE; |
154 |
} |
155 |
else { |
156 |
TTFILECount = 1; |
157 |
return TRUE; |
158 |
} |
159 |
} |
160 |
|
161 |
BOOL FreeTTFILE() |
162 |
{ |
163 |
if (TTFILECount==0) |
164 |
return FALSE; |
165 |
TTFILECount--; |
166 |
if (TTFILECount>0) |
167 |
return TRUE; |
168 |
if (HTTFILE!=NULL) |
169 |
{ |
170 |
FreeLibrary(HTTFILE); |
171 |
HTTFILE = NULL; |
172 |
} |
173 |
return TRUE; |
174 |
} |
175 |
|
176 |
static PFileTransDlg FLogDlg = NULL; |
177 |
static PFileTransDlg SendDlg = NULL; |
178 |
static PProtoDlg PtDlg = NULL; |
179 |
|
180 |
BOOL OpenFTDlg(PFileVar fv) |
181 |
{ |
182 |
PFileTransDlg FTDlg; |
183 |
HWND HFTDlg; |
184 |
char uimsg[MAX_UIMSG]; |
185 |
|
186 |
FTDlg = new CFileTransDlg(); |
187 |
|
188 |
if (FTDlg!=NULL) |
189 |
{ |
190 |
FTDlg->Create(fv, &cv, &ts); |
191 |
FTDlg->RefreshNum(); |
192 |
if (fv->OpId == OpLog) { |
193 |
HWndLog = FTDlg->m_hWnd; // steven add |
194 |
} |
195 |
} |
196 |
|
197 |
if (fv->OpId==OpLog) |
198 |
FLogDlg = FTDlg; /* Log */ |
199 |
else |
200 |
SendDlg = FTDlg; /* File send */ |
201 |
|
202 |
HFTDlg=FTDlg->GetSafeHwnd(); |
203 |
|
204 |
GetDlgItemText(HFTDlg, IDC_TRANS_FILENAME, uimsg, sizeof(uimsg)); |
205 |
get_lang_msg("DLG_FILETRANS_FILENAME", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
206 |
SetDlgItemText(HFTDlg, IDC_TRANS_FILENAME, ts.UIMsg); |
207 |
GetDlgItemText(HFTDlg, IDC_FULLPATH_LABEL, uimsg, sizeof(uimsg)); |
208 |
get_lang_msg("DLG_FILETRANS_FULLPATH", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
209 |
SetDlgItemText(HFTDlg, IDC_FULLPATH_LABEL, ts.UIMsg); |
210 |
GetDlgItemText(HFTDlg, IDC_TRANS_TRANS, uimsg, sizeof(uimsg)); |
211 |
get_lang_msg("DLG_FILETRANS_TRNAS", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
212 |
SetDlgItemText(HFTDlg, IDC_TRANS_TRANS, ts.UIMsg); |
213 |
GetDlgItemText(HFTDlg, IDCANCEL, uimsg, sizeof(uimsg)); |
214 |
get_lang_msg("DLG_FILETRANS_CLOSE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
215 |
SetDlgItemText(HFTDlg, IDCANCEL, ts.UIMsg); |
216 |
GetDlgItemText(HFTDlg, IDC_TRANSPAUSESTART, uimsg, sizeof(uimsg)); |
217 |
get_lang_msg("DLG_FILETRANS_PAUSE", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
218 |
SetDlgItemText(HFTDlg, IDC_TRANSPAUSESTART, ts.UIMsg); |
219 |
GetDlgItemText(HFTDlg, IDC_TRANSHELP, uimsg, sizeof(uimsg)); |
220 |
get_lang_msg("BTN_HELP", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
221 |
SetDlgItemText(HFTDlg, IDC_TRANSHELP, ts.UIMsg); |
222 |
|
223 |
if (fv->OpId == OpSendFile) { |
224 |
InitDlgProgress(HFTDlg, IDC_TRANSPROGRESS, &fv->ProgStat); |
225 |
} |
226 |
else { |
227 |
fv->ProgStat = -1; |
228 |
} |
229 |
|
230 |
return (FTDlg!=NULL); |
231 |
} |
232 |
|
233 |
void ShowFTDlg(WORD OpId) |
234 |
{ |
235 |
if (OpId == OpLog) { |
236 |
if (FLogDlg != NULL) { |
237 |
FLogDlg->ShowWindow(SW_SHOWNORMAL); |
238 |
} |
239 |
} |
240 |
else { |
241 |
if (SendDlg != NULL) { |
242 |
SendDlg->ShowWindow(SW_SHOWNORMAL); |
243 |
} |
244 |
} |
245 |
} |
246 |
|
247 |
BOOL NewFileVar(PFileVar *fv) |
248 |
{ |
249 |
if ((*fv)==NULL) |
250 |
{ |
251 |
*fv = (PFileVar)malloc(sizeof(TFileVar)); |
252 |
if ((*fv)!=NULL) |
253 |
{ |
254 |
memset(*fv, 0, sizeof(TFileVar)); |
255 |
strncpy_s((*fv)->FullName, sizeof((*fv)->FullName),ts.FileDir, _TRUNCATE); |
256 |
AppendSlash((*fv)->FullName,sizeof((*fv)->FullName)); |
257 |
(*fv)->DirLen = strlen((*fv)->FullName); |
258 |
(*fv)->FileOpen = FALSE; |
259 |
(*fv)->OverWrite = ((ts.FTFlag & FT_RENAME) == 0); |
260 |
(*fv)->HMainWin = HVTWin; |
261 |
(*fv)->Success = FALSE; |
262 |
(*fv)->NoMsg = FALSE; |
263 |
(*fv)->HideDialog = FALSE; |
264 |
} |
265 |
} |
266 |
|
267 |
return ((*fv)!=NULL); |
268 |
} |
269 |
|
270 |
void FreeFileVar(PFileVar *fv) |
271 |
{ |
272 |
if ((*fv)!=NULL) |
273 |
{ |
274 |
if ((*fv)->FileOpen) _lclose((*fv)->FileHandle); |
275 |
if ((*fv)->FnStrMemHandle>0) |
276 |
{ |
277 |
GlobalUnlock((*fv)->FnStrMemHandle); |
278 |
GlobalFree((*fv)->FnStrMemHandle); |
279 |
} |
280 |
free(*fv); |
281 |
*fv = NULL; |
282 |
} |
283 |
} |
284 |
|
285 |
// &h ���z�X�g�����u�� (2007.5.14) |
286 |
// &p ��TCP�|�[�g�������u�� (2009.6.12) |
287 |
void ConvertLogname(char *c, int destlen) |
288 |
{ |
289 |
char buf[MAXPATHLEN], buf2[MAXPATHLEN], *p = c; |
290 |
|
291 |
memset(buf, 0, sizeof(buf)); |
292 |
|
293 |
while(*p != '\0') { |
294 |
if (*p == '&' && *(p+1) != '\0') { |
295 |
switch (*(p+1)) { |
296 |
case 'h': |
297 |
if (cv.Open) { |
298 |
if (cv.PortType == IdTCPIP) { |
299 |
strncat_s(buf,sizeof(buf),ts.HostName,_TRUNCATE); |
300 |
} |
301 |
else if (cv.PortType == IdSerial) { |
302 |
strncpy_s(buf2,sizeof(buf2),buf,_TRUNCATE); |
303 |
_snprintf_s(buf, sizeof(buf), _TRUNCATE, "%sCOM%d", buf2, ts.ComPort); |
304 |
} |
305 |
} |
306 |
break; |
307 |
case 'p': |
308 |
if (cv.Open) { |
309 |
if (cv.PortType == IdTCPIP) { |
310 |
char port[6]; |
311 |
_snprintf_s(port, sizeof(port), _TRUNCATE, "%d", ts.TCPPort); |
312 |
strncat_s(buf,sizeof(buf),port,_TRUNCATE); |
313 |
} |
314 |
} |
315 |
break; |
316 |
default: |
317 |
strncpy_s(buf2,sizeof(buf2),p,2); |
318 |
strncat_s(buf,sizeof(buf),buf2,_TRUNCATE); |
319 |
} |
320 |
p++; |
321 |
} |
322 |
else { |
323 |
strncpy_s(buf2,sizeof(buf2),p,1); |
324 |
strncat_s(buf,sizeof(buf),buf2,_TRUNCATE); |
325 |
} |
326 |
p++; |
327 |
} |
328 |
strncpy_s(c, destlen, buf, _TRUNCATE); |
329 |
} |
330 |
|
331 |
void FixLogOption() |
332 |
{ |
333 |
if (ts.TransBin) { |
334 |
ts.LogTypePlainText = false; |
335 |
ts.LogTimestamp = false; |
336 |
} |
337 |
} |
338 |
|
339 |
extern "C" { |
340 |
BOOL LogStart() |
341 |
{ |
342 |
LONG Option; |
343 |
char *logdir; |
344 |
|
345 |
if ((FileLog) || (BinLog)) return FALSE; |
346 |
|
347 |
if (! LoadTTFILE()) return FALSE; |
348 |
if (! NewFileVar(&LogVar)) |
349 |
{ |
350 |
FreeTTFILE(); |
351 |
return FALSE; |
352 |
} |
353 |
LogVar->OpId = OpLog; |
354 |
|
355 |
if (strlen(ts.LogDefaultPath) > 0) { |
356 |
logdir = ts.LogDefaultPath; |
357 |
} |
358 |
else if (strlen(ts.FileDir) > 0) { |
359 |
logdir = ts.FileDir; |
360 |
} |
361 |
else { |
362 |
logdir = ts.HomeDir; |
363 |
} |
364 |
|
365 |
if (strlen(&(LogVar->FullName[LogVar->DirLen]))==0) |
366 |
{ |
367 |
// LOWORD |
368 |
// 0x0001 = Binary |
369 |
// HIWORD |
370 |
// 0x0001 = Append |
371 |
// 0x1000 = plain text (2005.2.20 yutaka) |
372 |
// 0x2000 = timestamp (2006.7.23 maya) |
373 |
// 0x4000 = hide file transfer dialog (2008.1.30 maya) |
374 |
// teraterm.ini�����������������f�t�H���g�I�v�V�������������B(2005.5.7 yutaka) |
375 |
Option = MAKELONG(ts.TransBin, |
376 |
ts.Append | |
377 |
(0x1000 * ts.LogTypePlainText) | |
378 |
(0x2000 * ts.LogTimestamp) | |
379 |
(0x4000 * ts.LogHideDialog)); |
380 |
|
381 |
// ���O���f�t�H���g�t�@�C���������� (2006.8.28 maya) |
382 |
strncat_s(LogVar->FullName, sizeof(LogVar->FullName), ts.LogDefaultName, _TRUNCATE); |
383 |
|
384 |
ParseStrftimeFileName(LogVar->FullName, sizeof(LogVar->FullName)); |
385 |
|
386 |
// &h ���z�X�g�����u�� (2007.5.14) |
387 |
ConvertLogname(LogVar->FullName, sizeof(LogVar->FullName)); |
388 |
|
389 |
strncpy_s(LogVar->LogDefaultPath, sizeof(LogVar->LogDefaultPath), ts.LogDefaultPath, _TRUNCATE); |
390 |
if (! (*GetTransFname)(LogVar, logdir, GTF_LOG, &Option)) |
391 |
{ |
392 |
FreeFileVar(&LogVar); |
393 |
FreeTTFILE(); |
394 |
return FALSE; |
395 |
} |
396 |
ts.TransBin = LOWORD(Option); |
397 |
ts.Append = HIWORD(Option); |
398 |
|
399 |
if (ts.Append & 0x1000) { |
400 |
ts.LogTypePlainText = 1; |
401 |
} else { |
402 |
ts.LogTypePlainText = 0; |
403 |
} |
404 |
|
405 |
if (ts.Append & 0x2000) { |
406 |
ts.LogTimestamp = 1; |
407 |
} |
408 |
else { |
409 |
ts.LogTimestamp = 0; |
410 |
} |
411 |
|
412 |
if (ts.Append & 0x4000) { |
413 |
ts.LogHideDialog = 1; |
414 |
} |
415 |
else { |
416 |
ts.LogHideDialog = 0; |
417 |
} |
418 |
|
419 |
ts.Append &= 0x1; // 1bit���}�X�N���� |
420 |
|
421 |
} |
422 |
else { |
423 |
// LogVar->DirLen = 0 �������������� |
424 |
// �t���p�X�E�����p�X������ LogVar->FullName �������������K�v������ |
425 |
char FileName[MAX_PATH]; |
426 |
|
427 |
// �t���p�X�� |
428 |
strncpy_s(FileName, sizeof(FileName), LogVar->FullName, _TRUNCATE); |
429 |
ConvFName(logdir,FileName,sizeof(FileName),"",LogVar->FullName,sizeof(LogVar->FullName)); |
430 |
|
431 |
ParseStrftimeFileName(LogVar->FullName, sizeof(LogVar->FullName)); |
432 |
|
433 |
// &h ���z�X�g�����u�� (2007.5.14) |
434 |
ConvertLogname(LogVar->FullName, sizeof(LogVar->FullName)); |
435 |
(*SetFileVar)(LogVar); |
436 |
|
437 |
FixLogOption(); |
438 |
} |
439 |
|
440 |
if (ts.TransBin > 0) |
441 |
{ |
442 |
BinLog = TRUE; |
443 |
FileLog = FALSE; |
444 |
if (! CreateBinBuf()) |
445 |
{ |
446 |
FileTransEnd(OpLog); |
447 |
return FALSE; |
448 |
} |
449 |
} |
450 |
else { |
451 |
BinLog = FALSE; |
452 |
FileLog = TRUE; |
453 |
if (! CreateLogBuf()) |
454 |
{ |
455 |
FileTransEnd(OpLog); |
456 |
return FALSE; |
457 |
} |
458 |
} |
459 |
cv.LStart = cv.LogPtr; |
460 |
cv.LCount = 0; |
461 |
if (ts.LogHideDialog) |
462 |
LogVar->HideDialog = 1; |
463 |
|
464 |
HelpId = HlpFileLog; |
465 |
/* 2007.05.24 Gentaro */ |
466 |
eLineEnd = Line_LineHead; |
467 |
|
468 |
if (ts.Append > 0) |
469 |
{ |
470 |
LogVar->FileHandle = _lopen(LogVar->FullName,OF_WRITE); |
471 |
if (LogVar->FileHandle>0){ |
472 |
_llseek(LogVar->FileHandle,0,2); |
473 |
/* 2007.05.24 Gentaro |
474 |
If log file already exists, |
475 |
a newline is inserted before the first timestamp. |
476 |
*/ |
477 |
eLineEnd = Line_FileHead; |
478 |
} |
479 |
else |
480 |
LogVar->FileHandle = _lcreat(LogVar->FullName,0); |
481 |
} |
482 |
else |
483 |
LogVar->FileHandle = _lcreat(LogVar->FullName,0); |
484 |
LogVar->FileOpen = (LogVar->FileHandle>0); |
485 |
if (! LogVar->FileOpen) |
486 |
{ |
487 |
char msg[128]; |
488 |
|
489 |
// �t�@�C���I�[�v���G���[�������b�Z�[�W�\�������������B(2008.7.9 yutaka) |
490 |
if (LogVar->NoMsg == FALSE) { |
491 |
_snprintf_s(msg, sizeof(msg), _TRUNCATE, "Can not create a `%s' file. (%d)", LogVar->FullName, GetLastError()); |
492 |
MessageBox(NULL, msg, "Tera Term: File open error", MB_OK | MB_ICONERROR); |
493 |
} |
494 |
|
495 |
FileTransEnd(OpLog); |
496 |
return FALSE; |
497 |
} |
498 |
LogVar->ByteCount = 0; |
499 |
|
500 |
if (! OpenFTDlg(LogVar)) { |
501 |
FileTransEnd(OpLog); |
502 |
return FALSE; |
503 |
} |
504 |
|
505 |
return TRUE; |
506 |
} |
507 |
} |
508 |
|
509 |
void LogPut1(BYTE b) |
510 |
{ |
511 |
LogLast = b; |
512 |
cv.LogBuf[cv.LogPtr] = b; |
513 |
cv.LogPtr++; |
514 |
if (cv.LogPtr>=InBuffSize) |
515 |
cv.LogPtr = cv.LogPtr-InBuffSize; |
516 |
|
517 |
if (FileLog) |
518 |
{ |
519 |
if (cv.LCount>=InBuffSize) |
520 |
{ |
521 |
cv.LCount = InBuffSize; |
522 |
cv.LStart = cv.LogPtr; |
523 |
} |
524 |
else |
525 |
cv.LCount++; |
526 |
} |
527 |
else |
528 |
cv.LCount = 0; |
529 |
|
530 |
if (DDELog) |
531 |
{ |
532 |
if (cv.DCount>=InBuffSize) |
533 |
{ |
534 |
cv.DCount = InBuffSize; |
535 |
cv.DStart = cv.LogPtr; |
536 |
} |
537 |
else |
538 |
cv.DCount++; |
539 |
} |
540 |
else { |
541 |
cv.DCount = 0; |
542 |
// ���O���������}�N�����X�g�[���������������C���B |
543 |
// ���O�����������x�}�N�����~�������A�o�b�t�@���C���f�b�N�X�������������������A |
544 |
// ���x�}�N�������������������f�[�^�������������������B |
545 |
// �}�N�������~���������������C���f�b�N�X�����������������������B |
546 |
// (2006.12.26 yutaka) |
547 |
cv.DStart = cv.LogPtr; |
548 |
} |
549 |
} |
550 |
|
551 |
void Log1Byte(BYTE b) |
552 |
{ |
553 |
if (b==0x0d) |
554 |
{ |
555 |
LogLast = b; |
556 |
return; |
557 |
} |
558 |
if ((b==0x0a) && (LogLast==0x0d)) |
559 |
LogPut1(0x0d); |
560 |
LogPut1(b); |
561 |
} |
562 |
|
563 |
static BOOL Get1(PCHAR Buf, int *Start, int *Count, PBYTE b) |
564 |
{ |
565 |
if (*Count<=0) return FALSE; |
566 |
*b = Buf[*Start]; |
567 |
(*Start)++; |
568 |
if (*Start>=InBuffSize) |
569 |
*Start = *Start-InBuffSize; |
570 |
(*Count)--; |
571 |
return TRUE; |
572 |
} |
573 |
|
574 |
|
575 |
|
576 |
static CRITICAL_SECTION g_filelog_lock; /* ���b�N�p���� */ |
577 |
|
578 |
void logfile_lock_initialize(void) |
579 |
{ |
580 |
InitializeCriticalSection(&g_filelog_lock); |
581 |
} |
582 |
|
583 |
static inline void logfile_lock(void) |
584 |
{ |
585 |
EnterCriticalSection(&g_filelog_lock); |
586 |
} |
587 |
|
588 |
static inline void logfile_unlock(void) |
589 |
{ |
590 |
LeaveCriticalSection(&g_filelog_lock); |
591 |
} |
592 |
|
593 |
// �R�����g�����O���������� |
594 |
void CommentLogToFile(char *buf, int size) |
595 |
{ |
596 |
DWORD wrote; |
597 |
|
598 |
if (LogVar == NULL || !LogVar->FileOpen) { |
599 |
char uimsg[MAX_UIMSG]; |
600 |
get_lang_msg("MSG_ERROR", uimsg, sizeof(uimsg), "ERROR", ts.UILanguageFile); |
601 |
get_lang_msg("MSG_COMMENT_LOG_OPEN_ERROR", ts.UIMsg, sizeof(ts.UIMsg), |
602 |
"It is not opened by the log file yet.", ts.UILanguageFile); |
603 |
::MessageBox(NULL, ts.UIMsg, uimsg, MB_OK|MB_ICONEXCLAMATION); |
604 |
return; |
605 |
} |
606 |
|
607 |
logfile_lock(); |
608 |
WriteFile((HANDLE)LogVar->FileHandle, buf, size, &wrote, NULL); |
609 |
WriteFile((HANDLE)LogVar->FileHandle, "\r\n", 2, &wrote, NULL); // ���s |
610 |
/* Set Line End Flag |
611 |
2007.05.24 Gentaro |
612 |
*/ |
613 |
eLineEnd = Line_LineHead; |
614 |
logfile_unlock(); |
615 |
} |
616 |
|
617 |
void LogToFile() |
618 |
{ |
619 |
PCHAR Buf; |
620 |
int Start, Count; |
621 |
BYTE b; |
622 |
|
623 |
if (! LogVar->FileOpen) return; |
624 |
if (FileLog) |
625 |
{ |
626 |
Buf = cv.LogBuf; |
627 |
Start = cv.LStart; |
628 |
Count = cv.LCount; |
629 |
} |
630 |
else if (BinLog) |
631 |
{ |
632 |
Buf = cv.BinBuf; |
633 |
Start = cv.BStart; |
634 |
Count = cv.BCount; |
635 |
} |
636 |
else |
637 |
return; |
638 |
|
639 |
if (Buf==NULL) return; |
640 |
if (Count==0) return; |
641 |
|
642 |
// ���b�N������(2004.8.6 yutaka) |
643 |
logfile_lock(); |
644 |
|
645 |
while (Get1(Buf,&Start,&Count,&b)) |
646 |
{ |
647 |
if (((cv.FilePause & OpLog)==0) && (! cv.ProtoFlag)) |
648 |
{ |
649 |
// �����������o��(2006.7.23 maya) |
650 |
// ���t�t�H�[�}�b�g�����{�����������E�W�������X���� (2006.7.23 yutaka) |
651 |
/* 2007.05.24 Gentaro */ |
652 |
if ( ts.LogTimestamp && eLineEnd ) { |
653 |
#if 1 |
654 |
#if 0 |
655 |
SYSTEMTIME LocalTime; |
656 |
GetLocalTime(&LocalTime); |
657 |
char strtime[27]; |
658 |
|
659 |
// format time |
660 |
sprintf(strtime, "[%04d/%02d/%02d %02d:%02d:%02d.%03d] ", |
661 |
LocalTime.wYear, LocalTime.wMonth,LocalTime.wDay, |
662 |
LocalTime.wHour, LocalTime.wMinute, LocalTime.wSecond, |
663 |
LocalTime.wMilliseconds); |
664 |
#else |
665 |
// �~���b���\���������������X (2009.5.23 maya) |
666 |
SYSTEMTIME LocalTime; |
667 |
GetLocalTime(&LocalTime); |
668 |
char strtime[29]; |
669 |
char week[][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; |
670 |
char month[][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
671 |
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; |
672 |
_snprintf_s(strtime, sizeof(strtime), _TRUNCATE, |
673 |
"%s %s %02d %02d:%02d:%02d.%03d %04d", |
674 |
week[LocalTime.wDayOfWeek], |
675 |
month[LocalTime.wMonth-1], |
676 |
LocalTime.wDay, |
677 |
LocalTime.wHour, |
678 |
LocalTime.wMinute, |
679 |
LocalTime.wSecond, |
680 |
LocalTime.wMilliseconds, |
681 |
LocalTime.wYear); |
682 |
#endif |
683 |
#else |
684 |
time_t tick = time(NULL); |
685 |
char *strtime = ctime(&tick); |
686 |
#endif |
687 |
/* 2007.05.24 Gentaro */ |
688 |
if( eLineEnd == Line_FileHead ){ |
689 |
_lwrite(LogVar->FileHandle,"\r\n",2); |
690 |
} |
691 |
_lwrite(LogVar->FileHandle,"[",1); |
692 |
_lwrite(LogVar->FileHandle, strtime, strlen(strtime)); |
693 |
_lwrite(LogVar->FileHandle,"] ",2); |
694 |
} |
695 |
|
696 |
/* 2007.05.24 Gentaro */ |
697 |
if( b == 0x0a ){ |
698 |
eLineEnd = Line_LineHead; /* set endmark*/ |
699 |
} |
700 |
else { |
701 |
eLineEnd = Line_Other; /* clear endmark*/ |
702 |
} |
703 |
|
704 |
_lwrite(LogVar->FileHandle,(PCHAR)&b,1); |
705 |
(LogVar->ByteCount)++; |
706 |
} |
707 |
} |
708 |
|
709 |
logfile_unlock(); |
710 |
|
711 |
if (FileLog) |
712 |
{ |
713 |
cv.LStart = Start; |
714 |
cv.LCount = Count; |
715 |
} |
716 |
else { |
717 |
cv.BStart = Start; |
718 |
cv.BCount = Count; |
719 |
} |
720 |
if (((cv.FilePause & OpLog) !=0) || cv.ProtoFlag) return; |
721 |
if (FLogDlg!=NULL) |
722 |
FLogDlg->RefreshNum(); |
723 |
} |
724 |
|
725 |
BOOL CreateLogBuf() |
726 |
{ |
727 |
if (cv.HLogBuf==NULL) |
728 |
{ |
729 |
cv.HLogBuf = GlobalAlloc(GMEM_MOVEABLE,InBuffSize); |
730 |
cv.LogBuf = NULL; |
731 |
cv.LogPtr = 0; |
732 |
cv.LStart = 0; |
733 |
cv.LCount = 0; |
734 |
cv.DStart = 0; |
735 |
cv.DCount = 0; |
736 |
} |
737 |
return (cv.HLogBuf!=NULL); |
738 |
} |
739 |
|
740 |
void FreeLogBuf() |
741 |
{ |
742 |
if ((cv.HLogBuf==NULL) || FileLog || DDELog) |
743 |
return; |
744 |
if (cv.LogBuf!=NULL) |
745 |
GlobalUnlock(cv.HLogBuf); |
746 |
GlobalFree(cv.HLogBuf); |
747 |
cv.HLogBuf = NULL; |
748 |
cv.LogBuf = NULL; |
749 |
cv.LogPtr = 0; |
750 |
cv.LStart = 0; |
751 |
cv.LCount = 0; |
752 |
cv.DStart = 0; |
753 |
cv.DCount = 0; |
754 |
} |
755 |
|
756 |
BOOL CreateBinBuf() |
757 |
{ |
758 |
if (cv.HBinBuf==NULL) |
759 |
{ |
760 |
cv.HBinBuf = GlobalAlloc(GMEM_MOVEABLE,InBuffSize); |
761 |
cv.BinBuf = NULL; |
762 |
cv.BinPtr = 0; |
763 |
cv.BStart = 0; |
764 |
cv.BCount = 0; |
765 |
} |
766 |
return (cv.HBinBuf!=NULL); |
767 |
} |
768 |
|
769 |
void FreeBinBuf() |
770 |
{ |
771 |
if ((cv.HBinBuf==NULL) || BinLog) |
772 |
return; |
773 |
if (cv.BinBuf!=NULL) |
774 |
GlobalUnlock(cv.HBinBuf); |
775 |
GlobalFree(cv.HBinBuf); |
776 |
cv.HBinBuf = NULL; |
777 |
cv.BinBuf = NULL; |
778 |
cv.BinPtr = 0; |
779 |
cv.BStart = 0; |
780 |
cv.BCount = 0; |
781 |
} |
782 |
|
783 |
extern "C" { |
784 |
void FileSendStart() |
785 |
{ |
786 |
LONG Option; |
787 |
|
788 |
if (! cv.Ready || FSend) return; |
789 |
if (cv.ProtoFlag) |
790 |
{ |
791 |
FreeFileVar(&SendVar); |
792 |
return; |
793 |
} |
794 |
|
795 |
if (! LoadTTFILE()) |
796 |
return; |
797 |
if (! NewFileVar(&SendVar)) |
798 |
{ |
799 |
FreeTTFILE(); |
800 |
return; |
801 |
} |
802 |
SendVar->OpId = OpSendFile; |
803 |
|
804 |
FSend = TRUE; |
805 |
|
806 |
if (strlen(&(SendVar->FullName[SendVar->DirLen]))==0) |
807 |
{ |
808 |
Option = MAKELONG(ts.TransBin,0); |
809 |
SendVar->FullName[0] = 0; |
810 |
if (! (*GetTransFname)(SendVar, ts.FileDir, GTF_SEND, &Option)) |
811 |
{ |
812 |
FileTransEnd(OpSendFile); |
813 |
return; |
814 |
} |
815 |
ts.TransBin = LOWORD(Option); |
816 |
} |
817 |
else |
818 |
(*SetFileVar)(SendVar); |
819 |
|
820 |
SendVar->FileHandle = _lopen(SendVar->FullName,OF_READ); |
821 |
SendVar->FileOpen = (SendVar->FileHandle>0); |
822 |
if (! SendVar->FileOpen) |
823 |
{ |
824 |
FileTransEnd(OpSendFile); |
825 |
return; |
826 |
} |
827 |
SendVar->ByteCount = 0; |
828 |
SendVar->FileSize = GetFSize(SendVar->FullName); |
829 |
|
830 |
TalkStatus = IdTalkFile; |
831 |
FileRetrySend = FALSE; |
832 |
FileRetryEcho = FALSE; |
833 |
FileCRSend = FALSE; |
834 |
|
835 |
if (! OpenFTDlg(SendVar)) |
836 |
FileTransEnd(OpSendFile); |
837 |
} |
838 |
} |
839 |
|
840 |
void FileTransEnd(WORD OpId) |
841 |
/* OpId = 0: close Log and FileSend |
842 |
OpLog: close Log |
843 |
OpSendFile: close FileSend */ |
844 |
{ |
845 |
if (((OpId==0) || (OpId==OpLog)) && (FileLog || BinLog)) |
846 |
{ |
847 |
FileLog = FALSE; |
848 |
BinLog = FALSE; |
849 |
if (FLogDlg!=NULL) |
850 |
{ |
851 |
FLogDlg->DestroyWindow(); |
852 |
FLogDlg = NULL; |
853 |
HWndLog = NULL; // steven add |
854 |
} |
855 |
FreeFileVar(&LogVar); |
856 |
FreeLogBuf(); |
857 |
FreeBinBuf(); |
858 |
FreeTTFILE(); |
859 |
} |
860 |
|
861 |
if (((OpId==0) || (OpId==OpSendFile)) && FSend) |
862 |
{ |
863 |
FSend = FALSE; |
864 |
TalkStatus = IdTalkKeyb; |
865 |
if (SendDlg!=NULL) |
866 |
{ |
867 |
SendDlg->DestroyWindow(); |
868 |
SendDlg = NULL; |
869 |
} |
870 |
FreeFileVar(&SendVar); |
871 |
FreeTTFILE(); |
872 |
} |
873 |
|
874 |
EndDdeCmnd(0); |
875 |
} |
876 |
|
877 |
// vtwin.cpp �����R�[�������������Aextern "C"���t�����B(2004.11.3 yutaka) |
878 |
extern "C" { |
879 |
int FSOut1(BYTE b) |
880 |
{ |
881 |
if (ts.TransBin > 0) |
882 |
return CommBinaryOut(&cv,(PCHAR)&b,1); |
883 |
else if ((b>=0x20) || (b==0x09) || (b==0x0A) || (b==0x0D)) |
884 |
return CommTextOut(&cv,(PCHAR)&b,1); |
885 |
else |
886 |
return 1; |
887 |
} |
888 |
|
889 |
int FSEcho1(BYTE b) |
890 |
{ |
891 |
if (ts.TransBin > 0) |
892 |
return CommBinaryEcho(&cv,(PCHAR)&b,1); |
893 |
else |
894 |
return CommTextEcho(&cv,(PCHAR)&b,1); |
895 |
} |
896 |
} |
897 |
|
898 |
extern "C" { |
899 |
void FileSend() |
900 |
{ |
901 |
WORD c, fc; |
902 |
LONG BCOld; |
903 |
|
904 |
if ((SendDlg==NULL) || |
905 |
((cv.FilePause & OpSendFile) !=0)) |
906 |
return; |
907 |
|
908 |
BCOld = SendVar->ByteCount; |
909 |
|
910 |
if (FileRetrySend) |
911 |
{ |
912 |
FileRetryEcho = (ts.LocalEcho>0); |
913 |
c = FSOut1(FileByte); |
914 |
FileRetrySend = (c==0); |
915 |
if (FileRetrySend) |
916 |
return; |
917 |
} |
918 |
|
919 |
if (FileRetryEcho) |
920 |
{ |
921 |
c = FSEcho1(FileByte); |
922 |
FileRetryEcho = (c==0); |
923 |
if (FileRetryEcho) |
924 |
return; |
925 |
} |
926 |
|
927 |
do { |
928 |
fc = _lread(SendVar->FileHandle,&FileByte,1); |
929 |
SendVar->ByteCount = SendVar->ByteCount + fc; |
930 |
|
931 |
if (FileCRSend && (fc==1) && (FileByte==0x0A)) |
932 |
{ |
933 |
fc = _lread(SendVar->FileHandle,&FileByte,1); |
934 |
SendVar->ByteCount = SendVar->ByteCount + fc; |
935 |
} |
936 |
|
937 |
if (fc!=0) |
938 |
{ |
939 |
c = FSOut1(FileByte); |
940 |
FileCRSend = (ts.TransBin==0) && (FileByte==0x0D); |
941 |
FileRetrySend = (c==0); |
942 |
if (FileRetrySend) |
943 |
{ |
944 |
if (SendVar->ByteCount != BCOld) |
945 |
SendDlg->RefreshNum(); |
946 |
return; |
947 |
} |
948 |
if (ts.LocalEcho>0) |
949 |
{ |
950 |
c = FSEcho1(FileByte); |
951 |
FileRetryEcho = (c==0); |
952 |
if (FileRetryEcho) |
953 |
return; |
954 |
} |
955 |
} |
956 |
if ((fc==0) || (SendVar->ByteCount % 100 == 0)) |
957 |
{ |
958 |
SendDlg->RefreshNum(); |
959 |
BCOld = SendVar->ByteCount; |
960 |
if (fc!=0) |
961 |
return; |
962 |
} |
963 |
} while (fc!=0); |
964 |
|
965 |
FileTransEnd(OpSendFile); |
966 |
} |
967 |
} |
968 |
|
969 |
extern "C" { |
970 |
void FLogChangeButton(BOOL Pause) |
971 |
{ |
972 |
if (FLogDlg!=NULL) |
973 |
FLogDlg->ChangeButton(Pause); |
974 |
} |
975 |
} |
976 |
|
977 |
extern "C" { |
978 |
void FLogRefreshNum() |
979 |
{ |
980 |
if (FLogDlg!=NULL) |
981 |
FLogDlg->RefreshNum(); |
982 |
} |
983 |
} |
984 |
|
985 |
BOOL OpenProtoDlg(PFileVar fv, int IdProto, int Mode, WORD Opt1, WORD Opt2) |
986 |
{ |
987 |
int vsize; |
988 |
PProtoDlg pd; |
989 |
HWND Hpd; |
990 |
char uimsg[MAX_UIMSG]; |
991 |
|
992 |
ProtoId = IdProto; |
993 |
|
994 |
switch (ProtoId) { |
995 |
case PROTO_KMT: |
996 |
vsize = sizeof(TKmtVar); |
997 |
break; |
998 |
case PROTO_XM: |
999 |
vsize = sizeof(TXVar); |
1000 |
break; |
1001 |
case PROTO_YM: |
1002 |
vsize = sizeof(TYVar); |
1003 |
break; |
1004 |
case PROTO_ZM: |
1005 |
vsize = sizeof(TZVar); |
1006 |
break; |
1007 |
case PROTO_BP: |
1008 |
vsize = sizeof(TBPVar); |
1009 |
break; |
1010 |
case PROTO_QV: |
1011 |
vsize = sizeof(TQVVar); |
1012 |
break; |
1013 |
} |
1014 |
ProtoVar = (PCHAR)malloc(vsize); |
1015 |
if (ProtoVar==NULL) |
1016 |
return FALSE; |
1017 |
|
1018 |
switch (ProtoId) { |
1019 |
case PROTO_KMT: |
1020 |
((PKmtVar)ProtoVar)->KmtMode = Mode; |
1021 |
break; |
1022 |
case PROTO_XM: |
1023 |
((PXVar)ProtoVar)->XMode = Mode; |
1024 |
((PXVar)ProtoVar)->XOpt = Opt1; |
1025 |
((PXVar)ProtoVar)->TextFlag = 1 - (Opt2 & 1); |
1026 |
break; |
1027 |
case PROTO_YM: // TBD |
1028 |
((PYVar)ProtoVar)->YMode = Mode; |
1029 |
((PYVar)ProtoVar)->YOpt = Yopt1K; // TBD |
1030 |
break; |
1031 |
case PROTO_ZM: |
1032 |
((PZVar)ProtoVar)->BinFlag = (Opt1 & 1) != 0; |
1033 |
((PZVar)ProtoVar)->ZMode = Mode; |
1034 |
break; |
1035 |
case PROTO_BP: |
1036 |
((PBPVar)ProtoVar)->BPMode = Mode; |
1037 |
break; |
1038 |
case PROTO_QV: |
1039 |
((PQVVar)ProtoVar)->QVMode = Mode; |
1040 |
break; |
1041 |
} |
1042 |
|
1043 |
pd = new CProtoDlg(); |
1044 |
if (pd==NULL) |
1045 |
{ |
1046 |
free(ProtoVar); |
1047 |
ProtoVar = NULL; |
1048 |
return FALSE; |
1049 |
} |
1050 |
pd->Create(fv,&ts); |
1051 |
|
1052 |
Hpd=pd->GetSafeHwnd(); |
1053 |
|
1054 |
GetDlgItemText(Hpd, IDC_PROT_FILENAME, uimsg, sizeof(uimsg)); |
1055 |
get_lang_msg("DLG_PROT_FIELNAME", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
1056 |
SetDlgItemText(Hpd, IDC_PROT_FILENAME, ts.UIMsg); |
1057 |
GetDlgItemText(Hpd, IDC_PROT_PROT, uimsg, sizeof(uimsg)); |
1058 |
get_lang_msg("DLG_PROT_PROTO", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
1059 |
SetDlgItemText(Hpd, IDC_PROT_PROT, ts.UIMsg); |
1060 |
GetDlgItemText(Hpd, IDC_PROT_PACKET, uimsg, sizeof(uimsg)); |
1061 |
get_lang_msg("DLG_PROT_PACKET", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
1062 |
SetDlgItemText(Hpd, IDC_PROT_PACKET, ts.UIMsg); |
1063 |
GetDlgItemText(Hpd, IDC_PROT_TRANS, uimsg, sizeof(uimsg)); |
1064 |
get_lang_msg("DLG_PROT_TRANS", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
1065 |
SetDlgItemText(Hpd, IDC_PROT_TRANS, ts.UIMsg); |
1066 |
GetDlgItemText(Hpd, IDCANCEL, uimsg, sizeof(uimsg)); |
1067 |
get_lang_msg("BTN_CANCEL", ts.UIMsg, sizeof(ts.UIMsg), uimsg, ts.UILanguageFile); |
1068 |
SetDlgItemText(Hpd, IDCANCEL, ts.UIMsg); |
1069 |
|
1070 |
(*ProtoInit)(ProtoId,FileVar,ProtoVar,&cv,&ts); |
1071 |
|
1072 |
PtDlg = pd; |
1073 |
return TRUE; |
1074 |
} |
1075 |
|
1076 |
extern "C" { |
1077 |
void CloseProtoDlg() |
1078 |
{ |
1079 |
if (PtDlg!=NULL) |
1080 |
{ |
1081 |
PtDlg->DestroyWindow(); |
1082 |
PtDlg = NULL; |
1083 |
|
1084 |
::KillTimer(FileVar->HMainWin,IdProtoTimer); |
1085 |
if ((ProtoId==PROTO_QV) && |
1086 |
(((PQVVar)ProtoVar)->QVMode==IdQVSend)) |
1087 |
CommTextOut(&cv,"\015",1); |
1088 |
if (FileVar->LogFlag) |
1089 |
_lclose(FileVar->LogFile); |
1090 |
FileVar->LogFile = 0; |
1091 |
if (ProtoVar!=NULL) |
1092 |
{ |
1093 |
free(ProtoVar); |
1094 |
ProtoVar = NULL; |
1095 |
} |
1096 |
} |
1097 |
} |
1098 |
} |
1099 |
|
1100 |
BOOL ProtoStart() |
1101 |
{ |
1102 |
if (cv.ProtoFlag) |
1103 |
return FALSE; |
1104 |
if (FSend) |
1105 |
{ |
1106 |
FreeFileVar(&FileVar); |
1107 |
return FALSE; |
1108 |
} |
1109 |
|
1110 |
if (! LoadTTFILE()) |
1111 |
return FALSE; |
1112 |
NewFileVar(&FileVar); |
1113 |
|
1114 |
if (FileVar==NULL) |
1115 |
{ |
1116 |
FreeTTFILE(); |
1117 |
return FALSE; |
1118 |
} |
1119 |
cv.ProtoFlag = TRUE; |
1120 |
return TRUE; |
1121 |
} |
1122 |
|
1123 |
void ProtoEnd() |
1124 |
{ |
1125 |
if (! cv.ProtoFlag) |
1126 |
return; |
1127 |
cv.ProtoFlag = FALSE; |
1128 |
|
1129 |
/* Enable transmit delay (serial port) */ |
1130 |
cv.DelayFlag = TRUE; |
1131 |
TalkStatus = IdTalkKeyb; |
1132 |
|
1133 |
CloseProtoDlg(); |
1134 |
|
1135 |
if ((FileVar!=NULL) && FileVar->Success) |
1136 |
EndDdeCmnd(1); |
1137 |
else |
1138 |
EndDdeCmnd(0); |
1139 |
|
1140 |
FreeTTFILE(); |
1141 |
FreeFileVar(&FileVar); |
1142 |
} |
1143 |
|
1144 |
extern "C" { |
1145 |
int ProtoDlgParse() |
1146 |
{ |
1147 |
int P; |
1148 |
|
1149 |
P = ActiveWin; |
1150 |
if (PtDlg==NULL) |
1151 |
return P; |
1152 |
|
1153 |
if ((*ProtoParse)(ProtoId,FileVar,ProtoVar,&cv)) |
1154 |
P = 0; /* continue */ |
1155 |
else { |
1156 |
CommSend(&cv); |
1157 |
ProtoEnd(); |
1158 |
} |
1159 |
return P; |
1160 |
} |
1161 |
} |
1162 |
|
1163 |
extern "C" { |
1164 |
void ProtoDlgTimeOut() |
1165 |
{ |
1166 |
if (PtDlg!=NULL) |
1167 |
(*ProtoTimeOutProc)(ProtoId,FileVar,ProtoVar,&cv); |
1168 |
} |
1169 |
} |
1170 |
|
1171 |
extern "C" { |
1172 |
void ProtoDlgCancel() |
1173 |
{ |
1174 |
if ((PtDlg!=NULL) && |
1175 |
(*ProtoCancel)(ProtoId,FileVar,ProtoVar,&cv)) |
1176 |
ProtoEnd(); |
1177 |
} |
1178 |
} |
1179 |
|
1180 |
extern "C" { |
1181 |
void KermitStart(int mode) |
1182 |
{ |
1183 |
WORD w; |
1184 |
|
1185 |
if (! ProtoStart()) |
1186 |
return; |
1187 |
|
1188 |
switch (mode) { |
1189 |
case IdKmtSend: |
1190 |
FileVar->OpId = OpKmtSend; |
1191 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1192 |
{ |
1193 |
if (! (*GetMultiFname)(FileVar,ts.FileDir,GMF_KERMIT,&w) || |
1194 |
(FileVar->NumFname==0)) |
1195 |
{ |
1196 |
ProtoEnd(); |
1197 |
return; |
1198 |
} |
1199 |
} |
1200 |
else |
1201 |
(*SetFileVar)(FileVar); |
1202 |
break; |
1203 |
case IdKmtReceive: |
1204 |
FileVar->OpId = OpKmtRcv; |
1205 |
break; |
1206 |
case IdKmtGet: |
1207 |
FileVar->OpId = OpKmtSend; |
1208 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1209 |
{ |
1210 |
if (! (*GetGetFname)(FileVar->HMainWin,FileVar) || |
1211 |
(strlen(FileVar->FullName)==0)) |
1212 |
{ |
1213 |
ProtoEnd(); |
1214 |
return; |
1215 |
} |
1216 |
} |
1217 |
else |
1218 |
(*SetFileVar)(FileVar); |
1219 |
break; |
1220 |
case IdKmtFinish: |
1221 |
FileVar->OpId = OpKmtFin; |
1222 |
break; |
1223 |
default: |
1224 |
ProtoEnd(); |
1225 |
return; |
1226 |
} |
1227 |
TalkStatus = IdTalkQuiet; |
1228 |
|
1229 |
/* disable transmit delay (serial port) */ |
1230 |
cv.DelayFlag = FALSE; |
1231 |
|
1232 |
if (! OpenProtoDlg(FileVar,PROTO_KMT,mode,0,0)) |
1233 |
ProtoEnd(); |
1234 |
} |
1235 |
} |
1236 |
|
1237 |
extern "C" { |
1238 |
void XMODEMStart(int mode) |
1239 |
{ |
1240 |
LONG Option; |
1241 |
|
1242 |
if (! ProtoStart()) |
1243 |
return; |
1244 |
|
1245 |
if (mode==IdXReceive) |
1246 |
FileVar->OpId = OpXRcv; |
1247 |
else |
1248 |
FileVar->OpId = OpXSend; |
1249 |
|
1250 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1251 |
{ |
1252 |
Option = MAKELONG(ts.XmodemBin,ts.XmodemOpt); |
1253 |
if (! (*GetXFname)(FileVar->HMainWin, |
1254 |
mode==IdXReceive,&Option,FileVar,ts.FileDir)) |
1255 |
{ |
1256 |
ProtoEnd(); |
1257 |
return; |
1258 |
} |
1259 |
ts.XmodemOpt = HIWORD(Option); |
1260 |
ts.XmodemBin = LOWORD(Option); |
1261 |
} |
1262 |
else |
1263 |
(*SetFileVar)(FileVar); |
1264 |
|
1265 |
if (mode==IdXReceive) |
1266 |
FileVar->FileHandle = _lcreat(FileVar->FullName,0); |
1267 |
else |
1268 |
FileVar->FileHandle = _lopen(FileVar->FullName,OF_READ); |
1269 |
|
1270 |
FileVar->FileOpen = FileVar->FileHandle>0; |
1271 |
if (! FileVar->FileOpen) |
1272 |
{ |
1273 |
ProtoEnd(); |
1274 |
return; |
1275 |
} |
1276 |
TalkStatus = IdTalkQuiet; |
1277 |
|
1278 |
/* disable transmit delay (serial port) */ |
1279 |
cv.DelayFlag = FALSE; |
1280 |
|
1281 |
if (! OpenProtoDlg(FileVar,PROTO_XM,mode, |
1282 |
ts.XmodemOpt,ts.XmodemBin)) |
1283 |
ProtoEnd(); |
1284 |
} |
1285 |
} |
1286 |
|
1287 |
extern "C" { |
1288 |
void YMODEMStart(int mode) |
1289 |
{ |
1290 |
WORD Opt; |
1291 |
|
1292 |
if (! ProtoStart()) |
1293 |
return; |
1294 |
|
1295 |
if (mode==IdYSend) |
1296 |
{ |
1297 |
Opt = ts.XmodemBin; |
1298 |
FileVar->OpId = OpYSend; |
1299 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1300 |
{ |
1301 |
if (! (*GetMultiFname)(FileVar,ts.FileDir,GMF_Y,&Opt) || |
1302 |
(FileVar->NumFname==0)) |
1303 |
{ |
1304 |
ProtoEnd(); |
1305 |
return; |
1306 |
} |
1307 |
ts.XmodemBin = Opt; |
1308 |
} |
1309 |
else |
1310 |
(*SetFileVar)(FileVar); |
1311 |
} |
1312 |
else /* IdZReceive or IdZAuto */ |
1313 |
FileVar->OpId = OpYRcv; |
1314 |
|
1315 |
TalkStatus = IdTalkQuiet; |
1316 |
|
1317 |
/* disable transmit delay (serial port) */ |
1318 |
cv.DelayFlag = FALSE; |
1319 |
|
1320 |
if (! OpenProtoDlg(FileVar,PROTO_YM,mode,Opt,0)) |
1321 |
ProtoEnd(); |
1322 |
} |
1323 |
} |
1324 |
|
1325 |
extern "C" { |
1326 |
void ZMODEMStart(int mode) |
1327 |
{ |
1328 |
WORD Opt; |
1329 |
|
1330 |
if (! ProtoStart()) |
1331 |
return; |
1332 |
|
1333 |
if (mode==IdZSend) |
1334 |
{ |
1335 |
Opt = ts.XmodemBin; |
1336 |
FileVar->OpId = OpZSend; |
1337 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1338 |
{ |
1339 |
if (! (*GetMultiFname)(FileVar,ts.FileDir,GMF_Z,&Opt) || |
1340 |
(FileVar->NumFname==0)) |
1341 |
{ |
1342 |
ProtoEnd(); |
1343 |
return; |
1344 |
} |
1345 |
ts.XmodemBin = Opt; |
1346 |
} |
1347 |
else |
1348 |
(*SetFileVar)(FileVar); |
1349 |
} |
1350 |
else /* IdZReceive or IdZAuto */ |
1351 |
FileVar->OpId = OpZRcv; |
1352 |
|
1353 |
TalkStatus = IdTalkQuiet; |
1354 |
|
1355 |
/* disable transmit delay (serial port) */ |
1356 |
cv.DelayFlag = FALSE; |
1357 |
|
1358 |
if (! OpenProtoDlg(FileVar,PROTO_ZM,mode,Opt,0)) |
1359 |
ProtoEnd(); |
1360 |
} |
1361 |
} |
1362 |
|
1363 |
extern "C" { |
1364 |
void BPStart(int mode) |
1365 |
{ |
1366 |
LONG Option; |
1367 |
|
1368 |
if (! ProtoStart()) |
1369 |
return; |
1370 |
if (mode==IdBPSend) |
1371 |
{ |
1372 |
FileVar->OpId = OpBPSend; |
1373 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1374 |
{ |
1375 |
FileVar->FullName[0] = 0; |
1376 |
if (! (*GetTransFname)(FileVar, ts.FileDir, GTF_BP, &Option)) |
1377 |
{ |
1378 |
ProtoEnd(); |
1379 |
return; |
1380 |
} |
1381 |
} |
1382 |
else |
1383 |
(*SetFileVar)(FileVar); |
1384 |
} |
1385 |
else /* IdBPReceive or IdBPAuto */ |
1386 |
FileVar->OpId = OpBPRcv; |
1387 |
|
1388 |
TalkStatus = IdTalkQuiet; |
1389 |
|
1390 |
/* disable transmit delay (serial port) */ |
1391 |
cv.DelayFlag = FALSE; |
1392 |
|
1393 |
if (! OpenProtoDlg(FileVar,PROTO_BP,mode,0,0)) |
1394 |
ProtoEnd(); |
1395 |
} |
1396 |
} |
1397 |
|
1398 |
extern "C" { |
1399 |
void QVStart(int mode) |
1400 |
{ |
1401 |
WORD W; |
1402 |
|
1403 |
if (! ProtoStart()) |
1404 |
return; |
1405 |
|
1406 |
if (mode==IdQVSend) |
1407 |
{ |
1408 |
FileVar->OpId = OpQVSend; |
1409 |
if (strlen(&(FileVar->FullName[FileVar->DirLen]))==0) |
1410 |
{ |
1411 |
if (! (*GetMultiFname)(FileVar,ts.FileDir,GMF_QV, &W) || |
1412 |
(FileVar->NumFname==0)) |
1413 |
{ |
1414 |
ProtoEnd(); |
1415 |
return; |
1416 |
} |
1417 |
} |
1418 |
else |
1419 |
(*SetFileVar)(FileVar); |
1420 |
} |
1421 |
else |
1422 |
FileVar->OpId = OpQVRcv; |
1423 |
|
1424 |
TalkStatus = IdTalkQuiet; |
1425 |
|
1426 |
/* disable transmit delay (serial port) */ |
1427 |
cv.DelayFlag = FALSE; |
1428 |
|
1429 |
if (! OpenProtoDlg(FileVar,PROTO_QV,mode,0,0)) |
1430 |
ProtoEnd(); |
1431 |
} |
1432 |
} |