blob: 44c527b56f081b885c1cbfe2df9f2b4f68b41427 [file] [log] [blame]
Constantin Kaplinsky729598c2006-05-25 05:12:25 +00001/* Copyright (C) 2005 TightVNC Team. All Rights Reserved.
2 *
3 * Developed by Dennis Syrovatsky.
4 *
5 * This is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This software is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this software; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
18 * USA.
19 *
Peter Åstrand7877cd62009-02-25 16:15:48 +000020 *
Constantin Kaplinsky729598c2006-05-25 05:12:25 +000021 *
22 */
23
24// -=- FileTransfer.cxx
25
26#include <vncviewer/FileTransfer.h>
27
28using namespace rfb;
29using namespace rfb::win32;
30
31FileTransfer::FileTransfer()
32{
33 m_bFTDlgShown = false;
34 m_bInitialized = false;
35 m_bResized = false;
36 m_bCancel = false;
37 m_bOverwriteAll = false;
38
39 m_pFTDialog = new FTDialog(GetModuleHandle(0), this);
40
41 m_pReader = NULL;
42 m_pWriter = NULL;
43
44 m_dw64SizeSending = 0;
45 m_dirSizeRqstNum = 0;
46}
47
48FileTransfer::~FileTransfer()
49{
50 if (m_pFTDialog != NULL) {
51 delete m_pFTDialog;
52 m_pFTDialog = NULL;
53 }
54
55 if (m_pReader != NULL) {
56 delete m_pReader;
57 m_pReader = NULL;
58 }
59
60 if (m_pWriter != NULL) {
61 delete m_pWriter;
62 m_pWriter = NULL;
63 }
64
65 freeQueues();
66}
67
68bool
69FileTransfer::initialize(rdr::InStream *pIS, rdr::OutStream *pOS)
70{
71 if (m_bInitialized) return false;
72
73 m_pReader = new CFTMsgReader(pIS);
74 m_pWriter = new CFTMsgWriter(pOS);
75
76 freeQueues();
77
78 m_bInitialized = true;
79 return true;
80}
81
82bool
83FileTransfer::show(HWND hwndParent)
84{
85 if (!m_bInitialized) return false;
86
87 m_bFTDlgShown = m_pFTDialog->createFTDialog(hwndParent);
88
89 return m_bFTDlgShown;
90}
91
92bool
93FileTransfer::processFTMsg(int type)
94{
95 if (!m_bInitialized) return false;
96
97 switch (type)
98 {
99 case msgTypeFileListData:
100 return procFileListDataMsg();
101 case msgTypeFileDownloadData:
102 return procFileDownloadDataMsg();
103 case msgTypeFileUploadCancel:
104 return procFileUploadCancelMsg();
105 case msgTypeFileDownloadFailed:
106 return procFileDownloadFailedMsg();
107 case msgTypeFileDirSizeData:
108 return procFileDirSizeDataMsg();
109 case msgTypeFileLastRequestFailed:
110 return procFileLastRqstFailedMsg();
111 default:
112 return false;
113 }
114}
115
116bool
117FileTransfer::isTransferEnable()
118{
119 if (m_TransferQueue.getNumEntries() > 0) return true; else return false;
120}
121
122void
123FileTransfer::addDeleteQueue(char *pPathPrefix, FileInfo *pFI, unsigned int flags)
124{
125 if ((m_bFTDlgShown) && (m_DeleteQueue.getNumEntries() > 0))
126 m_pFTDialog->setStatusText("Starting Delete Operation");
127
128 m_DeleteQueue.add(pPathPrefix, pPathPrefix, pFI, flags);
129
130 checkDeleteQueue();
131}
132
133void
134FileTransfer::checkDeleteQueue()
135{
136 if (m_DeleteQueue.getNumEntries() > 0) {
137 if (m_bFTDlgShown)
138 m_pFTDialog->setStatusText("Delete Operation Executing: %s", m_DeleteQueue.getFullLocPathAt(0));
139 if (m_DeleteQueue.getFlagsAt(0) & FT_ATTR_DELETE_LOCAL) {
140 FolderManager fm;
141 if (!fm.deleteIt(m_DeleteQueue.getFullLocPathAt(0))) {
142 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Delete Operation Failed");
143 } else {
144 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Delete Operation Completed");
145 }
146 m_DeleteQueue.deleteAt(0);
147 m_pFTDialog->postCheckDeleteQueueMsg();
148 } else {
149 if (m_DeleteQueue.getFlagsAt(0) & FT_ATTR_DELETE_REMOTE) {
150 writeFileDeleteRqst(strlen(m_DeleteQueue.getFullLocPathAt(0)),
151 m_DeleteQueue.getFullLocPathAt(0));
152
153 char *pPath = m_DeleteQueue.getLocPathAt(0);
154 m_queueFileListRqst.add(pPath, 0, 0, FT_FLR_DEST_DELETE);
155 writeFileListRqst(strlen(pPath), pPath, false);
156 }
157 }
158 } else {
159 if (m_bFTDlgShown) {
160 m_pFTDialog->setStatusText("Delete Operation Completed Successfully");
161 PostMessage(m_pFTDialog->getWndHandle(), WM_COMMAND, MAKEWPARAM(IDC_FTLOCALRELOAD, 0), 0);
162 PostMessage(m_pFTDialog->getWndHandle(), WM_COMMAND, MAKEWPARAM(IDC_FTREMOTERELOAD, 0), 0);
163 }
164 }
165}
166
167void
168FileTransfer::addTransferQueue(char *pLocalPath, char *pRemotePath,
169 FileInfo *pFI, unsigned int flags)
170{
171 if (!isTransferEnable()) {
172 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Starting Copy Operation");
173 m_bTransferSuccess = true;
174 }
175
176 m_TransferQueue.add(pLocalPath, pRemotePath, pFI, (flags | FT_ATTR_RESIZE_NEEDED));
177
178 checkTransferQueue();
179}
180
181bool
182FileTransfer::resizeSending()
183{
184 for (unsigned int i = 0; i < m_TransferQueue.getNumEntries(); i++) {
185 unsigned int flags = m_TransferQueue.getFlagsAt(i);
186 if (flags & FT_ATTR_RESIZE_NEEDED) {
187 if (flags & FT_ATTR_FILE) {
188 m_bResized = true;
189 m_dw64SizeSending += m_TransferQueue.getSizeAt(i);
190 m_TransferQueue.clearFlagAt(i, FT_ATTR_RESIZE_NEEDED);
191 } else {
192 if (flags & FT_ATTR_DIR) {
193 if (flags & FT_ATTR_COPY_DOWNLOAD) {
194 m_bResized = true;
195 char *pPath = m_TransferQueue.getFullRemPathAt(i);
196 m_dirSizeRqstNum = i;
197 writeFileDirSizeRqst(strlen(pPath), pPath);
198 return false;
199 } else {
200 if (flags & FT_ATTR_COPY_UPLOAD) {
201 FolderManager fm;
202 DWORD64 dw64Size;
203 m_bResized = true;
204 fm.getDirSize(m_TransferQueue.getFullLocPathAt(i), &dw64Size);
205 m_dw64SizeSending += dw64Size;
206 m_TransferQueue.clearFlagAt(i, FT_ATTR_RESIZE_NEEDED);
207 }
208 } // if (flags & FT_ATTR_COPY_DOWNLOAD)
209 } // if (flags & FT_ATTR_FOLDER)
210 } // if (flags & FT_ATTR_FILE)
211 } // if (flags & FT_ATTR_NEEDED_RESIZE)
212 } // for (unsigned int i = 0; i < m_TransferQueue.getNumEntries(); i++)
213
214 if ((m_bFTDlgShown) && (m_bResized)) {
215 m_pFTDialog->m_pProgress->clearAndInitGeneral(m_dw64SizeSending, 0);
216 m_bResized = false;
217 }
218
219 return true;
220}
221
222void
223FileTransfer::checkTransferQueue()
224{
225 if (!isTransferEnable()) {
226 if (m_bFTDlgShown) {
227 m_pFTDialog->m_pProgress->clearAll();
228 m_dw64SizeSending = 0;
229 m_bResized = false;
230
231 if (m_bTransferSuccess)
232 m_pFTDialog->setStatusText("File Transfer Operation Completed Successfully");
233 else
234 m_pFTDialog->setStatusText("File Transfer Operation Completed");
235
236 m_pFTDialog->afterCancelTransfer();
237 PostMessage(m_pFTDialog->getWndHandle(), WM_COMMAND, MAKEWPARAM(IDC_FTLOCALRELOAD, 0), 0);
238 PostMessage(m_pFTDialog->getWndHandle(), WM_COMMAND, MAKEWPARAM(IDC_FTREMOTERELOAD, 0), 0);
239 return;
240 }
241 } else {
242 if (!resizeSending()) return;
243
244 unsigned int flag0 = m_TransferQueue.getFlagsAt(0);
245
246 if (flag0 & FT_ATTR_COPY_UPLOAD) {
247 if (flag0 & FT_ATTR_FILE) {
248 uploadFile();
249 return;
250 }
251 if (flag0 & FT_ATTR_DIR) {
252 char *pFullPath = m_TransferQueue.getFullRemPathAt(0);
253 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Creating Remote Folder. %s", pFullPath);
254 writeFileCreateDirRqst(strlen(pFullPath), pFullPath);
255
256 char *pPath = m_TransferQueue.getRemPathAt(0);
257 m_TransferQueue.setFlagsAt(0, (flag0 | FT_ATTR_FLR_UPLOAD_CHECK));
258 m_queueFileListRqst.add(pPath, 0, 0, FT_FLR_DEST_UPLOAD);
259 writeFileListRqst(strlen(pPath), pPath, false);
260 return;
261 }
262 } else {
263 if (flag0 & FT_ATTR_COPY_DOWNLOAD) {
264 if (flag0 & FT_ATTR_FILE) {
265 downloadFile();
266 return;
267 }
268 if (flag0 & FT_ATTR_DIR) {
269 FolderManager fm;
270 char *pLocPath = m_TransferQueue.getFullLocPathAt(0);
271 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Creating Local Folder. %s", pLocPath);
272
273 if (!fm.createDir(pLocPath)) {
274 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Creating Local Folder Failed.");
275 m_bTransferSuccess = false;
276 m_TransferQueue.deleteAt(0);
277 m_pFTDialog->postCheckTransferQueueMsg();
278 return;
279 } else {
280 if ((m_bFTDlgShown) && (strcmp(m_TransferQueue.getLocPathAt(0), m_pFTDialog->getLocalPath()) == 0))
281 PostMessage(m_pFTDialog->getWndHandle(), WM_COMMAND, MAKEWPARAM(IDC_FTLOCALRELOAD, 0), 0);
282
283 m_TransferQueue.setFlagsAt(0, (m_TransferQueue.getFlagsAt(0) | FT_ATTR_FLR_DOWNLOAD_ADD));
284 char *pRemPath = m_TransferQueue.getFullRemPathAt(0);
285 m_queueFileListRqst.add(pRemPath, 0, 0, FT_FLR_DEST_DOWNLOAD);
286 writeFileListRqst(strlen(pRemPath), pRemPath, 0);
287 return;
288 }
289 }
290 }
291 }
292 m_bTransferSuccess = false;
293 if (m_bFTDlgShown) m_pFTDialog->setStatusText("File Transfer Operation Failed. Unknown data in the transfer queue");
294 } // if (!isTransferEnable())
295}
296
297bool
298FileTransfer::uploadFile()
299{
300 if (m_TransferQueue.getFlagsAt(0) & FT_ATTR_FILE) {
301 if (m_fileReader.create(m_TransferQueue.getFullLocPathAt(0))) {
302
303 if (m_bFTDlgShown) {
304 m_pFTDialog->setStatusText("Upload Started: %s to %s",
305 m_TransferQueue.getFullLocPathAt(0),
306 m_TransferQueue.getFullRemPathAt(0));
307 m_pFTDialog->m_pProgress->clearAndInitSingle(m_TransferQueue.getSizeAt(0), 0);
308 }
309
310 writeFileUploadRqst(strlen(m_TransferQueue.getFullRemPathAt(0)),
311 m_TransferQueue.getFullRemPathAt(0), 0);
312 uploadFilePortion();
313 }
314 }
315 return false;
316}
317
318bool
319FileTransfer::downloadFile()
320{
321 if (m_TransferQueue.getFlagsAt(0) & FT_ATTR_FILE) {
322 if (m_fileWriter.create(m_TransferQueue.getFullLocPathAt(0))) {
323 if (m_bFTDlgShown) {
324 m_pFTDialog->setStatusText("Download Started: %s to %s",
325 m_TransferQueue.getFullRemPathAt(0),
326 m_TransferQueue.getFullLocPathAt(0));
327 m_pFTDialog->m_pProgress->clearAndInitSingle(m_TransferQueue.getSizeAt(0), 0);
328 }
329 writeFileDownloadRqst(strlen(m_TransferQueue.getFullRemPathAt(0)),
330 m_TransferQueue.getFullRemPathAt(0), 0);
331 return true;
332 } else return false;
333 }
334 return false;
335}
336
337void
338FileTransfer::uploadFilePortion()
339{
340 if (checkCancelOperations()) {
341 char reason[] = "The user cancel transfer";
342 m_pWriter->writeFileUploadFailed(strlen(reason), reason);
343 }
344
345 if (m_fileReader.isCreated()) {
346 char buf[FT_MAX_SENDING_SIZE];
347 unsigned int bytesRead = 0;
348 if (m_fileReader.read((void *)buf, FT_MAX_SENDING_SIZE, &bytesRead)) {
349 if (bytesRead == 0) {
350 m_pWriter->writeFileUploadData(m_TransferQueue.getDataAt(0));
351 m_fileReader.close();
352 if (m_bFTDlgShown) {
353 m_pFTDialog->m_pProgress->clearAndInitSingle(0, 0);
354 m_pFTDialog->setStatusText("Upload Completed");
355 }
356 m_TransferQueue.deleteAt(0);
357 m_pFTDialog->postCheckTransferQueueMsg();
358 } else {
359 if (m_bFTDlgShown) m_pFTDialog->m_pProgress->increase(bytesRead);
360 m_pWriter->writeFileUploadData(bytesRead, (char *)buf);
361 m_pFTDialog->postUploadFilePortionMsg();
362 }
363 } else {
364 m_fileReader.close();
365 m_bTransferSuccess = false;
366 char reason[] = "Error While Reading File";
367 m_pWriter->writeFileUploadFailed(strlen(reason), reason);
368 if (m_bFTDlgShown) {
369 m_pFTDialog->m_pProgress->clearAndInitSingle(0, 0);
370 m_pFTDialog->setStatusText("Upload Failed");
371 }
372 m_TransferQueue.deleteAt(0);
373 m_pFTDialog->postCheckTransferQueueMsg();
374 }
375 }
376}
377
378void
379FileTransfer::createRemoteFolder(char *pPath, char *pName)
380{
381 char fullPath[FT_FILENAME_SIZE];
382 sprintf(fullPath, "%s\\%s", pPath, pName);
383 m_pFTDialog->setStatusText("Creating Remote Folder: %s", fullPath);
384 writeFileCreateDirRqst(strlen(fullPath), fullPath);
385 requestFileList(pPath, FT_FLR_DEST_MAIN, false);
386}
387
388void
389FileTransfer::renameRemote(char *pPath, char *pOldName, char *pNewName)
390{
391 char fullOldName[FT_FILENAME_SIZE];
392 char fullNewName[FT_FILENAME_SIZE];
393
394 sprintf(fullOldName, "%s\\%s", pPath, pOldName);
395 sprintf(fullNewName, "%s\\%s", pPath, pNewName);
396
397 writeFileRenameRqst(strlen(fullOldName), strlen(fullNewName),
398 fullOldName, fullNewName);
399 requestFileList(pPath, FT_FLR_DEST_MAIN, false);
400}
401
402bool
403FileTransfer::procFileListDataMsg()
404{
405 FileInfo fileInfo;
406 int res = m_pReader->readFileListData(&fileInfo);
407
Peter Åstrandad4a8c72008-12-11 09:11:02 +0000408 bool bResult = false;
Constantin Kaplinsky729598c2006-05-25 05:12:25 +0000409 switch (m_queueFileListRqst.getFlagsAt(0))
410 {
411 case FT_FLR_DEST_MAIN:
412 if (!m_bFTDlgShown) break;
413
414 if (res < 0) {
415 m_pFTDialog->reqFolderUnavailable();
416 bResult = true;
417 } else {
418 bResult = procFLRMain(&fileInfo);
419 }
420 break;
421 case FT_FLR_DEST_BROWSE:
422 bResult = procFLRBrowse(&fileInfo);
423 break;
424 case FT_FLR_DEST_UPLOAD:
425 bResult = procFLRUpload(&fileInfo);
426 break;
427 case FT_FLR_DEST_DOWNLOAD:
428 bResult = procFLRDownload(&fileInfo);
429 break;
430 case FT_FLR_DEST_DELETE:
431 bResult = procFLRDelete(&fileInfo);
432 break;
433 case FT_FLR_DEST_RENAME:
434 bResult = procFLRRename(&fileInfo);
435 break;
436 }
437 m_queueFileListRqst.deleteAt(0);
438 return bResult;
439}
440
441bool
442FileTransfer::procFileDownloadDataMsg()
443{
444 unsigned int bufSize = 0;
445 unsigned int modTime = 0;
446
447 void *pFile = m_pReader->readFileDownloadData(&bufSize, &modTime);
448
449 if (checkCancelOperations()) {
450 char reason[] = "The user cancel transfer";
451 m_pWriter->writeFileDownloadCancel(strlen(reason), reason);
452 }
453
454 if ((!m_fileWriter.isCreated()) || (!isTransferEnable())) {
455 m_bTransferSuccess = false;
456 if (pFile != NULL) delete [] pFile;
457 return false;
458 }
459
460 if (bufSize > 0) {
461 unsigned int bytesWritten = 0;
462 m_fileWriter.write(pFile, bufSize, &bytesWritten);
463 delete [] pFile;
464 if (bytesWritten != bufSize) {
465 m_bTransferSuccess = false;
466 char reason[] = "Error File Writting to File";
467 m_pWriter->writeFileDownloadCancel(strlen(reason), reason);
468 if (m_bFTDlgShown) {
469 m_pFTDialog->setStatusText("Download Failed");
470 m_pFTDialog->m_pProgress->clearAndInitSingle(0, 0);
471 }
472 m_TransferQueue.deleteAt(0);
473 m_pFTDialog->postCheckTransferQueueMsg();
474 return false;
475 } else {
476 if (m_bFTDlgShown) {
477 m_pFTDialog->m_pProgress->increase(bufSize);
478 }
479 }
480 return true;
481 } else {
482 if (modTime != 0) {
483 m_fileWriter.setTime(modTime);
484 m_fileWriter.close();
485 if (m_bFTDlgShown) {
486 m_pFTDialog->setStatusText("Download Completed");
487 m_pFTDialog->m_pProgress->clearAndInitSingle(0, 0);
488 }
489 m_TransferQueue.deleteAt(0);
490 m_pFTDialog->postCheckTransferQueueMsg();
491 return true;
492 } else {
493 m_fileWriter.close();
494 m_bTransferSuccess = false;
495 char reason[] = "Error File Writting";
496 if (m_bFTDlgShown) {
497 m_pFTDialog->setStatusText("Download Failed");
498 m_pFTDialog->m_pProgress->clearAndInitSingle(0, 0);
499 }
500 m_pWriter->writeFileDownloadCancel(strlen(reason), reason);
501 m_TransferQueue.deleteAt(0);
502 m_pFTDialog->postCheckTransferQueueMsg();
503 }
504 }
505 return false;
506}
507
508bool
509FileTransfer::procFileUploadCancelMsg()
510{
511 unsigned int reasonSize = 0;
512 char *pReason = m_pReader->readFileUploadCancel(&reasonSize);
513
514 if (m_bFTDlgShown) {
515 m_pFTDialog->setStatusText("Upload Canceled by Remote Computer : %s", pReason);
516 }
517 endUndoneOperation();
518 m_pFTDialog->postCheckTransferQueueMsg();
519
520 delete [] pReason;
521 return true;
522}
523
524bool
525FileTransfer::procFileDownloadFailedMsg()
526{
527 unsigned int reasonSize = 0;
528 char *pReason = m_pReader->readFileDownloadFailed(&reasonSize);
529
530 if (m_bFTDlgShown) {
531 m_pFTDialog->setStatusText("Download Failed by Remote Computer : %s", pReason);
532 }
533 endUndoneOperation();
534 m_pFTDialog->postCheckTransferQueueMsg();
535
536 delete [] pReason;
537 return true;
538}
539
540bool
541FileTransfer::procFileDirSizeDataMsg()
542{
543 DWORD64 dw64DirSize = 0;
544 unsigned short dirSizeLow16 = 0;
545 unsigned int dirSizeHigh32 = 0;
546 m_pReader->readFileDirSizeData(&dirSizeLow16, &dirSizeHigh32);
547
548 dw64DirSize = dirSizeLow16;
549 dw64DirSize = (dw64DirSize << 32) + dirSizeHigh32;
550
551 m_dw64SizeSending += dw64DirSize;
552 m_TransferQueue.clearFlagAt(m_dirSizeRqstNum, FT_ATTR_RESIZE_NEEDED);
553 checkTransferQueue();
554 return true;
555}
556
557bool
558FileTransfer::procFileLastRqstFailedMsg()
559{
560 unsigned int reasonSize = 0;
561 int requestType;
562 char *pReason = m_pReader->readFileLastRqstFailed(&requestType, &reasonSize);
563 delete [] pReason;
564 return true;
565}
566
567bool
568FileTransfer::procFLRMain(FileInfo *pFI)
569{
570 if (m_bFTDlgShown) m_pFTDialog->addRemoteLVItems(pFI);
571 return true;
572}
573
574bool
575FileTransfer::procFLRBrowse(FileInfo *pFI)
576{
577 m_pFTDialog->addBrowseItems(pFI);
578 return false;
579}
580
581bool
582FileTransfer::procFLRUpload(FileInfo *pFI)
583{
584 unsigned int flags = m_TransferQueue.getFlagsAt(0);
585 if (flags & FT_ATTR_FLR_UPLOAD_CHECK) {
586 int num = isExistName(pFI, m_TransferQueue.getRemNameAt(0));
587 if (num >= 0) {
588 if ((m_bFTDlgShown) && (strcmp(m_TransferQueue.getRemPathAt(0), m_pFTDialog->getRemotePath()) == 0)) {
589 m_pFTDialog->addRemoteLVItems(pFI);
590 }
591 } else {
592 if (flags & FT_ATTR_DIR) {
593 m_TransferQueue.deleteAt(0);
594 m_bTransferSuccess = false;
595 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Create Remote Folder Failed.");
596 }
597 }
598 }
599 FolderManager fm;
600 FileInfo fi;
601 flags = m_TransferQueue.getFlagsAt(0);
602 if (flags & FT_ATTR_FILE) {
603 uploadFile();
604 return true;
605 } else {
606 if (fm.getDirInfo(m_TransferQueue.getFullLocPathAt(0), &fi, 0)) {
607 m_TransferQueue.add(m_TransferQueue.getFullLocPathAt(0),
608 m_TransferQueue.getFullRemPathAt(0),
609 &fi, FT_ATTR_COPY_UPLOAD);
610 }
611 }
612 m_TransferQueue.deleteAt(0);
613 m_pFTDialog->postCheckTransferQueueMsg();
614 return true;
615}
616
617bool
618FileTransfer::procFLRDownload(FileInfo *pFI)
619{
620 unsigned int flags = m_TransferQueue.getFlagsAt(0);
621
622 if ((flags & FT_ATTR_DIR) && (flags & FT_ATTR_FLR_DOWNLOAD_ADD)) {
623 m_TransferQueue.add(m_TransferQueue.getFullLocPathAt(0),
624 m_TransferQueue.getFullRemPathAt(0),
625 pFI, FT_ATTR_COPY_DOWNLOAD);
626 m_TransferQueue.deleteAt(0);
627 m_pFTDialog->postCheckTransferQueueMsg();
628 return true;
629 } else {
630 m_bTransferSuccess = false;
631 if (m_bFTDlgShown) m_pFTDialog->setStatusText("File Transfer Operation Failed: Unknown data from server.");
632 }
633 return false;
634}
635
636bool
637FileTransfer::procFLRDelete(FileInfo *pFI)
638{
639 if (isExistName(pFI, m_DeleteQueue.getLocNameAt(0)) >= 0) {
640 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Delete Operation Failed.");
641 } else {
642 if (m_bFTDlgShown) m_pFTDialog->setStatusText("Delete Operation Completed.");
643 }
644 m_DeleteQueue.deleteAt(0);
645 checkDeleteQueue();
646 return true;
647}
648
649bool
650FileTransfer::procFLRRename(FileInfo *pFI)
651{
652 return false;
653}
654
655void
656FileTransfer::requestFileList(char *pPath, int dest, bool bDirOnly)
657{
658 m_queueFileListRqst.add(pPath, 0, 0, dest);
659
660 writeFileListRqst(strlen(pPath), pPath, bDirOnly);
661}
662
663int
664FileTransfer::isExistName(FileInfo *pFI, char *pName)
665{
666 for (unsigned int i = 0; i < pFI->getNumEntries(); i++) {
667 if (strcmp(pFI->getNameAt(i), pName) == 0) {
668 return i;
669 }
670 }
671 return -1;
672}
673
674bool
675FileTransfer::checkCancelOperations()
676{
677 if (m_bFTDlgShown) m_pFTDialog->processDlgMsgs();
678 if (m_bCancel) {
679 endUndoneOperation();
680 if (m_bFTDlgShown) {
681 m_pFTDialog->setStatusText("All Operations Canceled");
682 }
683 return true;
684 } else {
685 return false;
686 }
687}
688
689void
690FileTransfer::endUndoneOperation()
691{
692 m_bCancel = false;
693 m_bTransferSuccess = false;
694 m_fileReader.close();
695 m_fileWriter.close();
696 freeQueues();
697 m_dw64SizeSending = 0;
698 m_pFTDialog->m_pProgress->clearAll();
699}
700
701void
702FileTransfer::freeQueues()
703{
704 m_TransferQueue.free();
705 m_DeleteQueue.free();
706 m_queueFileListRqst.free();
707}
708
709int
710FileTransfer::convertToUnixPath(char *path)
711{
712 int len = strlen(path);
713 if (len >= FT_FILENAME_SIZE) return -1;
714 if (len == 0) {strcpy(path, "/"); return 1;}
715 for (int i = (len - 1); i >= 0; i--) {
716 if (path[i] == '\\') path[i] = '/';
717 path[i+1] = path[i];
718 }
719 path[len + 1] = '\0';
720 path[0] = '/';
721 return strlen(path);
722}
723
724bool
725FileTransfer::writeFileListRqst(unsigned short dirnameLen, char *pDirName, bool bDirOnly)
726{
727 char dirName[FT_FILENAME_SIZE];
728 strcpy(dirName, pDirName);
729 int len = convertToUnixPath(dirName);
730 if (len <= 0) return false;
731
732 return m_pWriter->writeFileListRqst(len, dirName, bDirOnly);
733}
734
735bool
736FileTransfer::writeFileDownloadRqst(unsigned short filenameLen, char *pFilename,
737 unsigned int position)
738{
739 char filename[FT_FILENAME_SIZE];
740 strcpy(filename, pFilename);
741 unsigned short len = (unsigned short) convertToUnixPath(filename);
742 if (len <= 0) return false;
743
744 return m_pWriter->writeFileDownloadRqst(len, filename, position);
745}
746
747bool
748FileTransfer::writeFileUploadRqst(unsigned short filenameLen, char *pFilename,
749 unsigned int position)
750{
751 char filename[FT_FILENAME_SIZE];
752 strcpy(filename, pFilename);
753 unsigned short len = (unsigned short) convertToUnixPath(filename);
754 if (len <= 0) return false;
755
756 return m_pWriter->writeFileUploadRqst(len, filename, position);
757}
758
759bool
760FileTransfer::writeFileCreateDirRqst(unsigned short dirNameLen, char *pDirName)
761{
762 char path[FT_FILENAME_SIZE];
763 strcpy(path, pDirName);
764 int nameLen = convertToUnixPath(path);
765
766 return m_pWriter->writeFileCreateDirRqst(nameLen, path);
767}
768
769bool
770FileTransfer::writeFileDirSizeRqst(unsigned short dirNameLen, char *pDirName)
771{
772 char path[FT_FILENAME_SIZE];
773 strcpy(path, pDirName);
774 int nameLen = convertToUnixPath(path);
775
776 return m_pWriter->writeFileDirSizeRqst(nameLen, path);
777}
778
779bool
780FileTransfer::writeFileRenameRqst(unsigned short oldNameLen, unsigned short newNameLen,
781 char *pOldName, char *pNewName)
782{
783 char oldName[FT_FILENAME_SIZE];
784 char newName[FT_FILENAME_SIZE];
785
786 strcpy(oldName, pOldName);
787 strcpy(newName, pNewName);
788
789 int _oldNameLen = convertToUnixPath(oldName);
790 int _newNameLen = convertToUnixPath(newName);
791
792 return m_pWriter->writeFileRenameRqst(_oldNameLen, _newNameLen, oldName, newName);
793}
794
795bool
796FileTransfer::writeFileDeleteRqst(unsigned short nameLen, char *pName)
797{
798 char path[FT_FILENAME_SIZE];
799 strcpy(path, pName);
800 int _nameLen = convertToUnixPath(path);
801
802 return m_pWriter->writeFileDeleteRqst(_nameLen, path);
803}