QCA

qca_support.h
Go to the documentation of this file.
1/*
2 * qca_support.h - Qt Cryptographic Architecture
3 * Copyright (C) 2003-2005 Justin Karneges <justin@affinix.com>
4 * Copyright (C) 2004,2005, 2007 Brad Hards <bradh@frogmouth.net>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 * 02110-1301 USA
20 *
21 */
22
23/**
24 \file qca_support.h
25
26 Header file for "support" classes used in %QCA
27
28 The classes in this header do not have any cryptographic
29 content - they are used in %QCA, and are included for convenience.
30
31 \note You should not use this header directly from an
32 application. You should just use <tt> \#include <QtCrypto>
33 </tt> instead.
34*/
35
36#ifndef QCA_SUPPORT_H
37#define QCA_SUPPORT_H
38
39#include "qca_export.h"
40#include "qca_tools.h"
41#include <QByteArray>
42#include <QList>
43#include <QMetaObject>
44#include <QObject>
45#include <QString>
46#include <QStringList>
47#include <QThread>
48#include <QVariant>
49#include <QVariantList>
50
51namespace QCA {
52
53/**
54 Convenience method to determine the return type of a method
55
56 This function identifies the return type of a specified
57 method. This function can be used as shown:
58 \code
59class TestClass : public QObject
60{
61 Q_OBJECT
62 // ...
63public slots:
64 QString qstringMethod() { return QString(); };
65 bool boolMethod( const QString & ) { return true; };
66};
67
68QByteArray myTypeName;
69
70TestClass testClass;
71QList<QByteArray> argsList; // empty list, since no args
72
73myTypeName = QCA::methodReturnType( testClass.metaObject(), QByteArray( "qstringMethod" ), argsList );
74// myTypeName is "QString"
75
76myTypeName = QCA::methodReturnType( testClass.metaObject(), QByteArray( "boolMethod" ), argsList );
77// myTypeName is "", because there is no method called "boolMethod" that has no arguments
78
79argsList << "QString"; // now we have one argument
80myTypeName = QCA::methodReturnType( testClass.metaObject(), QByteArray( "boolMethod" ), argsList );
81// myTypeName is "bool"
82 \endcode
83
84 The return type name of a method returning void is an empty string, not "void"
85
86 \note This function is not normally required for use with
87 %QCA. It is provided for use in your code, if required.
88
89 \param obj the QMetaObject for the object
90 \param method the name of the method (without the arguments or brackets)
91 \param argTypes the list of argument types of the method
92
93 \return the name of the type that this method will return with the specified
94 argument types.
95
96 \sa QMetaType for more information on the Qt meta type system.
97
98 \relates SyncThread
99*/
100
101#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
102QCA_EXPORT int methodReturnType(const QMetaObject *obj, const QByteArray &method, const QList<QByteArray> &argTypes);
103#else
104QCA_EXPORT QByteArray methodReturnType(const QMetaObject *obj,
105 const QByteArray &method,
106 const QList<QByteArray> argTypes);
107#endif
108
109/**
110 Convenience method to invoke a method by name, using a variant
111 list of arguments.
112
113 This function can be used as shown:
114 \code
115class TestClass : public QObject
116{
117 Q_OBJECT
118 // ...
119public slots:
120 QString qstringMethod() { return QString( "the result" ); };
121 bool boolMethod( const QString & ) { return true; };
122};
123
124TestClass *testClass = new TestClass;
125QVariantList args;
126
127QVariant stringRes;
128// calls testClass->qstringMethod() with no arguments ( since args is an empty list)
129bool ret = QCA::invokeMethodWithVariants( testClass, QByteArray( "qstringMethod" ), args, &stringRes );
130// ret is true (since call succeeded), stringRes.toString() is a string - "the result"
131
132QVariant boolResult;
133QString someString( "not important" );
134args << someString;
135// calls testClass->boolMethod( someString ), returning result in boolResult
136ret = QCA::invokeMethodWithVariants( testClass1, QByteArray( "boolMethod" ), args, &boolResult );
137// ret is true (since call succeeded), boolResult.toBool() is true.
138 \endcode
139
140 \param obj the object to call the method on
141 \param method the name of the method (without the arguments or brackets)
142 \param args the list of arguments to use in the method call
143 \param ret the return value of the method (unchanged if the call fails)
144 \param type the type of connection to use
145
146 \return true if the call succeeded, otherwise false
147
148 \relates SyncThread
149*/
151 const QByteArray &method,
152 const QVariantList &args,
153 QVariant *ret,
155
156/**
157 \class SyncThread qca_support.h QtCrypto
158
159 Convenience class to run a thread and interact with it synchronously
160
161 SyncThread makes it easy to perform the common practice of starting a
162 thread, running some objects in that thread, and then interacting with
163 those objects safely. Often, there is no need to directly use threading
164 primitives (e.g. QMutex), resulting in very clean multi-threaded code.
165
166 \note The following is an excerpt from
167 http://delta.affinix.com/2006/11/13/synchronized-threads-part-3/
168
169 ---<br>
170 With SyncThread, you can start, stop, and call a method in another thread
171 while the main thread sleeps. The only requirement is that the methods be
172 declared as slots.
173
174 Below is a contrived example, where we have an object in another thread
175 that increments a counter over a some interval, using the Qt event loop,
176 and provides a method to inspect the value.
177
178 First, the Counter object:
179
180\code
181class Counter : public QObject
182{
183 Q_OBJECT
184private:
185 int x;
186 QTimer timer;
187
188public:
189 Counter() : timer(this)
190 {
191 x = 0;
192 connect(&timer, &QTimer::timeout, this, &Counter::t_timeout);
193 }
194
195public slots:
196 void start(int seconds)
197 {
198 timer.setInterval(seconds * 1000);
199 timer.start();
200 }
201
202 int value() const
203 {
204 return x;
205 }
206
207private Q_SLOTS:
208 void t_timeout()
209 {
210 ++x;
211 }
212};
213\endcode
214
215 Looks like a typical object, no surprises.
216
217 Now to wrap Counter with SyncThread. We went over how to do this in the
218 first article, and it is very straightforward:
219
220\code
221class CounterThread : public SyncThread
222{
223 Q_OBJECT
224public:
225 Counter *counter;
226
227 CounterThread(QObject *parent) : SyncThread(parent)
228 {
229 counter = 0;
230 }
231
232 ~CounterThread()
233 {
234 // SyncThread will stop the thread on destruct, but since our
235 // atStop() function makes references to CounterThread's
236 // members, we need to shutdown here, before CounterThread
237 // destructs.
238 stop();
239 }
240
241protected:
242 virtual void atStart()
243 {
244 counter = new Counter;
245 }
246
247 virtual void atStop()
248 {
249 delete counter;
250 }
251};
252\endcode
253
254 We can then use it like this:
255
256\code
257CounterThread *thread = new CounterThread;
258
259// after this call, the thread is started and the Counter is ready
260thread->start();
261
262// let's start the counter with a 1 second interval
263thread->call(thread->counter, "start", QVariantList() << 1);
264...
265
266// after some time passes, let's check on the value
267int x = thread->call(thread->counter, "value").toInt();
268
269// we're done with this thing
270delete thread;
271\endcode
272
273 Even without the call() function, SyncThread is still very useful
274 for preparing objects in another thread, which you can then
275 QObject::connect() to and use signals and slots like normal.
276
277 \ingroup UserAPI
278*/
279class QCA_EXPORT SyncThread : public QThread
280{
281 Q_OBJECT
282public:
283 /**
284 Standard constructor
285
286 \param parent the parent object for this parent.
287 */
288 SyncThread(QObject *parent = nullptr);
289
290 /**
291 Calls stop() and then destructs
292
293 \note Subclasses should call stop() in their own destructor
294 */
295 ~SyncThread() override;
296
297 /**
298 Starts the thread, begins the event loop the thread, and then
299 calls atStart() in the thread. This function will block until
300 atStart() has returned.
301 */
302 void start();
303
304 /**
305 Stops the event loop of the thread, calls atStop() in the thread,
306 and instructs the thread to finish. This function will block
307 until the thread has finished.
308 */
309 void stop();
310
311 /**
312 Calls a slot of an object in the thread. This function will block
313 until the slot has returned.
314
315 It is possible for the call to fail, for example if the method
316 does not exist.
317
318 The arguments and return value of the call use QVariant. If the
319 method has no return value (returns void), then the returned
320 QVariant will be null.
321
322 \param obj the object to call the method on
323 \param method the name of the method (without the arguments or
324 brackets)
325 \param args the list of arguments to use in the method call
326 \param ok if not 0, true is stored here if the call succeeds,
327 otherwise false is stored here.
328 */
330 call(QObject *obj, const QByteArray &method, const QVariantList &args = QVariantList(), bool *ok = nullptr);
331
332protected:
333 /**
334 Reimplement this to perform your initialization
335 */
336 virtual void atStart() = 0;
337
338 /**
339 Reimplement this to perform your deinitialization
340 */
341 virtual void atEnd() = 0;
342
343 /**
344 Starts the event loop and calls atStart and atStop as necessary
345 */
346 void run() override;
347
348private:
349 Q_DISABLE_COPY(SyncThread)
350
351 class Private;
352 friend class Private;
353 Private *d;
354};
355
356/**
357 \class Synchronizer qca_support.h QtCrypto
358
359 Enable synchronization between two threads.
360*/
361class QCA_EXPORT Synchronizer : public QObject
362{
363 Q_OBJECT
364public:
365 /**
366 Standard constructor
367
368 \param parent the parent object to this object
369 */
371 ~Synchronizer() override;
372
373 /**
374 Call to pause execution in this thread. This function
375 will block until conditionMet() is called.
376
377 \param msecs the time to wait before proceeding. The default
378 timeout value (-1) indicates to wait indefinitely.
379 */
380 bool waitForCondition(int msecs = -1);
381
382 /**
383 Call to continue execution in the paused thread.
384 */
386
387private:
388 Q_DISABLE_COPY(Synchronizer)
389
390 class Private;
391 Private *d;
392};
393
394/**
395 \class DirWatch qca_support.h QtCrypto
396
397 Support class to monitor a directory for activity.
398
399 %DirWatch monitors a specified file for any changes. When
400 the directory changes, the changed() signal is emitted.
401
402 \note QFileSystemWatcher has very similar functionality
403 to this class. You should evaluate this class and
404 QFileSystemWatcher to determine which better suits your
405 application needs.
406
407 \ingroup UserAPI
408*/
409class QCA_EXPORT DirWatch : public QObject
410{
411 Q_OBJECT
412public:
413 /**
414 Standard constructor
415
416 \param dir the name of the directory to watch. If not
417 set in the constructor, you can set it using setDirName()
418 \param parent the parent object for this object
419 */
420 explicit DirWatch(const QString &dir = QString(), QObject *parent = nullptr);
421 ~DirWatch() override;
422
423 /**
424 The name of the directory that is being monitored
425 */
427
428 /**
429 Change the directory being monitored
430
431 \param dir the name of the directory to monitor
432 */
433 void setDirName(const QString &dir);
434
435Q_SIGNALS:
436 /**
437 The changed signal is emitted when the directory is
438 changed (e.g.\ modified by addition or deletion of a
439 file within the directory, or the deletion of the
440 directory)
441 */
442 void changed();
443
444private:
445 Q_DISABLE_COPY(DirWatch)
446
447 class Private;
448 friend class Private;
449 Private *d;
450};
451
452/**
453 \class FileWatch qca_support.h QtCrypto
454
455 Support class to monitor a file for activity
456
457 %FileWatch monitors a specified file for any changes. When
458 the file changes, the changed() signal is emitted.
459
460 \note QFileSystemWatcher has very similar functionality
461 to this class. You should evaluate this class and
462 QFileSystemWatcher to determine which better suits your
463 application needs.
464
465 \ingroup UserAPI
466*/
467class QCA_EXPORT FileWatch : public QObject
468{
469 Q_OBJECT
470public:
471 /**
472 Standard constructor
473
474 \param file the name of the file to watch. If not
475 in this object, you can set it using setFileName()
476 \param parent the parent object for this object
477 */
478 explicit FileWatch(const QString &file = QString(), QObject *parent = nullptr);
479 ~FileWatch() override;
480
481 /**
482 The name of the file that is being monitored
483 */
485
486 /**
487 Change the file being monitored
488
489 \param file the name of the file to monitor
490 */
491 void setFileName(const QString &file);
492
493Q_SIGNALS:
494 /**
495 The changed signal is emitted when the file is
496 changed (e.g. modified, deleted)
497 */
498 void changed();
499
500private:
501 Q_DISABLE_COPY(FileWatch)
502
503 class Private;
504 friend class Private;
505 Private *d;
506};
507
508class ConsolePrivate;
509class ConsoleReferencePrivate;
510class ConsoleReference;
511
512/**
513 \class Console qca_support.h QtCrypto
514
515 %QCA %Console system
516
517 %QCA provides an API for asynchronous, event-based access to
518 the console and stdin/stdout, as these facilities are
519 otherwise not portable. The primary use of this system within
520 %QCA is for passphrase prompting in command-line applications,
521 using the tty console type.
522
523 How it works: Create a %Console object for the type of console
524 desired, and then use ConsoleReference to act on the console.
525 Only one ConsoleReference may operate on a %Console at a time.
526
527 A %Console object takes over either the physical console (Console::Tty
528 type) or stdin/stdout (Console::Stdio type). Only one of each type
529 may be created at a time.
530
531 Whenever code is written that needs a tty or stdio object, the
532 code should first call one of the static methods (ttyInstance()
533 or stdioInstance()) to see if a console object for the desired
534 type exists already. If the object exists, use it. If it does
535 not exist, the rule is that the relevant code should create the
536 object, use the object, and then destroy the object when the
537 operation is completed.
538
539 By following the above rule, you can write code that utilizes
540 a console without the application having to create some master
541 console object for you. Of course, if the application has
542 created a console then it will be used.
543
544 The reason why there is a master console object is that it
545 is not guaranteed that all I/O will survive creation and
546 destruction of a console object. If you are using the Stdio
547 Type, then you probably want a long-lived console object. It
548 is possible to capture unprocessed I/O by calling
549 bytesLeftToRead or bytesLeftToWrite. However, it is not
550 expected that general console-needing code will call these
551 functions when utilizing a temporary console. Thus, an
552 application developer would need to create his own console
553 object, invoke the console-needing code, and then do his own
554 extraction of the unprocessed I/O if necessary. Another reason
555 to extract unprocessed I/O is if you need to switch from
556 %Console back to standard functions (e.g. fgets() ).
557
558 \ingroup UserAPI
559*/
560class QCA_EXPORT Console : public QObject
561{
562 Q_OBJECT
563public:
564 /**
565 The type of console object
566 */
567 enum Type
568 {
569 Tty, ///< physical console
570 Stdio ///< stdin/stdout
571 };
572 /**
573 The type of I/O to use with the console object.
574 */
576 {
577 Read, ///< Read only (equivalent to stdin)
578 ReadWrite ///< Read/write (equivalent to stdin and stdout)
579 };
580
581 /**
582 The nature of the console operation
583 */
585 {
586 Default, ///< use default terminal settings
587 Interactive ///< char-by-char input, no echo
588 };
589
590 /**
591 Standard constructor
592
593 Note that library code should not create a new Console object
594 without checking whether there is already a Console object of
595 the required Type. See the main documentation for Console for the
596 rationale for this.
597
598 \param type the Type of Console object to create
599 \param cmode the ChannelMode (I/O type) to use
600 \param tmode the TerminalMode to use
601 \param parent the parent object for this object
602
603 \sa ttyInstance() and stdioInstance for static methods that allow
604 you to test whether there is already a Console object of the
605 required Type, and if there is, obtain a reference to that object.
606 */
607 Console(Type type, ChannelMode cmode, TerminalMode tmode, QObject *parent = nullptr);
608 ~Console() override;
609
610 /**
611 The Type of this Console object
612 */
613 Type type() const;
614
615 /**
616 The ChannelMode of this Console object
617 */
619
620 /**
621 The TerminalMode of this Console object
622 */
624
625 /**
626 Test whether standard input is redirected.
627
628 \sa type() and channelMode()
629 */
630 static bool isStdinRedirected();
631
632 /**
633 Test whether standard output is redirected.
634
635 \sa type() and channelMode()
636 */
637 static bool isStdoutRedirected();
638
639 /**
640 The current terminal-type console object
641
642 \return null if there is no current Console
643 of this type, otherwise the Console to use
644 */
646
647 /**
648 The current stdio-type console object
649
650 \return null if there is no current Console
651 of this type, otherwise the Console to use
652 */
654
655 /**
656 Release the Console
657
658 This allows access to buffers containing any remaining data
659 */
660 void release();
661
662 /**
663 Obtain remaining data from the Console, awaiting
664 a read operation
665 */
667
668 /**
669 Obtain remaining data from the Console, awaiting
670 a write operation
671 */
673
674private:
675 Q_DISABLE_COPY(Console)
676
677 friend class ConsolePrivate;
678 ConsolePrivate *d;
679
680 friend class ConsoleReference;
681};
682
683/**
684 \class ConsoleReference qca_support.h QtCrypto
685
686 Manager for a Console
687
688 \note Only one %ConsoleReference object can be active at a time
689
690 \ingroup UserAPI
691*/
692class QCA_EXPORT ConsoleReference : public QObject
693{
694 Q_OBJECT
695public:
696 /**
697 The security setting to use for the Console being managed.
698 */
700 {
701 SecurityDisabled,
702 SecurityEnabled
703 };
704
705 /**
706 Standard constructor
707
708 \param parent the parent object for this object
709 */
710 ConsoleReference(QObject *parent = nullptr);
711 ~ConsoleReference() override;
712
713 /**
714 Set the Console object to be managed, and start processing.
715
716 You typically want to use Console::ttyInstance() or
717 Console::stdioInstance() to obtain the required Console
718 reference.
719
720 \param console reference to the Console to be managed
721 \param mode the SecurityMode to use for this Console.
722
723 \sa QCA::Console for more information on how to handle the
724 console aspects of your application or library code.
725 */
726 bool start(Console *console, SecurityMode mode = SecurityDisabled);
727
728 /**
729 Stop processing, and release the Console
730 */
731 void stop();
732
733 /**
734 The Console object managed by this object
735
736 \sa start() to set the Console to be managed
737 */
738 Console *console() const;
739
740 /**
741 The security mode setting for the Console object
742 managed by this object.
743
744 \sa start() to set the SecurityMode
745 */
747
748 /**
749 Read data from the Console.
750
751 \param bytes the number of bytes to read. The default
752 is to read all available bytes
753
754 \sa readSecure() for a method suitable for reading
755 sensitive data.
756 */
757 QByteArray read(int bytes = -1);
758
759 /**
760 Write data to the Console.
761
762 \param a the array of data to write to the Console
763
764 \sa writeSecure() for a method suitable for writing
765 sensitive data.
766 */
767 void write(const QByteArray &a);
768
769 /**
770 Read secure data from the Console
771
772 \param bytes the number of bytes to read. The default
773 is to read all available bytes
774
775 \sa read() which is suitable for non-sensitive data
776 */
777 SecureArray readSecure(int bytes = -1);
778
779 /**
780 Write secure data to the Console
781
782 \param a the array of data to write to the Console
783
784 \sa write() which is suitable for non-sensitive data
785 */
786 void writeSecure(const SecureArray &a);
787
788 /**
789 Close the write channel
790
791 You only need to call this if writing is enabled
792 on the Console being managed.
793 */
795
796 /**
797 The number of bytes available to read from the
798 Console being managed.
799 */
800 int bytesAvailable() const;
801
802 /**
803 The number of bytes remaining to be written
804 to the Console being managed
805 */
806 int bytesToWrite() const;
807
808Q_SIGNALS:
809 /**
810 Emitted when there are bytes available to read from
811 the Console being managed
812 */
813 void readyRead();
814
815 /**
816 Emitted when bytes are written to the Console
817
818 \param bytes the number of bytes that were written
819
820 \sa bytesAvailable()
821 */
822 void bytesWritten(int bytes);
823
824 /**
825 Emitted when the console input is closed
826 */
828
829 /**
830 Emitted when the console output is closed
831 */
833
834private:
835 Q_DISABLE_COPY(ConsoleReference)
836
837 friend class ConsoleReferencePrivate;
838 ConsoleReferencePrivate *d;
839
840 friend class Console;
841};
842
843/**
844 \class ConsolePrompt qca_support.h QtCrypto
845
846 Console prompt handler.
847
848 This class provides a convenient way to get user input in a secure way,
849as shown below:
850\code
851QCA::ConsolePrompt prompt;
852prompt.getHidden("Passphrase");
853prompt.waitForFinished();
854QCA:SecureArray pass = prompt.result();
855\endcode
856
857 \note It is not necessary to use waitForFinished(), because you can
858 just connect the finished() signal to a suitable method, however
859 command line (console) applications often require waitForFinished().
860
861 \ingroup UserAPI
862*/
863class QCA_EXPORT ConsolePrompt : public QObject
864{
865 Q_OBJECT
866public:
867 /**
868 Standard constructor
869
870 \param parent the parent object for this object
871 */
872 ConsolePrompt(QObject *parent = nullptr);
873 ~ConsolePrompt() override;
874
875 /**
876 Allow the user to enter data without it being echo'd to
877 the terminal. This is particularly useful for entry
878 of passwords, passphrases and PINs.
879
880 \param promptStr the prompt to display to the user
881
882 \sa result() for how to get the input back.
883 */
884 void getHidden(const QString &promptStr);
885
886 /**
887 Obtain one character from the user
888
889 \sa resultChar() for how to get the input back.
890 */
891 void getChar();
892
893 /**
894 Block waiting for user input.
895
896 You may wish to use the finished() signal to
897 avoid blocking.
898 */
900
901 /**
902 Obtain the result of the user input.
903
904 This method is usually called to obtain data
905 from the user that was requested by the getHidden()
906 call.
907 */
909
910 /**
911 Obtain the result of the user input.
912
913 This method is usually called to obtain data
914 from the user that was requested by the getChar()
915 call.
916 */
918
919Q_SIGNALS:
920 /**
921 Emitted when the user input activity has been
922 completed.
923
924 This corresponds to the provision of a string
925 for getHidden() or a single character for getChar().
926
927 \sa waitForFinished
928 */
929 void finished();
930
931private:
932 Q_DISABLE_COPY(ConsolePrompt)
933
934 class Private;
935 friend class Private;
936 Private *d;
937};
938
940
941/**
942 \class Logger qca_support.h QtCrypto
943
944 A simple logging system
945
946 This class provides a simple but flexible approach to logging information
947 that may be used for debugging or system operation diagnostics.
948
949 There is a single %Logger for each application that uses %QCA. You do not
950 need to create this %Logger yourself - %QCA automatically creates it on
951 startup. You can get access to the %Logger using the global QCA::logger()
952 method.
953
954 By default the Logger just accepts all messages (binary and text). If you
955 want to get access to those messages, you need to subclass
956 AbstractLogDevice, and register your subclass (using registerLogDevice()).
957 You can then take whatever action is appropriate (e.g. show to the user
958 using the GUI, log to a file or send to standard error).
959
960 \ingroup UserAPI
961*/
962class QCA_EXPORT Logger : public QObject
963{
964 Q_OBJECT
965public:
966 /**
967 The severity of the message
968
969 This information may be used by the log device to determine
970 what the appropriate action is.
971 */
973 {
974 Quiet = 0, ///< Quiet: turn of logging
975 Emergency = 1, ///< Emergency: system is unusable
976 Alert = 2, ///< Alert: action must be taken immediately
977 Critical = 3, ///< Critical: critical conditions
978 Error = 4, ///< Error: error conditions
979 Warning = 5, ///< Warning: warning conditions
980 Notice = 6, ///< Notice: normal but significant condition
981 Information = 7, ///< Informational: informational messages
982 Debug = 8 ///< Debug: debug-level messages
983 };
984
985 /**
986 Get the current logging level
987
988 \return Current level
989 */
990 inline Severity level() const
991 {
992 return m_logLevel;
993 }
994
995 /**
996 Set the current logging level
997
998 \param level new logging level
999
1000 Only severities less or equal than the log level one will be logged
1001 */
1002 void setLevel(Severity level);
1003
1004 /**
1005 Log a message to all available log devices
1006
1007 \param message the text to log
1008 */
1009 void logTextMessage(const QString &message, Severity = Information);
1010
1011 /**
1012 Log a binary blob to all available log devices
1013
1014 \param blob the information to log
1015
1016 \note how this is handled is quite logger specific. For
1017 example, it might be logged as a binary, or it might be
1018 encoded in some way
1019 */
1020 void logBinaryMessage(const QByteArray &blob, Severity = Information);
1021
1022 /**
1023 Add an AbstractLogDevice subclass to the existing list of loggers
1024
1025 \param logger the LogDevice to add
1026 */
1028
1029 /**
1030 Remove an AbstractLogDevice subclass from the existing list of loggers
1031
1032 \param loggerName the name of the LogDevice to remove
1033
1034 \note If there are several log devices with the same name, all will be removed.
1035 */
1036 void unregisterLogDevice(const QString &loggerName);
1037
1038 /**
1039 Get a list of the names of all registered log devices
1040 */
1042
1043private:
1044 Q_DISABLE_COPY(Logger)
1045
1046 friend class Global;
1047
1048 /**
1049 Create a new message logger
1050 */
1051 Logger();
1052
1053 ~Logger() override;
1054
1055 QStringList m_loggerNames;
1057 Severity m_logLevel;
1058};
1059
1060/**
1061 \class AbstractLogDevice qca_support.h QtCrypto
1062
1063 An abstract log device
1064
1065 \ingroup UserAPI
1066*/
1067class QCA_EXPORT AbstractLogDevice : public QObject
1068{
1069 Q_OBJECT
1070public:
1071 /**
1072 The name of this log device
1073 */
1074 QString name() const;
1075
1076 /**
1077 Log a message
1078
1079 The default implementation does nothing - you should
1080 override this method in your subclass to do whatever
1081 logging is required
1082
1083 \param message the message to log
1084 \param severity the severity level of the message
1085 */
1086 virtual void logTextMessage(const QString &message, Logger::Severity severity);
1087
1088 /**
1089 Log a binary blob
1090
1091 The default implementation does nothing - you should
1092 override this method in your subclass to do whatever
1093 logging is required
1094
1095 \param blob the message (as a byte array) to log
1096 \param severity the severity level of the message
1097 */
1098 virtual void logBinaryMessage(const QByteArray &blob, Logger::Severity severity);
1099
1100protected:
1101 /**
1102 Create a new message logger
1103
1104 \param name the name of this log device
1105 \param parent the parent for this logger
1106 */
1107 explicit AbstractLogDevice(const QString &name, QObject *parent = nullptr);
1108
1109 ~AbstractLogDevice() override = 0;
1110
1111private:
1112 Q_DISABLE_COPY(AbstractLogDevice)
1113
1114 class Private;
1115 Private *d;
1116
1117 QString m_name;
1118};
1119
1120}
1121
1122#endif
An abstract log device.
QString name() const
The name of this log device.
AbstractLogDevice(const QString &name, QObject *parent=nullptr)
Create a new message logger.
virtual void logBinaryMessage(const QByteArray &blob, Logger::Severity severity)
Log a binary blob.
virtual void logTextMessage(const QString &message, Logger::Severity severity)
Log a message.
Console prompt handler.
void getChar()
Obtain one character from the user.
QChar resultChar() const
Obtain the result of the user input.
void waitForFinished()
Block waiting for user input.
void finished()
Emitted when the user input activity has been completed.
void getHidden(const QString &promptStr)
Allow the user to enter data without it being echo'd to the terminal.
SecureArray result() const
Obtain the result of the user input.
ConsolePrompt(QObject *parent=nullptr)
Standard constructor.
Manager for a Console.
SecurityMode securityMode() const
The security mode setting for the Console object managed by this object.
void outputClosed()
Emitted when the console output is closed.
void bytesWritten(int bytes)
Emitted when bytes are written to the Console.
void closeOutput()
Close the write channel.
void stop()
Stop processing, and release the Console.
ConsoleReference(QObject *parent=nullptr)
Standard constructor.
int bytesToWrite() const
The number of bytes remaining to be written to the Console being managed.
void write(const QByteArray &a)
Write data to the Console.
SecurityMode
The security setting to use for the Console being managed.
void writeSecure(const SecureArray &a)
Write secure data to the Console.
int bytesAvailable() const
The number of bytes available to read from the Console being managed.
QByteArray read(int bytes=-1)
Read data from the Console.
SecureArray readSecure(int bytes=-1)
Read secure data from the Console.
void readyRead()
Emitted when there are bytes available to read from the Console being managed.
void inputClosed()
Emitted when the console input is closed.
bool start(Console *console, SecurityMode mode=SecurityDisabled)
Set the Console object to be managed, and start processing.
Console * console() const
The Console object managed by this object.
QCA Console system
static Console * ttyInstance()
The current terminal-type console object.
Type
The type of console object.
@ Tty
physical console
Console(Type type, ChannelMode cmode, TerminalMode tmode, QObject *parent=nullptr)
Standard constructor.
static Console * stdioInstance()
The current stdio-type console object.
ChannelMode
The type of I/O to use with the console object.
@ Read
Read only (equivalent to stdin)
ChannelMode channelMode() const
The ChannelMode of this Console object.
QByteArray bytesLeftToRead()
Obtain remaining data from the Console, awaiting a read operation.
Type type() const
The Type of this Console object.
QByteArray bytesLeftToWrite()
Obtain remaining data from the Console, awaiting a write operation.
void release()
Release the Console.
TerminalMode
The nature of the console operation.
@ Default
use default terminal settings
static bool isStdinRedirected()
Test whether standard input is redirected.
TerminalMode terminalMode() const
The TerminalMode of this Console object.
static bool isStdoutRedirected()
Test whether standard output is redirected.
Support class to monitor a directory for activity.
QString dirName() const
The name of the directory that is being monitored.
DirWatch(const QString &dir=QString(), QObject *parent=nullptr)
Standard constructor.
void changed()
The changed signal is emitted when the directory is changed (e.g. modified by addition or deletion of...
void setDirName(const QString &dir)
Change the directory being monitored.
Support class to monitor a file for activity.
FileWatch(const QString &file=QString(), QObject *parent=nullptr)
Standard constructor.
QString fileName() const
The name of the file that is being monitored.
void setFileName(const QString &file)
Change the file being monitored.
void changed()
The changed signal is emitted when the file is changed (e.g.
A simple logging system.
QStringList currentLogDevices() const
Get a list of the names of all registered log devices.
Severity level() const
Get the current logging level.
void registerLogDevice(AbstractLogDevice *logger)
Add an AbstractLogDevice subclass to the existing list of loggers.
Severity
The severity of the message.
void logBinaryMessage(const QByteArray &blob, Severity=Information)
Log a binary blob to all available log devices.
void setLevel(Severity level)
Set the current logging level.
void unregisterLogDevice(const QString &loggerName)
Remove an AbstractLogDevice subclass from the existing list of loggers.
void logTextMessage(const QString &message, Severity=Information)
Log a message to all available log devices.
Secure array of bytes.
Definition qca_tools.h:317
Convenience class to run a thread and interact with it synchronously.
QCA_EXPORT bool invokeMethodWithVariants(QObject *obj, const QByteArray &method, const QVariantList &args, QVariant *ret, Qt::ConnectionType type=Qt::AutoConnection)
Convenience method to invoke a method by name, using a variant list of arguments.
virtual void atStart()=0
Reimplement this to perform your initialization.
QVariant call(QObject *obj, const QByteArray &method, const QVariantList &args=QVariantList(), bool *ok=nullptr)
Calls a slot of an object in the thread.
void run() override
Starts the event loop and calls atStart and atStop as necessary.
QCA_EXPORT int methodReturnType(const QMetaObject *obj, const QByteArray &method, const QList< QByteArray > &argTypes)
Convenience method to determine the return type of a method.
void stop()
Stops the event loop of the thread, calls atStop() in the thread, and instructs the thread to finish.
SyncThread(QObject *parent=nullptr)
Standard constructor.
virtual void atEnd()=0
Reimplement this to perform your deinitialization.
void start()
Starts the thread, begins the event loop the thread, and then calls atStart() in the thread.
~SyncThread() override
Calls stop() and then destructs.
Enable synchronization between two threads.
bool waitForCondition(int msecs=-1)
Call to pause execution in this thread.
void conditionMet()
Call to continue execution in the paused thread.
Synchronizer(QObject *parent)
Standard constructor.
QCA - the Qt Cryptographic Architecture.
Definition qca_basic.h:41
Header file for "tool" classes used in QCA.
ConnectionType
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri Jul 19 2024 11:55:06 by doxygen 1.11.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.