source: trunk/tools/qtestlib/wince/cetcpsyncserver/commands.cpp@ 561

Last change on this file since 561 was 561, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.1 sources.
  • Property svn:eol-style set to native
File size: 21.6 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the tools applications of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41#include "commands.h"
42#include <QtCore/QDebug>
43#include <QtCore/QFileInfo>
44#include <QtCore/QDir>
45#include <QtCore/QProcess>
46
47#ifdef Q_OS_WINCE
48#include <windows.h>
49#endif
50
51/////////////////////////////////////////////////////
52// Abstract Command Implementation //
53/////////////////////////////////////////////////////
54AbstractCommand::AbstractCommand()
55: m_socket(0)
56{
57}
58
59AbstractCommand::~AbstractCommand()
60{
61}
62
63void AbstractCommand::reportSuccess()
64{
65 m_socket->write(COMMAND_SUCCESS, strlen(COMMAND_SUCCESS));
66 m_socket->waitForBytesWritten();
67}
68
69void AbstractCommand::reportError()
70{
71 m_socket->write(COMMAND_ERROR, strlen(COMMAND_ERROR));
72 m_socket->waitForBytesWritten();
73}
74
75void AbstractCommand::dataReceived(QByteArray&)
76{
77 debugOutput(1, "AbstractCommand::dataReceived NOT SUPPOSED TO BE HERE");
78}
79
80void AbstractCommand::commandFinished()
81{
82 debugOutput(1, "AbstractCommand::commandFinished()NOT SUPPOSED TO BE HERE");
83}
84
85void AbstractCommand::setSocket(QTcpSocket* socket)
86{
87 debugOutput(0, "AbstractCommand::setSocket()");
88 Q_ASSERT(socket);
89 m_socket = socket;
90 connect(m_socket, SIGNAL(readyRead()), this, SLOT(_readData()));
91 reportSuccess();
92}
93
94QTcpSocket* AbstractCommand::socket()
95{
96 return m_socket;
97}
98
99void AbstractCommand::_readData()
100{
101 QByteArray arr = m_socket->readAll();
102 dataReceived(arr);
103}
104
105void AbstractCommand::_disconnect()
106{
107}
108
109/////////////////////////////////////////////////////
110// Create File Command Implementation //
111/////////////////////////////////////////////////////
112CreateFileCommand::CreateFileCommand()
113: m_dataCount(0)
114{
115 debugOutput(0, "CreateFileCommand::CreateFileCommand");
116 m_options.fileSize= -1;
117}
118
119CreateFileCommand::~CreateFileCommand()
120{
121 debugOutput(0, "CreateFileCommand::~CreateFileCommand");
122 if (m_file.isOpen()) {
123 fprintf(stderr, "****************FILE IS STILL OPENED AND HAVENT FINISHED WRITING**********************\n");
124 fprintf(stderr, "Current: %d Expected: %d\n", m_dataCount , m_options.fileSize);
125 m_file.close();
126 }
127}
128
129void CreateFileCommand::dataReceived(QByteArray &data)
130{
131 bool successful = true;
132 // If we haven't received the options yet
133 if (m_options.fileSize == -1) {
134 CreateFileOptions* opt = (CreateFileOptions*) data.data();
135 memcpy(&m_options , opt , sizeof(CreateFileOptions));
136
137 if (QFileInfo(QString::fromLatin1(m_options.fileName)).exists()) {
138 if (m_options.overwriteExisting) {
139#ifdef Q_OS_WINCE
140 SetFileAttributes(QFileInfo(m_options.fileName).absoluteFilePath().utf16(), FILE_ATTRIBUTE_NORMAL);
141#endif
142 QFile::remove(m_options.fileName);
143 } else
144 successful = false;
145 }
146 m_file.setFileName(QString::fromLatin1(m_options.fileName));
147 if (!m_file.open(QIODevice::WriteOnly))
148 successful = false;
149 else
150 debugOutput(3, QString::fromLatin1("Creating file: %1").arg(m_options.fileName));
151 } else { // write buffer on disc
152 if (!m_file.isOpen())
153 return;
154 m_file.write(data);
155 m_dataCount += data.size();
156 if (m_dataCount >= m_options.fileSize) {
157 // We do not care about more data than announced
158 m_file.close();
159 }
160 }
161
162 if (successful)
163 reportSuccess();
164 else
165 reportError();
166}
167
168void CreateFileCommand::commandFinished()
169{
170 debugOutput(0, "CreateFileCommand::commandFinished");
171#ifdef Q_OS_WIN
172 // We need to set the file attributes for intelligent time comparisons
173 QString tmpFile = QString::fromLatin1(m_options.fileName);
174 HANDLE handle = CreateFile(tmpFile.utf16(), GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
175 if (handle != INVALID_HANDLE_VALUE) {
176 SetFileTime(handle, &(m_options.fileTime), NULL, NULL);
177 CloseHandle(handle);
178 }
179 SetFileAttributes(tmpFile.utf16(), m_options.fileAttributes);
180#endif
181}
182
183/////////////////////////////////////////////////////
184// Create Directory Command Implementation //
185/////////////////////////////////////////////////////
186CreateDirectoryCommand::CreateDirectoryCommand()
187 : AbstractCommand()
188{
189 debugOutput(0, "CreateDirectoryCommand::CreateDirectoryCommand");
190}
191
192CreateDirectoryCommand::~CreateDirectoryCommand()
193{
194 debugOutput(0, "CreateDirectoryCommand::~CreateDirectoryCommand()");
195}
196
197void CreateDirectoryCommand::dataReceived(QByteArray &data)
198{
199 debugOutput(0, "CreateDirectoryCommand::dataReceived()");
200 CreateDirectoryOptions* options = (CreateDirectoryOptions*) data.data();
201 debugOutput(3, QString::fromLatin1("Creating directory: %1").arg(options->dirName));
202 bool success = true;
203 QDir dir;
204 if (options->recursively)
205 success = dir.mkpath(options->dirName);
206 else
207 success = dir.mkdir(options->dirName);
208
209 if (success)
210 reportSuccess();
211 else
212 reportError();
213}
214
215void CreateDirectoryCommand::commandFinished()
216{
217 debugOutput(0, "CreateDirectoryCommand::commandFinished()");
218}
219
220/////////////////////////////////////////////////////
221// Copy File Command Implementation //
222/////////////////////////////////////////////////////
223CopyFileCommand::CopyFileCommand()
224 : AbstractCommand()
225{
226 debugOutput(0, "CopyFileCommand::CopyFileCommand()");
227}
228
229CopyFileCommand::~CopyFileCommand()
230{
231 debugOutput(0, "CopyFileCommand::~CopyFileCommand()");
232}
233
234void CopyFileCommand::dataReceived(QByteArray &data)
235{
236 debugOutput(0, "CopyFileCommand::dataReceived()");
237 CopyFileOptions* options = (CopyFileOptions*) data.data();
238 debugOutput(3, QString::fromLatin1("Copy File: %1 -> %2").arg(options->from).arg(options->to));
239 bool success = true;
240 if (QFileInfo(options->to).exists()) {
241 if (options->overwriteExisting)
242 QFile::remove(options->to);
243 else
244 success = false;
245 }
246 if (success)
247 if (!QFile::copy(options->from , options->to))
248 success = false;
249
250 if (success)
251 reportSuccess();
252 else
253 reportError();
254}
255
256void CopyFileCommand::commandFinished()
257{
258 debugOutput(0, "CopyFileCommand::commandFinished()");
259}
260
261/////////////////////////////////////////////////////
262// Copy Directory Command Implementation //
263/////////////////////////////////////////////////////
264CopyDirectoryCommand::CopyDirectoryCommand()
265 : AbstractCommand()
266{
267 debugOutput(0, "CopyDirectoryCommand::CopyDirectoryCommand()");
268}
269
270CopyDirectoryCommand::~CopyDirectoryCommand()
271{
272 debugOutput(0, "CopyDirectoryCommand::~CopyDirectoryCommand()");
273}
274
275void CopyDirectoryCommand::dataReceived(QByteArray &data)
276{
277 debugOutput(0, "CopyDirectoryCommand::dataReceived()");
278 CopyDirectoryOptions* options = (CopyDirectoryOptions*) data.data();
279 debugOutput(3, QString::fromLatin1("Copy Directory: %1 %2").arg(options->from).arg(options->to));
280 if (copyDir(QLatin1String(options->from) , QLatin1String(options->to) , options->recursive))
281 reportSuccess();
282 else
283 reportError();
284}
285
286void CopyDirectoryCommand::commandFinished()
287{
288 debugOutput(0, "CopyDirectoryCommand::commandFinished()");
289}
290
291bool CopyDirectoryCommand::copyDir(const QString &from, const QString &to, bool recursive)
292{
293 QDir().mkpath(to);
294 QDir sourceDir(from);
295 QDir destDir(to);
296 QStringList entries = sourceDir.entryList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
297 foreach (QString item , entries) {
298 QString itemFrom = sourceDir.absoluteFilePath(item);
299 QString itemTo = destDir.absoluteFilePath(item);
300 if (QFileInfo(item).isDir()) {
301 if (recursive && !copyDir(itemFrom, itemTo, recursive))
302 return false;
303 } else {
304 if (!QFile::copy(itemFrom, itemTo))
305 return false;
306 }
307 }
308 return true;
309}
310
311/////////////////////////////////////////////////////
312// Delete File Command Implementation //
313/////////////////////////////////////////////////////
314DeleteFileCommand::DeleteFileCommand()
315 : AbstractCommand()
316{
317 debugOutput(0, "DeleteFileCommand::DeleteFileCommand()");
318}
319
320DeleteFileCommand::~DeleteFileCommand()
321{
322 debugOutput(0, "DeleteFileCommand::~DeleteFileCommand()");
323}
324
325void DeleteFileCommand::dataReceived(QByteArray &data)
326{
327 debugOutput(0, "DeleteFileCommand::dataReceived()");
328 DeleteFileOptions* options = (DeleteFileOptions*) data.data();
329 debugOutput(3, QString::fromLatin1("Delete File: %1").arg(options->fileName));
330 bool success = true;
331 QFile file(options->fileName);
332 if (file.exists()) {
333#ifdef Q_OS_WINCE
334 SetFileAttributes(QFileInfo(options->fileName).absoluteFilePath().utf16(), FILE_ATTRIBUTE_NORMAL);
335#endif
336 success = file.remove();
337 } else
338 success = false;
339
340 if (success)
341 reportSuccess();
342 else
343 reportError();
344}
345
346void DeleteFileCommand::commandFinished()
347{
348 debugOutput(0, "DeleteFileCommand::commandFinished()");
349}
350
351/////////////////////////////////////////////////////
352// Delete Directory Command Implementation //
353/////////////////////////////////////////////////////
354DeleteDirectoryCommand::DeleteDirectoryCommand()
355 : AbstractCommand()
356{
357 debugOutput(0, "DeleteDirectoryCommand::DeleteDirectoryCommand()");
358}
359
360DeleteDirectoryCommand::~DeleteDirectoryCommand()
361{
362 debugOutput(0, "DeleteDirectoryCommand::~DeleteDirectoryCommand()");
363}
364
365void DeleteDirectoryCommand::dataReceived(QByteArray &data)
366{
367 debugOutput(0, "DeleteDirectoryCommand::dataReceived()");
368 DeleteDirectoryOptions* options = (DeleteDirectoryOptions*) data.data();
369 debugOutput(3, QString::fromLatin1("Delete directory: %1").arg(options->dirName));
370 if (deleteDirectory(QLatin1String(options->dirName), options->recursive, options->failIfContentExists))
371 reportSuccess();
372 else
373 reportError();
374}
375
376void DeleteDirectoryCommand::commandFinished()
377{
378 debugOutput(0, "DeleteDirectoryCommand::commandFinished()");
379}
380
381bool DeleteDirectoryCommand::deleteDirectory(const QString &dirName, bool recursive, bool failIfContentExists)
382{
383 QDir dir(dirName);
384 if (!dir.exists())
385 return false;
386
387 QStringList itemList = dir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
388 if (itemList.size() > 0 && failIfContentExists)
389 return false;
390
391 foreach (QString item, itemList) {
392 QString itemName = dir.absoluteFilePath(item);
393 if (QFileInfo(itemName).isDir()) {
394 if (recursive && !deleteDirectory(itemName, recursive, failIfContentExists))
395 return false;
396 } else {
397 if (!dir.remove(item))
398 return false;
399 }
400 }
401 QString lastName = dir.dirName();
402 dir.cdUp();
403 dir.rmpath(lastName);
404 return true;
405}
406
407/////////////////////////////////////////////////////
408// Execute Command Implementation //
409/////////////////////////////////////////////////////
410ExecuteCommand::ExecuteCommand()
411 : AbstractCommand()
412 , m_argumentCount(0)
413 , m_timeout(-1)
414{
415 debugOutput(0, "ExecuteCommand::ExecuteCommand()");
416}
417
418ExecuteCommand::~ExecuteCommand()
419{
420 debugOutput(0, "ExecuteCommand::~ExecuteCommand()");
421}
422
423void ExecuteCommand::dataReceived(QByteArray &data)
424{
425 debugOutput(0, "ExecuteCommand::dataReceived()");
426
427 if (m_argumentCount == 0) {
428 ExecuteOptions* options = (ExecuteOptions*) data.data();
429 if (!QFileInfo(options->appName).exists()) {
430 debugOutput(1, "Error execute: application does not exist");
431 reportError();
432 return;
433 }
434
435 m_program = QLatin1String(options->appName);
436 m_argumentCount = options->argumentsCount;
437 m_waitFinished = options->waitForFinished;
438 m_timeout = options->timeout;
439 if (m_argumentCount == 0)
440 m_argumentCount = -1; // to trigger startup on next receive
441 reportSuccess();
442 } else if (m_arguments.size() < m_argumentCount) {
443 m_arguments += data;
444 reportSuccess();
445 } else { // do the execution
446 if (data == COMMAND_SUCCESS)
447 _doExecute();
448 }
449}
450
451void ExecuteCommand::_doExecute()
452{
453 debugOutput(0, "ExecuteCommand::_doExecute()");
454 debugOutput(3, QString::fromLatin1("Execute: %1 %2").arg(m_program).arg(m_arguments.join(" ")));
455 if (m_waitFinished) {
456 QProcess process;
457 process.start(m_program, m_arguments);
458 if (process.waitForFinished(m_timeout) == false || process.exitCode() < 0)
459 reportError();
460 else
461 reportSuccess();
462 } else {
463 if (QProcess::startDetached(m_program, m_arguments))
464 reportSuccess();
465 else
466 reportError();
467 }
468}
469void ExecuteCommand::commandFinished()
470{
471 debugOutput(0,"ExecuteCommand::commandFinished()");
472}
473
474/////////////////////////////////////////////////////
475// Read File Implementation //
476/////////////////////////////////////////////////////
477ReadFileCommand::ReadFileCommand()
478 : AbstractCommand()
479 , m_currentPos(0)
480{
481 debugOutput(0, "ReadFileCommand::ReadFileCommand()");
482 m_fileName.clear();
483}
484
485ReadFileCommand::~ReadFileCommand()
486{
487 debugOutput(0, "ReadFileCommand::~ReadFileCommand()");
488 if (m_file.isOpen())
489 m_file.close();
490}
491
492void ReadFileCommand::dataReceived(QByteArray &data)
493{
494 debugOutput(0, "ReadFileCommand::dataReceived()");
495 if (m_fileName.isEmpty()) {
496 ReadFileOptions* option = (ReadFileOptions*) data.data();
497 m_fileName = QLatin1String(option->fileName);
498 QFileInfo info(m_fileName);
499 m_file.setFileName(m_fileName);
500 ReadFileReply reply;
501 if (!info.exists() || !info.isFile() || !m_file.open(QIODevice::ReadOnly))
502 reply.fileValid = false;
503 else
504 reply.fileValid = true;
505 reply.fileSize = info.size();
506 m_fileSize = reply.fileSize;
507 socket()->write((char*) &reply, sizeof(reply));
508 debugOutput(3, QString::fromLatin1("Reading file: %1").arg(m_fileName));
509 } else {
510 QTcpSocket* sock = socket(); // design failure???
511 if (data != COMMAND_SUCCESS || m_currentPos >= m_fileSize) {
512 sock->disconnectFromHost();
513 return;
514 }
515 const int bufferSize = 1024;
516 QByteArray buffer = m_file.read(bufferSize);
517 m_currentPos += buffer.size();
518 sock->write(buffer);
519 sock->waitForBytesWritten();
520 }
521}
522
523void ReadFileCommand::commandFinished()
524{
525 debugOutput(0, "ReadFileCommand::commandFinished()");
526}
527
528/////////////////////////////////////////////////////
529// Read Directory Implementation //
530/////////////////////////////////////////////////////
531ReadDirectoryCommand::ReadDirectoryCommand()
532 : AbstractCommand()
533 , m_iterator(0)
534{
535 debugOutput(0, "ReadDirectoryCommand::ReadDirectoryCommand");
536 m_dirName.clear();
537}
538
539ReadDirectoryCommand::~ReadDirectoryCommand()
540{
541 debugOutput(0, "ReadDirectoryCommand::~ReadDirectoryCommand()");
542 delete m_iterator;
543}
544
545void ReadDirectoryCommand::dataReceived(QByteArray &data)
546{
547 debugOutput(0, "ReadDirectoryCommand::dataReceived()");
548 QTcpSocket* sock = socket();
549 if (m_dirName.isEmpty()) {
550 ReadDirectoryOptions* option = (ReadDirectoryOptions*) data.data();
551 QFileInfo info(QLatin1String(option->dirName));
552 debugOutput(3, QString::fromLatin1("Reading Directory entries: %1").arg(option->dirName));
553 ReadDirectoryReply reply;
554 if (!info.exists() || !info.isDir()) {
555 reply.itemCount = -1;
556 reply.entryValid = false;
557 } else {
558 m_dirName = QLatin1String(option->dirName);
559 m_dir.setPath(m_dirName);
560 m_iterator = new QDirIterator(m_dir);
561 reply.itemCount = m_dir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot).size();
562 reply.entryValid = true;
563 }
564 sock->write((char*) &reply, sizeof(reply));
565 sock->waitForBytesWritten();
566 } else {
567 if (data != COMMAND_SUCCESS) {
568 qDebug() << "Something went wrong in the meantime";
569 return;
570 }
571 ReadDirectoryItem reply;
572 if (m_iterator->hasNext()) {
573 m_iterator->next();
574 QFileInfo info = m_iterator->fileInfo();
575 strcpy(reply.name, qPrintable(info.absoluteFilePath()));
576 reply.isDirectory = info.isDir();
577 if (!reply.isDirectory)
578 reply.size = info.size();
579 }
580 reply.hasMore = m_iterator->hasNext();
581 sock->write((char*) &reply, sizeof(reply));
582 sock->waitForBytesWritten();
583 }
584}
585
586void ReadDirectoryCommand::commandFinished()
587{
588 debugOutput(0, "ReadDirectoryCommand::commandFinished()");
589}
590
591/////////////////////////////////////////////////////
592// File Time Implementation //
593/////////////////////////////////////////////////////
594FileTimeCommand::FileTimeCommand()
595 : AbstractCommand()
596{
597 debugOutput(0, "FileTimeCommand::FileTimeCommand()");
598}
599
600FileTimeCommand::~FileTimeCommand()
601{
602 debugOutput(0, "FileTimeCommand::~FileTimeCommand()");
603}
604
605void FileTimeCommand::dataReceived(QByteArray &data)
606{
607 debugOutput(0, "FileTimeCommand::dataReceived()");
608 FileTimeOptions* option = (FileTimeOptions*) data.data();
609
610 FILETIME resultTime;
611 resultTime.dwLowDateTime = -1;
612 resultTime.dwHighDateTime = -1;
613
614#ifdef Q_OS_WIN
615 QString fileName = QLatin1String(option->fileName);
616 HANDLE deviceHandle = CreateFile(fileName.utf16(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
617 debugOutput(3, QString::fromLatin1("Asking FileTime: %1").arg(fileName));
618 if (deviceHandle != INVALID_HANDLE_VALUE) {
619 FILETIME deviceCreationTime;
620 if (GetFileTime(deviceHandle, &deviceCreationTime, NULL, NULL)) {
621 resultTime = deviceCreationTime;
622 }
623 CloseHandle(deviceHandle);
624 }
625#endif
626 QTcpSocket* sock = socket();
627 sock->write((char*) &resultTime, sizeof(resultTime));
628 sock->waitForBytesWritten();
629}
630
631void FileTimeCommand::commandFinished()
632{
633 debugOutput(0, "FileTimeCommand::commandFinished()");
634}
635
636/////////////////////////////////////////////////////
637// Time Stamp Implementation //
638/////////////////////////////////////////////////////
639TimeStampCommand::TimeStampCommand()
640 : AbstractCommand()
641{
642 debugOutput(0, "TimeStampCommand::TimeStampCommand()");
643}
644
645TimeStampCommand::~TimeStampCommand()
646{
647 debugOutput(0, "TimeStampCommand::~TimeStampCommand()");
648}
649
650void TimeStampCommand::dataReceived(QByteArray &data)
651{
652 debugOutput(0, "TimeStampCommand::dataReceived()");
653 FILETIME resultTime;
654 resultTime.dwLowDateTime = -1;
655 resultTime.dwHighDateTime = -1;
656
657#ifdef Q_OS_WIN
658 FILETIME stampTime = *((FILETIME*)data.data());
659
660 QString tmpFile = QString::fromLatin1("\\qt_tmp_ftime_convert");
661 HANDLE remoteHandle = CreateFile(tmpFile.utf16(), GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
662 if (remoteHandle != INVALID_HANDLE_VALUE) {
663 if (!SetFileTime(remoteHandle, &stampTime, NULL, NULL)) {
664 CloseHandle(remoteHandle);
665 } else {
666 CloseHandle(remoteHandle);
667 remoteHandle = CreateFile(tmpFile.utf16(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
668 if (remoteHandle != INVALID_HANDLE_VALUE) {
669 if (GetFileTime(remoteHandle, &stampTime, NULL, NULL))
670 resultTime = stampTime;
671 CloseHandle(remoteHandle);
672 DeleteFile(tmpFile.utf16());
673 }
674 }
675 }
676 debugOutput(3, QString::fromLatin1("Asking TimeStamp"));
677#endif
678 QTcpSocket* sock = socket();
679 sock->write((char*) &resultTime, sizeof(resultTime));
680 sock->waitForBytesWritten();
681}
682
683void TimeStampCommand::commandFinished()
684{
685 debugOutput(0, "TimeStampCommand::commandFinished()");
686}
Note: See TracBrowser for help on using the repository browser.