File indexing completed on 2024-04-07 04:36:22

0001 /*
0002  * Copyright (C) 2003-2007  Justin Karneges <justin@affinix.com>
0003  *
0004  * This library is free software; you can redistribute it and/or
0005  * modify it under the terms of the GNU Lesser General Public
0006  * License as published by the Free Software Foundation; either
0007  * version 2.1 of the License, or (at your option) any later version.
0008  *
0009  * This library is distributed in the hope that it will be useful,
0010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0012  * Lesser General Public License for more details.
0013  *
0014  * You should have received a copy of the GNU Lesser General Public
0015  * License along with this library; if not, write to the Free Software
0016  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
0017  * 02110-1301  USA
0018  *
0019  */
0020 
0021 // Note: if we ever enable the threaded backend, we need to protect:
0022 //   QPipeDevice read and bytesAvailable
0023 //   QPipeEnd finalize
0024 
0025 // Note: we never use the return value for QPipeWriter::stop, but I don't
0026 //   think this matters much
0027 
0028 #include "qpipe.h"
0029 
0030 #include <climits>
0031 #include <cstdlib>
0032 
0033 // sorry, i've added this dependency for now, but it's easy enough to take
0034 //   with you if you want qpipe independent of qca
0035 #include "qca_safeobj.h"
0036 
0037 #ifdef Q_OS_WIN
0038 #include <QMutex>
0039 #include <QTextCodec>
0040 #include <QTextDecoder>
0041 #include <QTextEncoder>
0042 #include <QThread>
0043 #include <QWaitCondition>
0044 #else
0045 #include <QMutex>
0046 #endif
0047 
0048 #ifdef Q_OS_UNIX
0049 #include <cerrno>
0050 #include <csignal>
0051 #include <fcntl.h>
0052 #include <sys/ioctl.h>
0053 #include <unistd.h>
0054 #ifdef HAVE_SYS_FILIO_H
0055 #include <sys/filio.h>
0056 #endif
0057 #endif
0058 
0059 #define USE_POLL
0060 
0061 #define CONSOLE_CHAREXPAND 5
0062 #define PIPEWRITER_POLL 1000
0063 #define PIPEREADER_POLL 100
0064 #define PIPEWRITER_BLOCK 8192
0065 #define PIPEEND_BLOCK 8192
0066 #define PIPEEND_READBUF 16384
0067 #define PIPEEND_READBUF_SEC 1024
0068 
0069 namespace QCA {
0070 
0071 #ifdef Q_OS_UNIX
0072 // adapted from qt
0073 Q_GLOBAL_STATIC(QMutex, ign_mutex)
0074 static bool ign_sigpipe = false;
0075 
0076 static void ignore_sigpipe()
0077 {
0078     // Set to ignore SIGPIPE once only.
0079     QMutexLocker locker(ign_mutex());
0080     if (!ign_sigpipe) {
0081         ign_sigpipe = true;
0082         struct sigaction noaction;
0083         memset(&noaction, 0, sizeof(noaction));
0084         noaction.sa_handler = SIG_IGN;
0085         sigaction(SIGPIPE, &noaction, nullptr);
0086     }
0087 }
0088 #endif
0089 
0090 #ifdef Q_OS_WIN
0091 static int pipe_dword_cap_to_int(DWORD dw)
0092 {
0093     if (sizeof(int) <= sizeof(DWORD))
0094         return (int)((dw > INT_MAX) ? INT_MAX : dw);
0095     else
0096         return (int)dw;
0097 }
0098 
0099 static bool pipe_dword_overflows_int(DWORD dw)
0100 {
0101     if (sizeof(int) <= sizeof(DWORD))
0102         return (dw > INT_MAX) ? true : false;
0103     else
0104         return false;
0105 }
0106 #endif
0107 
0108 #ifdef Q_OS_UNIX
0109 static int pipe_size_t_cap_to_int(size_t size)
0110 {
0111     if (sizeof(int) <= sizeof(size_t))
0112         return (int)((size > INT_MAX) ? INT_MAX : size);
0113     else // maybe silly..  can int ever be larger than size_t?
0114         return (int)size;
0115 }
0116 #endif
0117 
0118 static bool pipe_set_blocking(Q_PIPE_ID pipe, bool b)
0119 {
0120 #ifdef Q_OS_WIN
0121     DWORD flags = 0;
0122     if (!b)
0123         flags |= PIPE_NOWAIT;
0124     if (!SetNamedPipeHandleState(pipe, &flags, NULL, NULL))
0125         return false;
0126     return true;
0127 #endif
0128 #ifdef Q_OS_UNIX
0129     int flags = fcntl(pipe, F_GETFL);
0130     if (!b)
0131         flags |= O_NONBLOCK;
0132     else
0133         flags &= ~O_NONBLOCK;
0134     if (fcntl(pipe, F_SETFL, flags) == -1)
0135         return false;
0136     return true;
0137 #endif
0138 }
0139 
0140 // on windows, the pipe is closed and the new pipe is returned in newPipe
0141 static bool pipe_set_inheritable(Q_PIPE_ID pipe, bool b, Q_PIPE_ID *newPipe = nullptr)
0142 {
0143 #ifdef Q_OS_WIN
0144     // windows is required to accept a new pipe id
0145     if (!newPipe)
0146         return false;
0147     HANDLE h;
0148     if (!DuplicateHandle(GetCurrentProcess(), pipe, GetCurrentProcess(), &h, 0, b, DUPLICATE_SAME_ACCESS))
0149         return false;
0150     *newPipe = h;
0151     return true;
0152 #endif
0153 #ifdef Q_OS_UNIX
0154     if (newPipe)
0155         *newPipe = pipe;
0156     int flags = fcntl(pipe, F_GETFD);
0157     if (!b)
0158         flags |= FD_CLOEXEC;
0159     else
0160         flags &= ~FD_CLOEXEC;
0161     if (fcntl(pipe, F_SETFD, flags) == -1)
0162         return false;
0163     return true;
0164 #endif
0165 }
0166 
0167 // returns number of bytes available
0168 static int pipe_read_avail(Q_PIPE_ID pipe)
0169 {
0170     int bytesAvail = 0;
0171 #ifdef Q_OS_WIN
0172     DWORD i = 0;
0173     if (PeekNamedPipe(pipe, 0, 0, 0, &i, 0))
0174         bytesAvail = pipe_dword_cap_to_int(i);
0175 #endif
0176 #ifdef Q_OS_UNIX
0177     size_t nbytes = 0;
0178     if (ioctl(pipe, FIONREAD, (char *)&nbytes) >= 0)
0179         bytesAvail = pipe_size_t_cap_to_int(nbytes);
0180 #endif
0181     return bytesAvail;
0182 }
0183 
0184 // returns number of bytes actually read, no more than 'max'.
0185 // -1 on error.  0 means no data, NOT EOF.
0186 // note: even though this function looks like it can return data and EOF
0187 //       at the same time, it never actually does.
0188 static int pipe_read(Q_PIPE_ID pipe, char *data, int max, bool *eof)
0189 {
0190     int bytesRead = 0;
0191     if (eof)
0192         *eof = false;
0193     if (max < 1)
0194         return 0;
0195 #ifdef Q_OS_WIN
0196     DWORD maxread = max;
0197     DWORD r       = 0;
0198     if (!ReadFile(pipe, data, maxread, &r, 0)) {
0199         const DWORD err = GetLastError();
0200         if (err == ERROR_HANDLE_EOF) {
0201             if (eof)
0202                 *eof = true;
0203         } else if (err == ERROR_NO_DATA) {
0204             r = 0;
0205         } else
0206             return -1;
0207     }
0208     bytesRead = (int)r; // safe to cast, since 'max' is signed
0209 #endif
0210 #ifdef Q_OS_UNIX
0211     int r   = 0;
0212     int ret = read(pipe, data, max);
0213     if (ret == -1) {
0214         if (errno != EAGAIN)
0215             return -1;
0216     } else if (ret == 0) {
0217         if (eof)
0218             *eof = true;
0219     } else
0220         r = ret;
0221 
0222     bytesRead = r;
0223 #endif
0224     return bytesRead;
0225 }
0226 
0227 // returns number of bytes actually written.
0228 // for blocking pipes, this should always be 'size'.
0229 // -1 on error.
0230 static int pipe_write(Q_PIPE_ID pipe, const char *data, int size)
0231 {
0232 #ifdef Q_OS_WIN
0233     DWORD written;
0234     if (!WriteFile(pipe, data, size, &written, 0))
0235         return -1;
0236     return (int)written; // safe to cast, since 'size' is signed
0237 #endif
0238 #ifdef Q_OS_UNIX
0239     ignore_sigpipe();
0240     int r   = 0;
0241     int ret = write(pipe, data, size);
0242     if (ret == -1) {
0243         if (errno != EAGAIN)
0244             return -1;
0245     } else
0246         r = ret;
0247     return r;
0248 #endif
0249 }
0250 
0251 // Windows Console functions
0252 
0253 #ifdef Q_OS_WIN
0254 
0255 static bool pipe_is_a_console(Q_PIPE_ID pipe)
0256 {
0257     DWORD mode;
0258     if (GetConsoleMode(pipe, &mode))
0259         return true;
0260     return false;
0261 }
0262 
0263 // returns the number of keypress events in the console input queue,
0264 //   or -1 if there is an error (don't forget this!!)
0265 static int pipe_read_avail_console(Q_PIPE_ID pipe)
0266 {
0267     DWORD         count, i;
0268     INPUT_RECORD *rec;
0269     int           n, icount, total;
0270 
0271     // how many events are there?
0272     if (!GetNumberOfConsoleInputEvents(pipe, &count))
0273         return -1;
0274 
0275     // peek them all
0276     rec = (INPUT_RECORD *)malloc(count * sizeof(INPUT_RECORD));
0277     BOOL ret;
0278     ret = PeekConsoleInputW(pipe, rec, count, &i);
0279     if (!ret) {
0280         free(rec);
0281         return -1;
0282     }
0283 
0284     icount = pipe_dword_cap_to_int(i); // process only the amount returned
0285 
0286     // see which ones are normal keypress events
0287     total = 0;
0288     for (n = 0; n < icount; ++n) {
0289         if (rec[n].EventType == KEY_EVENT) {
0290             KEY_EVENT_RECORD *ke = &rec[n].Event.KeyEvent;
0291             if (ke->bKeyDown && ke->uChar.AsciiChar != 0)
0292                 total += ke->wRepeatCount;
0293         }
0294     }
0295 
0296     free(rec);
0297     return total;
0298 }
0299 
0300 // pass dec to keep a long-running decoder, else 0
0301 static int pipe_read_console(Q_PIPE_ID pipe, ushort *data, int max, bool *eof, QTextDecoder *dec = 0)
0302 {
0303     int  n, size, count;
0304     bool own_decoder;
0305 
0306     if (eof)
0307         *eof = false;
0308     if (max < 1)
0309         return 0;
0310 
0311     count = pipe_read_avail_console(pipe);
0312     if (count == -1)
0313         return -1;
0314     if (count == 0)
0315         return 0;
0316 
0317     if (dec) {
0318         own_decoder = false;
0319     } else {
0320         dec         = 0;
0321         own_decoder = true;
0322     }
0323 
0324     size = 0;
0325     for (n = 0; n < count && size < max; ++n) {
0326         bool    use_uni = true;
0327         quint16 uni     = 0;
0328         quint8  ansi    = 0;
0329 
0330         BOOL  ret;
0331         DWORD i;
0332         ret = ReadConsoleW(pipe, &uni, 1, &i, NULL);
0333         if (!ret) {
0334             // if the first read is an error, then report error
0335             if (n == 0) {
0336                 delete dec;
0337                 return -1;
0338             }
0339             // if we have some data, don't count this as an error.
0340             //   we'll probably get it again next time around...
0341             else
0342                 break;
0343         }
0344 
0345         QString substr;
0346         if (use_uni)
0347             substr = QChar(uni);
0348         else
0349             substr = dec->toUnicode((const char *)&ansi, 1);
0350 
0351         for (int k = 0; k < substr.length() && size < max; ++k) {
0352             QChar c = substr[k];
0353             if (c == QChar(0x1A)) // EOF?
0354             {
0355                 if (eof)
0356                     *eof = true;
0357                 break;
0358             }
0359             data[size++] = substr[k].unicode();
0360         }
0361     }
0362     if (own_decoder)
0363         delete dec;
0364 
0365     return size;
0366 }
0367 
0368 static int pipe_write_console(Q_PIPE_ID pipe, const ushort *data, int size)
0369 {
0370     DWORD i;
0371     BOOL  ret;
0372     ret = WriteConsoleW(pipe, data, size, &i, NULL);
0373     if (!ret)
0374         return -1;
0375     return (int)i; // safe to cast since 'size' is signed
0376 }
0377 #endif
0378 
0379 #ifdef Q_OS_WIN
0380 
0381 // Here is the multi-backend stuff for windows.  QPipeWriter and QPipeReader
0382 //   define a common interface, and then subclasses (like QPipeWriterThread)
0383 //   are used by QPipeDevice.  The base classes inherit from QThread, even
0384 //   if threads aren't used, so that I can define signals without dealing
0385 //   with multiple QObject inheritance in the thread subclasses (it is also
0386 //   possible that I'm missing something obvious and don't need to do this).
0387 
0388 // Note:
0389 //   QPipeWriterThread and QPipeReaderThread require the pipes to be in
0390 //     blocking mode.  QPipeWriterPoll and QPipeReaderPoll require the pipes
0391 //     to be in non-blocking mode.
0392 
0393 //----------------------------------------------------------------------------
0394 // QPipeWriter
0395 //----------------------------------------------------------------------------
0396 class QPipeWriter : public QThread
0397 {
0398     Q_OBJECT
0399 public:
0400     QPipeWriter(QObject *parent = nullptr)
0401         : QThread(parent)
0402     {
0403     }
0404 
0405     virtual ~QPipeWriter()
0406     {
0407     }
0408 
0409     // start
0410     virtual void start() = 0;
0411 
0412     // stop, and return number of bytes written so far
0413     virtual int stop() = 0;
0414 
0415     // data pointer needs to remain until canWrite is emitted
0416     virtual int write(const char *data, int size) = 0;
0417 
0418 Q_SIGNALS:
0419     // result values:
0420     //   =   0 : success
0421     //   =  -1 : error
0422     void canWrite(int result, int bytesWritten);
0423 
0424 protected:
0425     virtual void run()
0426     {
0427         // implement a default to satisfy the polling subclass
0428     }
0429 };
0430 
0431 //----------------------------------------------------------------------------
0432 // QPipeReader
0433 //----------------------------------------------------------------------------
0434 class QPipeReader : public QThread
0435 {
0436     Q_OBJECT
0437 public:
0438     QPipeReader(QObject *parent = nullptr)
0439         : QThread(parent)
0440     {
0441     }
0442 
0443     virtual ~QPipeReader()
0444     {
0445     }
0446 
0447     // start
0448     virtual void start() = 0;
0449 
0450     // to be called after every read
0451     virtual void resume() = 0;
0452 
0453 Q_SIGNALS:
0454     // result values:
0455     //  >=  0 : readAhead
0456     //   = -1 : atEnd
0457     //   = -2 : atError
0458     //   = -3 : data available, but no readAhead
0459     void canRead(int result);
0460 
0461 protected:
0462     virtual void run()
0463     {
0464         // implement a default to satisfy the polling subclass
0465     }
0466 };
0467 
0468 //----------------------------------------------------------------------------
0469 // QPipeWriterThread
0470 //----------------------------------------------------------------------------
0471 class QPipeWriterThread : public QPipeWriter
0472 {
0473     Q_OBJECT
0474 public:
0475     Q_PIPE_ID      pipe;
0476     QMutex         m;
0477     QWaitCondition w;
0478     bool           do_quit;
0479     const char    *data;
0480     int            size;
0481 
0482     QPipeWriterThread(Q_PIPE_ID id, QObject *parent = nullptr)
0483         : QPipeWriter(parent)
0484     {
0485         do_quit = false;
0486         data    = 0;
0487         connect(this, &QPipeWriterThread::canWrite_p, this, &QPipeWriterThread::canWrite);
0488         DuplicateHandle(GetCurrentProcess(), id, GetCurrentProcess(), &pipe, 0, false, DUPLICATE_SAME_ACCESS);
0489     }
0490 
0491     virtual ~QPipeWriterThread()
0492     {
0493         stop();
0494         CloseHandle(pipe);
0495     }
0496 
0497     virtual void start()
0498     {
0499         pipe_set_blocking(pipe, true);
0500         QThread::start();
0501     }
0502 
0503     virtual int stop()
0504     {
0505         if (isRunning()) {
0506             m.lock();
0507             do_quit = true;
0508             w.wakeOne();
0509             m.unlock();
0510             if (!wait(100))
0511                 terminate();
0512             do_quit = false;
0513             data    = 0;
0514         }
0515         return size;
0516     }
0517 
0518     virtual int write(const char *_data, int _size)
0519     {
0520         if (!isRunning())
0521             return -1;
0522 
0523         QMutexLocker locker(&m);
0524         if (data)
0525             return 0;
0526 
0527         data = _data;
0528         size = _size;
0529         w.wakeOne();
0530         return _size;
0531     }
0532 
0533 protected:
0534     virtual void run()
0535     {
0536         while (1) {
0537             m.lock();
0538 
0539             while (!data && !do_quit)
0540                 w.wait(&m);
0541 
0542             if (do_quit) {
0543                 m.unlock();
0544                 break;
0545             }
0546 
0547             const char *p   = data;
0548             int         len = size;
0549 
0550             m.unlock();
0551 
0552             int ret = internalWrite(p, len);
0553 
0554             m.lock();
0555             data = 0;
0556             size = ret;
0557             m.unlock();
0558 
0559             emit canWrite_p(ret < len ? -1 : 0, ret);
0560         }
0561     }
0562 
0563 private:
0564     // attempts to write len bytes.  value returned is number of bytes written.
0565     //   any return value less than len means a write error was encountered
0566     int internalWrite(const char *p, int len)
0567     {
0568         int total = 0;
0569         while (total < len) {
0570             m.lock();
0571             if (do_quit) {
0572                 m.unlock();
0573                 return 0;
0574             }
0575             m.unlock();
0576 
0577             int ret = pipe_write(pipe, p + total, qMin(PIPEWRITER_BLOCK, len - total));
0578             if (ret == -1) {
0579                 // from qt, don't know why
0580                 if (GetLastError() == 0xE8) // NT_STATUS_INVALID_USER_BUFFER
0581                 {
0582                     // give the os a rest
0583                     msleep(100);
0584                     continue;
0585                 }
0586 
0587                 // on any other error, end thread
0588                 return total;
0589             }
0590             total += ret;
0591         }
0592         return total;
0593     }
0594 
0595 Q_SIGNALS:
0596     void canWrite_p(int result, int bytesWritten);
0597 };
0598 
0599 //----------------------------------------------------------------------------
0600 // QPipeWriterPoll
0601 //----------------------------------------------------------------------------
0602 class QPipeWriterPoll : public QPipeWriter
0603 {
0604     Q_OBJECT
0605 public:
0606     Q_PIPE_ID   pipe;
0607     const char *data;
0608     int         size;
0609     SafeTimer   timer;
0610     int         total;
0611 
0612     QPipeWriterPoll(Q_PIPE_ID id, QObject *parent = nullptr)
0613         : QPipeWriter(parent)
0614         , timer(this)
0615     {
0616         pipe = id;
0617         data = 0;
0618         connect(&timer, &SafeTimer::timeout, this, &QPipeWriterPoll::tryNextWrite);
0619     }
0620 
0621     virtual ~QPipeWriterPoll()
0622     {
0623     }
0624 
0625     virtual void start()
0626     {
0627         pipe_set_blocking(pipe, false);
0628     }
0629 
0630     // return number of bytes written
0631     virtual int stop()
0632     {
0633         timer.stop();
0634         data = 0;
0635         return total;
0636     }
0637 
0638     // data pointer needs to remain until canWrite is emitted
0639     virtual int write(const char *_data, int _size)
0640     {
0641         total = 0;
0642         data  = _data;
0643         size  = _size;
0644         timer.start(0); // write at next event loop
0645         return _size;
0646     }
0647 
0648 private Q_SLOTS:
0649     void tryNextWrite()
0650     {
0651         int  written = pipe_write(pipe, data + total, size - total);
0652         bool error   = false;
0653         if (written == -1) {
0654             error   = true;
0655             written = 0; // no bytes written on error
0656 
0657             // from qt, they don't count it as fatal
0658             if (GetLastError() == 0xE8) // NT_STATUS_INVALID_USER_BUFFER
0659                 error = false;
0660         }
0661 
0662         total += written;
0663         if (error || total == size) {
0664             timer.stop();
0665             data = 0;
0666             emit canWrite(error ? -1 : 0, total);
0667             return;
0668         }
0669 
0670         timer.setInterval(PIPEWRITER_POLL);
0671     }
0672 };
0673 
0674 //----------------------------------------------------------------------------
0675 // QPipeReaderThread
0676 //----------------------------------------------------------------------------
0677 class QPipeReaderThread : public QPipeReader
0678 {
0679     Q_OBJECT
0680 public:
0681     Q_PIPE_ID      pipe;
0682     QMutex         m;
0683     QWaitCondition w;
0684     bool           do_quit, active;
0685 
0686     QPipeReaderThread(Q_PIPE_ID id, QObject *parent = nullptr)
0687         : QPipeReader(parent)
0688     {
0689         do_quit = false;
0690         active  = true;
0691         connect(this, &QPipeReaderThread::canRead_p, this, &QPipeReaderThread::canRead);
0692         DuplicateHandle(GetCurrentProcess(), id, GetCurrentProcess(), &pipe, 0, false, DUPLICATE_SAME_ACCESS);
0693     }
0694 
0695     virtual ~QPipeReaderThread()
0696     {
0697         if (isRunning()) {
0698             m.lock();
0699             do_quit = true;
0700             w.wakeOne();
0701             m.unlock();
0702             if (!wait(100))
0703                 terminate();
0704         }
0705         CloseHandle(pipe);
0706     }
0707 
0708     virtual void start()
0709     {
0710         pipe_set_blocking(pipe, true);
0711         QThread::start();
0712     }
0713 
0714     virtual void resume()
0715     {
0716         QMutexLocker locker(&m);
0717         pipe_set_blocking(pipe, true);
0718         active = true;
0719         w.wakeOne();
0720     }
0721 
0722 protected:
0723     virtual void run()
0724     {
0725         while (1) {
0726             m.lock();
0727 
0728             while (!active && !do_quit)
0729                 w.wait(&m);
0730 
0731             if (do_quit) {
0732                 m.unlock();
0733                 break;
0734             }
0735 
0736             m.unlock();
0737 
0738             while (1) {
0739                 unsigned char c;
0740                 bool          done;
0741                 int           ret = pipe_read(pipe, (char *)&c, 1, &done);
0742                 if (done || ret != 0) // eof, error, or data?
0743                 {
0744                     int result;
0745 
0746                     if (done) // we got EOF?
0747                         result = -1;
0748                     else if (ret == -1) // we got an error?
0749                         result = -2;
0750                     else if (ret >= 1) // we got some data??  queue it
0751                         result = c;
0752                     else // will never happen
0753                         result = -2;
0754 
0755                     m.lock();
0756                     active = false;
0757                     pipe_set_blocking(pipe, false);
0758                     m.unlock();
0759 
0760                     emit canRead_p(result);
0761                     break;
0762                 }
0763             }
0764         }
0765     }
0766 
0767 Q_SIGNALS:
0768     void canRead_p(int result);
0769 };
0770 
0771 //----------------------------------------------------------------------------
0772 // QPipeReaderPoll
0773 //----------------------------------------------------------------------------
0774 class QPipeReaderPoll : public QPipeReader
0775 {
0776     Q_OBJECT
0777 public:
0778     Q_PIPE_ID pipe;
0779     SafeTimer timer;
0780     bool      consoleMode;
0781 
0782     QPipeReaderPoll(Q_PIPE_ID id, QObject *parent = nullptr)
0783         : QPipeReader(parent)
0784         , timer(this)
0785     {
0786         pipe = id;
0787         connect(&timer, &SafeTimer::timeout, this, &QPipeReaderPoll::tryRead);
0788     }
0789 
0790     virtual ~QPipeReaderPoll()
0791     {
0792     }
0793 
0794     virtual void start()
0795     {
0796         pipe_set_blocking(pipe, false);
0797         consoleMode = pipe_is_a_console(pipe);
0798         resume();
0799     }
0800 
0801     virtual void resume()
0802     {
0803         timer.start(0);
0804     }
0805 
0806 private Q_SLOTS:
0807     void tryRead()
0808     {
0809         if (consoleMode)
0810             tryReadConsole();
0811         else
0812             tryReadPipe();
0813     }
0814 
0815 private:
0816     void tryReadPipe()
0817     {
0818         // is there data available for reading?  if so, signal.
0819         int bytes = pipe_read_avail(pipe);
0820         if (bytes > 0) {
0821             timer.stop();
0822             emit canRead(-3); // no readAhead
0823             return;
0824         }
0825 
0826         // no data available?  probe for EOF/error
0827         unsigned char c;
0828         bool          done;
0829         int           ret = pipe_read(pipe, (char *)&c, 1, &done);
0830         if (done || ret != 0) // eof, error, or data?
0831         {
0832             int result;
0833 
0834             if (done) // we got EOF?
0835                 result = -1;
0836             else if (ret == -1) // we got an error?
0837                 result = -2;
0838             else if (ret >= 1) // we got some data??  queue it
0839                 result = c;
0840             else // will never happen
0841                 result = -2;
0842 
0843             timer.stop();
0844             emit canRead(result);
0845             return;
0846         }
0847 
0848         timer.setInterval(PIPEREADER_POLL);
0849     }
0850 
0851     void tryReadConsole()
0852     {
0853         // is there data available for reading?  if so, signal.
0854         int count = pipe_read_avail_console(pipe);
0855         if (count > 0) {
0856             timer.stop();
0857             emit canRead(-3); // no readAhead
0858             return;
0859         }
0860 
0861         timer.setInterval(PIPEREADER_POLL);
0862     }
0863 };
0864 
0865 // end of windows pipe writer/reader implementations
0866 
0867 #endif
0868 
0869 //----------------------------------------------------------------------------
0870 // QPipeDevice
0871 //----------------------------------------------------------------------------
0872 class QPipeDevice::Private : public QObject
0873 {
0874     Q_OBJECT
0875 public:
0876     QPipeDevice      *q;
0877     Q_PIPE_ID         pipe;
0878     QPipeDevice::Type type;
0879     bool              enabled;
0880     bool              blockReadNotify;
0881     bool              canWrite;
0882     int               writeResult;
0883     int               lastTaken, lastWritten;
0884 
0885 #ifdef Q_OS_WIN
0886     bool          atEnd, atError, forceNotify;
0887     int           readAhead;
0888     SafeTimer    *readTimer;
0889     QTextDecoder *dec;
0890     bool          consoleMode;
0891     QPipeWriter  *pipeWriter;
0892     QPipeReader  *pipeReader;
0893 #endif
0894 #ifdef Q_OS_UNIX
0895     SafeSocketNotifier *sn_read, *sn_write;
0896 #endif
0897 
0898     Private(QPipeDevice *_q)
0899         : QObject(_q)
0900         , q(_q)
0901         , pipe(INVALID_Q_PIPE_ID)
0902     {
0903 #ifdef Q_OS_WIN
0904         readTimer  = 0;
0905         pipeWriter = 0;
0906         pipeReader = 0;
0907         dec        = 0;
0908 #endif
0909 #ifdef Q_OS_UNIX
0910         sn_read  = nullptr;
0911         sn_write = nullptr;
0912 #endif
0913     }
0914 
0915     ~Private() override
0916     {
0917         reset();
0918     }
0919 
0920     void reset()
0921     {
0922 #ifdef Q_OS_WIN
0923         atEnd       = false;
0924         atError     = false;
0925         forceNotify = false;
0926         readAhead   = -1;
0927         delete readTimer;
0928         readTimer = 0;
0929         delete pipeWriter;
0930         pipeWriter = 0;
0931         delete pipeReader;
0932         pipeReader = 0;
0933         delete dec;
0934         dec         = 0;
0935         consoleMode = false;
0936 #endif
0937 #ifdef Q_OS_UNIX
0938         delete sn_read;
0939         sn_read = nullptr;
0940         delete sn_write;
0941         sn_write = nullptr;
0942 #endif
0943         if (pipe != INVALID_Q_PIPE_ID) {
0944 #ifdef Q_OS_WIN
0945             CloseHandle(pipe);
0946 #endif
0947 #ifdef Q_OS_UNIX
0948             ::close(pipe);
0949 #endif
0950             pipe = INVALID_Q_PIPE_ID;
0951         }
0952 
0953         enabled         = false;
0954         blockReadNotify = false;
0955         canWrite        = true;
0956         writeResult     = -1;
0957     }
0958 
0959     void setup(Q_PIPE_ID id, QPipeDevice::Type _type)
0960     {
0961         pipe = id;
0962         type = _type;
0963     }
0964 
0965     void enable()
0966     {
0967         if (enabled)
0968             return;
0969 
0970         enabled = true;
0971 
0972         if (type == QPipeDevice::Read) {
0973 #ifdef Q_OS_WIN
0974             // for windows, the blocking mode is chosen by the QPipeReader
0975 
0976             // console might need a decoder
0977             if (consoleMode) {
0978                 dec = 0;
0979             }
0980 
0981             // pipe reader
0982 #ifdef USE_POLL
0983             pipeReader = new QPipeReaderPoll(pipe, this);
0984 #else
0985             // console always polls, no matter what
0986             if (consoleMode)
0987                 pipeReader = new QPipeReaderPoll(pipe, this);
0988             else
0989                 pipeReader = new QPipeReaderThread(pipe, this);
0990 #endif
0991             connect(pipeReader, &QPipeReader::canRead, this, &Private::pr_canRead);
0992             pipeReader->start();
0993 
0994             // polling timer
0995             readTimer = new SafeTimer(this);
0996             connect(readTimer, &SafeTimer::timeout, this, &Private::t_timeout);
0997 
0998             // updated: now that we have pipeReader, this no longer
0999             //   polls for data.  it only does delayed singleshot
1000             //   notifications.
1001             readTimer->setSingleShot(true);
1002 #endif
1003 #ifdef Q_OS_UNIX
1004             pipe_set_blocking(pipe, false);
1005 
1006             // socket notifier
1007             sn_read = new SafeSocketNotifier(pipe, QSocketNotifier::Read, this);
1008             connect(sn_read, &SafeSocketNotifier::activated, this, &Private::sn_read_activated);
1009 #endif
1010         } else {
1011             // for windows, the blocking mode is chosen by the QPipeWriter
1012 #ifdef Q_OS_UNIX
1013             pipe_set_blocking(pipe, false);
1014 
1015             // socket notifier
1016             sn_write = new SafeSocketNotifier(pipe, QSocketNotifier::Write, this);
1017             connect(sn_write, &SafeSocketNotifier::activated, this, &Private::sn_write_activated);
1018             sn_write->setEnabled(false);
1019 #endif
1020         }
1021     }
1022 
1023 public Q_SLOTS:
1024     void t_timeout()
1025     {
1026 #ifdef Q_OS_WIN
1027         if (blockReadNotify)
1028             return;
1029 
1030         // were we forced to notify?  this can happen if we want to
1031         //   spread out results across two reads.  whatever caused
1032         //   the forceNotify already knows what to do, so all we do
1033         //   is signal.
1034         if (forceNotify) {
1035             forceNotify     = false;
1036             blockReadNotify = true;
1037             emit q->notify();
1038             return;
1039         }
1040 #endif
1041     }
1042 
1043     void pw_canWrite(int result, int bytesWritten)
1044     {
1045 #ifdef Q_OS_WIN
1046         if (result == 0) {
1047             writeResult = 0;
1048             lastWritten = lastTaken; // success means all bytes
1049         } else {
1050             writeResult = -1;
1051             lastWritten = bytesWritten;
1052         }
1053 
1054         canWrite = true;
1055         emit q->notify();
1056 #else
1057         Q_UNUSED(result);
1058         Q_UNUSED(bytesWritten);
1059 #endif
1060     }
1061 
1062     void pr_canRead(int result)
1063     {
1064 #ifdef Q_OS_WIN
1065         blockReadNotify = true;
1066         if (result == -1)
1067             atEnd = true;
1068         else if (result == -2)
1069             atError = true;
1070         else if (result != -3)
1071             readAhead = result;
1072         emit q->notify();
1073 #else
1074         Q_UNUSED(result);
1075 #endif
1076     }
1077 
1078     void sn_read_activated()
1079     {
1080 #ifdef Q_OS_UNIX
1081         if (blockReadNotify)
1082             return;
1083 
1084         blockReadNotify = true;
1085         emit q->notify();
1086 #endif
1087     }
1088 
1089     void sn_write_activated()
1090     {
1091 #ifdef Q_OS_UNIX
1092         writeResult = 0;
1093         lastWritten = lastTaken;
1094 
1095         canWrite = true;
1096         sn_write->setEnabled(false);
1097         emit q->notify();
1098 #endif
1099     }
1100 };
1101 
1102 QPipeDevice::QPipeDevice(QObject *parent)
1103     : QObject(parent)
1104 {
1105     d = new Private(this);
1106 }
1107 
1108 QPipeDevice::~QPipeDevice()
1109 {
1110     delete d;
1111 }
1112 
1113 QPipeDevice::Type QPipeDevice::type() const
1114 {
1115     return d->type;
1116 }
1117 
1118 bool QPipeDevice::isValid() const
1119 {
1120     return (d->pipe != INVALID_Q_PIPE_ID);
1121 }
1122 
1123 Q_PIPE_ID QPipeDevice::id() const
1124 {
1125     return d->pipe;
1126 }
1127 
1128 int QPipeDevice::idAsInt() const
1129 {
1130 #ifdef Q_OS_WIN
1131     DWORD dw;
1132     memcpy(&dw, &d->pipe, sizeof(DWORD));
1133     return (int)dw; // FIXME? assumes handle value fits in signed int
1134 #endif
1135 #ifdef Q_OS_UNIX
1136     return d->pipe;
1137 #endif
1138 }
1139 
1140 void QPipeDevice::take(Q_PIPE_ID id, Type t)
1141 {
1142     close();
1143     d->setup(id, t);
1144 }
1145 
1146 void QPipeDevice::enable()
1147 {
1148 #ifdef Q_OS_WIN
1149     d->consoleMode = pipe_is_a_console(d->pipe);
1150 #endif
1151     d->enable();
1152 }
1153 
1154 void QPipeDevice::close()
1155 {
1156     d->reset();
1157 }
1158 
1159 void QPipeDevice::release()
1160 {
1161     d->pipe = INVALID_Q_PIPE_ID;
1162     d->reset();
1163 }
1164 
1165 bool QPipeDevice::setInheritable(bool enabled)
1166 {
1167 #ifdef Q_OS_WIN
1168     Q_PIPE_ID newPipe;
1169     if (!pipe_set_inheritable(d->pipe, enabled, &newPipe))
1170         return false;
1171     d->pipe = newPipe;
1172 #ifdef USE_POLL
1173     if (d->pipeReader)
1174         static_cast<QPipeReaderPoll *>(d->pipeReader)->pipe = d->pipe;
1175     if (d->pipeWriter)
1176         static_cast<QPipeWriterPoll *>(d->pipeWriter)->pipe = d->pipe;
1177 #endif
1178     return true;
1179 #endif
1180 #ifdef Q_OS_UNIX
1181     return pipe_set_inheritable(d->pipe, enabled, nullptr);
1182 #endif
1183 }
1184 
1185 int QPipeDevice::bytesAvailable() const
1186 {
1187     int n;
1188 #ifdef Q_OS_WIN
1189     if (d->consoleMode)
1190         n = pipe_read_avail_console(d->pipe);
1191     else
1192         n = pipe_read_avail(d->pipe);
1193     if (d->readAhead != -1)
1194         ++n;
1195 #else
1196     n = pipe_read_avail(d->pipe);
1197 #endif
1198     return n;
1199 }
1200 
1201 int QPipeDevice::read(char *data, int maxsize)
1202 {
1203     if (d->type != QPipeDevice::Read)
1204         return -1;
1205 
1206     // must read at least 1 byte
1207     if (maxsize < 1)
1208         return -1;
1209 
1210 #ifdef Q_OS_WIN
1211     // for windows console:
1212     // the number of bytes in utf8 can exceed the number of actual
1213     //   characters it represents.  to be safe, we'll assume that
1214     //   utf8 could outnumber characters X:1.  this does mean that
1215     //   the maxsize parameter needs to be at least X to do
1216     //   anything.  (X = CONSOLE_CHAREXPAND)
1217     if (d->consoleMode && maxsize < CONSOLE_CHAREXPAND)
1218         return -1;
1219 
1220     // for resuming the pipeReader
1221     bool wasBlocked = d->blockReadNotify;
1222 #endif
1223 
1224     d->blockReadNotify = false;
1225 
1226 #ifdef Q_OS_WIN
1227     // predetermined results
1228     if (d->atEnd) {
1229         close();
1230         return 0;
1231     }
1232     if (d->atError) {
1233         close();
1234         return -1;
1235     }
1236 
1237     int offset = 0;
1238     int size   = maxsize;
1239 
1240     // prepend readAhead if we have it
1241     if (d->readAhead != -1) {
1242         unsigned char c = (unsigned char)d->readAhead;
1243         d->readAhead    = -1;
1244         memcpy(&data[0], &c, 1);
1245         ++offset;
1246         --size;
1247 
1248         // readAhead was enough data for the caller?
1249         if (size == 0) {
1250             if (wasBlocked)
1251                 d->pipeReader->resume();
1252             return offset;
1253         }
1254     }
1255 
1256     // read from the pipe now
1257     bool done;
1258     int  ret;
1259     if (d->consoleMode) {
1260         // read a fraction of the number of characters as requested,
1261         //   to guarantee the result fits
1262         int num = size / CONSOLE_CHAREXPAND;
1263 
1264 #ifdef QPIPE_SECURE
1265         SecureArray destbuf(num * sizeof(ushort), 0);
1266 #else
1267         QByteArray destbuf(num * sizeof(ushort), 0);
1268 #endif
1269         ushort *dest = (ushort *)destbuf.data();
1270 
1271         ret = pipe_read_console(d->pipe, dest, num, &done, d->dec);
1272         if (ret != -1) {
1273             // for security, encode one character at a time without
1274             //   performing a QString conversion of the whole thing
1275             QTextCodec                *codec = QTextCodec::codecForMib(106);
1276             QTextCodec::ConverterState cstate(QTextCodec::IgnoreHeader);
1277             int                        at = 0;
1278             for (int n = 0; n < ret; ++n) {
1279                 QChar      c(dest[n]);
1280                 QByteArray out = codec->fromUnicode(&c, 1, &cstate);
1281                 memcpy(data + offset + at, out.data(), out.size());
1282                 at += out.size();
1283             }
1284             ret = at; // change ret to actual bytes
1285         }
1286     } else
1287         ret = pipe_read(d->pipe, data + offset, size, &done);
1288     if (done || ret == -1) // eof or error
1289     {
1290         // did we already have some data?  if so, defer the eof/error
1291         if (offset) {
1292             d->forceNotify = true;
1293             if (done)
1294                 d->atEnd = true;
1295             else
1296                 d->atError = true;
1297 
1298             // readTimer is a singleshot, so we have to start it
1299             //   for forceNotify to work
1300             d->readTimer->start();
1301         }
1302         // otherwise, bail
1303         else {
1304             close();
1305             if (done)
1306                 return 0;
1307             else
1308                 return -1;
1309         }
1310     } else
1311         offset += ret;
1312 
1313     // pipe still active?  resume the pipeReader
1314     if (wasBlocked && !d->atEnd && !d->atError)
1315         d->pipeReader->resume();
1316 
1317     // no data means error
1318     if (offset == 0)
1319         return -1;
1320 
1321     return offset;
1322 #endif
1323 #ifdef Q_OS_UNIX
1324     bool done;
1325     int  r = pipe_read(d->pipe, data, maxsize, &done);
1326     if (done) {
1327         close();
1328         return 0;
1329     }
1330     if (r == -1) {
1331         close();
1332         return -1;
1333     }
1334 
1335     // no data means error
1336     if (r == 0)
1337         return -1;
1338 
1339     return r;
1340 #endif
1341 }
1342 
1343 int QPipeDevice::write(const char *data, int size)
1344 {
1345     if (d->type != QPipeDevice::Write)
1346         return -1;
1347 
1348     // allowed to write?
1349     if (!d->canWrite)
1350         return -1;
1351 
1352     // if size is zero, don't bother
1353     if (size == 0)
1354         return 0;
1355 
1356     int r;
1357 #ifdef Q_OS_WIN
1358     if (!d->pipeWriter) {
1359 #ifdef USE_POLL
1360         d->pipeWriter = new QPipeWriterPoll(d->pipe, d);
1361 #else
1362         // console always polls, no matter what
1363         if (d->consoleMode)
1364             d->pipeWriter = new QPipeReaderPoll(d->pipe, d);
1365         else
1366             d->pipeWriter = new QPipeWriterThread(d->pipe, d);
1367 #endif
1368         connect(d->pipeWriter, &QPipeWriter::canWrite, d, &Private::pw_canWrite);
1369         d->pipeWriter->start();
1370     }
1371 
1372     if (d->consoleMode) {
1373         // Note: we convert to QString here, but it should not be a
1374         //   security issue (see pipe_write_console comment above)
1375 
1376         // for console, just write direct.  we won't use pipewriter
1377         QString out = QString::fromUtf8(QByteArray(data, size));
1378         r           = pipe_write_console(d->pipe, out.utf16(), out.length());
1379         if (r == -1)
1380             return -1;
1381 
1382         // convert characters to bytes
1383         r = out.mid(0, r).toUtf8().size();
1384 
1385         // simulate.  we invoke the signal of pipewriter rather than our
1386         //   own slot, so that the invoke can be cancelled.
1387         d->canWrite = false;
1388         QMetaObject::invokeMethod(d->pipeWriter, "canWrite", Qt::QueuedConnection, Q_ARG(int, 0), Q_ARG(int, r));
1389     } else {
1390         d->canWrite = false;
1391         r           = d->pipeWriter->write(data, size);
1392     }
1393 
1394     d->lastTaken = r;
1395     if (r == -1) {
1396         close();
1397         return -1;
1398     }
1399 #endif
1400 #ifdef Q_OS_UNIX
1401     r            = pipe_write(d->pipe, data, size);
1402     d->lastTaken = r;
1403     if (r == -1) {
1404         close();
1405         return -1;
1406     }
1407 
1408     d->canWrite = false;
1409     d->sn_write->setEnabled(true);
1410 #endif
1411     return r;
1412 }
1413 
1414 int QPipeDevice::writeResult(int *written) const
1415 {
1416     if (written)
1417         *written = d->lastWritten;
1418     return d->writeResult;
1419 }
1420 
1421 //----------------------------------------------------------------------------
1422 // QPipeEnd
1423 //----------------------------------------------------------------------------
1424 enum ResetMode
1425 {
1426     ResetSession        = 0,
1427     ResetSessionAndData = 1,
1428     ResetAll            = 2
1429 };
1430 
1431 class QPipeEnd::Private : public QObject
1432 {
1433     Q_OBJECT
1434 public:
1435     QPipeEnd         *q;
1436     QPipeDevice       pipe;
1437     QPipeDevice::Type type;
1438     QByteArray        buf;
1439     QByteArray        curWrite;
1440 
1441 #ifdef Q_OS_WIN
1442     bool consoleMode;
1443 #endif
1444 
1445 #ifdef QPIPE_SECURE
1446     bool        secure;
1447     SecureArray sec_buf;
1448     SecureArray sec_curWrite;
1449 #endif
1450     SafeTimer readTrigger, writeTrigger, closeTrigger, writeErrorTrigger;
1451     bool      canRead, activeWrite;
1452     int       lastWrite;
1453     bool      closeLater;
1454     bool      closing;
1455 
1456     Private(QPipeEnd *_q)
1457         : QObject(_q)
1458         , q(_q)
1459         , pipe(this)
1460         , readTrigger(this)
1461         , writeTrigger(this)
1462         , closeTrigger(this)
1463         , writeErrorTrigger(this)
1464     {
1465         readTrigger.setSingleShot(true);
1466         writeTrigger.setSingleShot(true);
1467         closeTrigger.setSingleShot(true);
1468         writeErrorTrigger.setSingleShot(true);
1469         connect(&pipe, &QPipeDevice::notify, this, &Private::pipe_notify);
1470         connect(&readTrigger, &SafeTimer::timeout, this, &Private::doRead);
1471         connect(&writeTrigger, &SafeTimer::timeout, this, &Private::doWrite);
1472         connect(&closeTrigger, &SafeTimer::timeout, this, &Private::doClose);
1473         connect(&writeErrorTrigger, &SafeTimer::timeout, this, &Private::doWriteError);
1474         reset(ResetSessionAndData);
1475     }
1476 
1477     void reset(ResetMode mode)
1478     {
1479         pipe.close();
1480         readTrigger.stop();
1481         writeTrigger.stop();
1482         closeTrigger.stop();
1483         writeErrorTrigger.stop();
1484         canRead     = false;
1485         activeWrite = false;
1486         lastWrite   = 0;
1487         closeLater  = false;
1488         closing     = false;
1489         curWrite.clear();
1490 #ifdef QPIPE_SECURE
1491         secure = false;
1492         sec_curWrite.clear();
1493 #endif
1494 
1495         if (mode >= ResetSessionAndData) {
1496             buf.clear();
1497 #ifdef QPIPE_SECURE
1498             sec_buf.clear();
1499 #endif
1500         }
1501     }
1502 
1503     void setup(Q_PIPE_ID id, QPipeDevice::Type _type)
1504     {
1505         type = _type;
1506 #ifdef Q_OS_WIN
1507         consoleMode = pipe_is_a_console(id);
1508 #endif
1509         pipe.take(id, type);
1510     }
1511 
1512     int pendingSize() const
1513     {
1514 #ifdef QPIPE_SECURE
1515         if (secure)
1516             return sec_buf.size();
1517         else
1518 #endif
1519             return buf.size();
1520     }
1521 
1522     int pendingFreeSize() const
1523     {
1524 #ifdef QPIPE_SECURE
1525         if (secure)
1526             return qMax(PIPEEND_READBUF_SEC - sec_buf.size(), 0);
1527         else
1528 #endif
1529             return qMax(PIPEEND_READBUF - buf.size(), 0);
1530     }
1531 
1532     void appendArray(QByteArray *a, const QByteArray &b)
1533     {
1534         (*a) += b;
1535     }
1536 
1537 #ifdef QPIPE_SECURE
1538     void appendArray(SecureArray *a, const SecureArray &b)
1539     {
1540         a->append(b);
1541     }
1542 #endif
1543 
1544     void takeArray(QByteArray *a, int len)
1545     {
1546         char     *p       = a->data();
1547         const int newsize = a->size() - len;
1548         memmove(p, p + len, newsize);
1549         a->resize(newsize);
1550     }
1551 
1552 #ifdef QPIPE_SECURE
1553     void takeArray(SecureArray *a, int len)
1554     {
1555         char     *p       = a->data();
1556         const int newsize = a->size() - len;
1557         memmove(p, p + len, newsize);
1558         a->resize(newsize);
1559     }
1560 #endif
1561 
1562     void setupNextRead()
1563     {
1564         if (pipe.isValid() && canRead) {
1565             canRead = false;
1566             readTrigger.start(0);
1567         }
1568     }
1569 
1570     void setupNextWrite()
1571     {
1572         if (!activeWrite) {
1573             activeWrite = true;
1574             writeTrigger.start(0);
1575         }
1576     }
1577 
1578     QByteArray read(QByteArray *buf, int bytes)
1579     {
1580         QByteArray a;
1581         if (bytes == -1 || bytes > buf->size()) {
1582             a = *buf;
1583         } else {
1584             a.resize(bytes);
1585             memcpy(a.data(), buf->data(), a.size());
1586         }
1587 
1588         takeArray(buf, a.size());
1589         setupNextRead();
1590         return a;
1591     }
1592 
1593     void write(QByteArray *buf, const QByteArray &a)
1594     {
1595         appendArray(buf, a);
1596         setupNextWrite();
1597     }
1598 
1599 #ifdef QPIPE_SECURE
1600     SecureArray readSecure(SecureArray *buf, int bytes)
1601     {
1602         SecureArray a;
1603         if (bytes == -1 || bytes > buf->size()) {
1604             a = *buf;
1605         } else {
1606             a.resize(bytes);
1607             memcpy(a.data(), buf->data(), a.size());
1608         }
1609 
1610         takeArray(buf, a.size());
1611         setupNextRead();
1612         return a;
1613     }
1614 
1615     void writeSecure(SecureArray *buf, const SecureArray &a)
1616     {
1617         appendArray(buf, a);
1618         setupNextWrite();
1619     }
1620 #endif
1621 
1622 public Q_SLOTS:
1623     void pipe_notify()
1624     {
1625         if (pipe.type() == QPipeDevice::Read) {
1626             doRead();
1627         } else {
1628             int x;
1629             int writeResult = pipe.writeResult(&x);
1630             if (writeResult == -1)
1631                 lastWrite = x; // if error, we may have written less bytes
1632 
1633             // remove what we just wrote
1634             bool moreData = false;
1635 #ifdef QPIPE_SECURE
1636             if (secure) {
1637                 takeArray(&sec_buf, lastWrite);
1638                 moreData = !sec_buf.isEmpty();
1639             } else
1640 #endif
1641             {
1642                 takeArray(&buf, lastWrite);
1643                 moreData = !buf.isEmpty();
1644             }
1645 
1646 #ifdef QPIPE_SECURE
1647             sec_curWrite.clear();
1648 #endif
1649             curWrite.clear();
1650 
1651             x         = lastWrite;
1652             lastWrite = 0;
1653 
1654             if (writeResult == 0) {
1655                 // more to write?  do it
1656                 if (moreData) {
1657                     writeTrigger.start(0);
1658                 }
1659                 // done with all writing
1660                 else {
1661                     activeWrite = false;
1662                     if (closeLater) {
1663                         closeLater = false;
1664                         closeTrigger.start(0);
1665                     }
1666                 }
1667             } else
1668                 writeErrorTrigger.start();
1669 
1670             if (x > 0)
1671                 emit q->bytesWritten(x);
1672         }
1673     }
1674 
1675     void doRead()
1676     {
1677         doReadActual(true);
1678     }
1679 
1680     void doReadActual(bool sigs)
1681     {
1682         const int left = pendingFreeSize();
1683         if (left == 0) {
1684             canRead = true;
1685             return;
1686         }
1687 
1688         int max;
1689 #ifdef Q_OS_WIN
1690         if (consoleMode) {
1691             // need a minimum amount for console
1692             if (left < CONSOLE_CHAREXPAND) {
1693                 canRead = true;
1694                 return;
1695             }
1696 
1697             // don't use pipe.bytesAvailable() for console mode,
1698             //   as it is somewhat bogus.  fortunately, there is
1699             //   no problem with overreading from the console.
1700             max = qMin(left, 32);
1701         } else
1702 #endif
1703         {
1704             max = qMin(left, pipe.bytesAvailable());
1705         }
1706 
1707         int ret;
1708 #ifdef QPIPE_SECURE
1709         if (secure) {
1710             SecureArray a(max);
1711             ret = pipe.read(a.data(), a.size());
1712             if (ret >= 1) {
1713                 a.resize(ret);
1714                 sec_buf.append(a);
1715             }
1716         } else
1717 #endif
1718         {
1719             QByteArray a(max, 0);
1720             ret = pipe.read(a.data(), a.size());
1721             if (ret >= 1) {
1722                 a.resize(ret);
1723                 buf += a;
1724             }
1725         }
1726 
1727         if (ret < 1) {
1728             reset(ResetSession);
1729             if (sigs) {
1730                 if (ret == 0)
1731                     emit q->error(QPipeEnd::ErrorEOF);
1732                 else
1733                     emit q->error(QPipeEnd::ErrorBroken);
1734             }
1735             return;
1736         }
1737 
1738         if (sigs)
1739             emit q->readyRead();
1740     }
1741 
1742     void doWrite()
1743     {
1744         int ret;
1745 #ifdef QPIPE_SECURE
1746         if (secure) {
1747             sec_curWrite.resize(qMin(PIPEEND_BLOCK, sec_buf.size()));
1748             memcpy(sec_curWrite.data(), sec_buf.data(), sec_curWrite.size());
1749 
1750             ret = pipe.write(sec_curWrite.data(), sec_curWrite.size());
1751         } else
1752 #endif
1753         {
1754             curWrite.resize(qMin(PIPEEND_BLOCK, buf.size()));
1755             memcpy(curWrite.data(), buf.data(), curWrite.size());
1756 
1757             ret = pipe.write(curWrite.data(), curWrite.size());
1758         }
1759 
1760         if (ret == -1) {
1761             reset(ResetSession);
1762             emit q->error(QPipeEnd::ErrorBroken);
1763             return;
1764         }
1765 
1766         lastWrite = ret;
1767     }
1768 
1769     void doClose()
1770     {
1771         reset(ResetSession);
1772         emit q->closed();
1773     }
1774 
1775     void doWriteError()
1776     {
1777         reset(ResetSession);
1778         emit q->error(QPipeEnd::ErrorBroken);
1779     }
1780 };
1781 
1782 QPipeEnd::QPipeEnd(QObject *parent)
1783     : QObject(parent)
1784 {
1785     d = new Private(this);
1786 }
1787 
1788 QPipeEnd::~QPipeEnd()
1789 {
1790     delete d;
1791 }
1792 
1793 void QPipeEnd::reset()
1794 {
1795     d->reset(ResetAll);
1796 }
1797 
1798 QPipeDevice::Type QPipeEnd::type() const
1799 {
1800     return d->pipe.type();
1801 }
1802 
1803 bool QPipeEnd::isValid() const
1804 {
1805     return d->pipe.isValid();
1806 }
1807 
1808 Q_PIPE_ID QPipeEnd::id() const
1809 {
1810     return d->pipe.id();
1811 }
1812 
1813 int QPipeEnd::idAsInt() const
1814 {
1815     return d->pipe.idAsInt();
1816 }
1817 
1818 void QPipeEnd::take(Q_PIPE_ID id, QPipeDevice::Type t)
1819 {
1820     reset();
1821     d->setup(id, t);
1822 }
1823 
1824 #ifdef QPIPE_SECURE
1825 void QPipeEnd::setSecurityEnabled(bool secure)
1826 {
1827     // no change
1828     if (d->secure == secure)
1829         return;
1830 
1831     if (secure) {
1832         d->sec_buf = d->buf;
1833         d->buf.clear();
1834     } else {
1835         d->buf = d->sec_buf.toByteArray();
1836         d->sec_buf.clear();
1837     }
1838 
1839     d->secure = secure;
1840 }
1841 #endif
1842 
1843 void QPipeEnd::enable()
1844 {
1845     d->pipe.enable();
1846 }
1847 
1848 void QPipeEnd::close()
1849 {
1850     if (!isValid() || d->closing)
1851         return;
1852 
1853     d->closing = true;
1854 
1855     if (d->activeWrite)
1856         d->closeLater = true;
1857     else
1858         d->closeTrigger.start(0);
1859 }
1860 
1861 void QPipeEnd::release()
1862 {
1863     if (!isValid())
1864         return;
1865 
1866     d->pipe.release();
1867     d->reset(ResetSession);
1868 }
1869 
1870 bool QPipeEnd::setInheritable(bool enabled)
1871 {
1872     return d->pipe.setInheritable(enabled);
1873 }
1874 
1875 void QPipeEnd::finalize()
1876 {
1877     if (!isValid())
1878         return;
1879 
1880     if (d->pipe.bytesAvailable())
1881         d->doReadActual(false);
1882     d->reset(ResetSession);
1883 }
1884 
1885 void QPipeEnd::finalizeAndRelease()
1886 {
1887     if (!isValid())
1888         return;
1889 
1890     if (d->pipe.bytesAvailable())
1891         d->doReadActual(false);
1892     d->pipe.release();
1893     d->reset(ResetSession);
1894 }
1895 
1896 int QPipeEnd::bytesAvailable() const
1897 {
1898     return d->pendingSize();
1899 }
1900 
1901 int QPipeEnd::bytesToWrite() const
1902 {
1903     return d->pendingSize();
1904 }
1905 
1906 QByteArray QPipeEnd::read(int bytes)
1907 {
1908     return d->read(&d->buf, bytes);
1909 }
1910 
1911 void QPipeEnd::write(const QByteArray &buf)
1912 {
1913     if (!isValid() || d->closing)
1914         return;
1915 
1916     if (buf.isEmpty())
1917         return;
1918 
1919 #ifdef QPIPE_SECURE
1920     if (d->secure) // call writeSecure() instead
1921         return;
1922 #endif
1923 
1924     d->write(&d->buf, buf);
1925 }
1926 
1927 #ifdef QPIPE_SECURE
1928 SecureArray QPipeEnd::readSecure(int bytes)
1929 {
1930     return d->readSecure(&d->sec_buf, bytes);
1931 }
1932 
1933 void QPipeEnd::writeSecure(const SecureArray &buf)
1934 {
1935     if (!isValid() || d->closing)
1936         return;
1937 
1938     if (buf.isEmpty())
1939         return;
1940 
1941     if (!d->secure) // call write() instead
1942         return;
1943 
1944     d->writeSecure(&d->sec_buf, buf);
1945 }
1946 #endif
1947 
1948 QByteArray QPipeEnd::takeBytesToWrite()
1949 {
1950     // only call this on inactive sessions
1951     if (isValid())
1952         return QByteArray();
1953 
1954     QByteArray a = d->buf;
1955     d->buf.clear();
1956     return a;
1957 }
1958 
1959 #ifdef QPIPE_SECURE
1960 SecureArray QPipeEnd::takeBytesToWriteSecure()
1961 {
1962     // only call this on inactive sessions
1963     if (isValid())
1964         return SecureArray();
1965 
1966     SecureArray a = d->sec_buf;
1967     d->sec_buf.clear();
1968     return a;
1969 }
1970 #endif
1971 
1972 //----------------------------------------------------------------------------
1973 // QPipe
1974 //----------------------------------------------------------------------------
1975 QPipe::QPipe(QObject *parent)
1976     : i(parent)
1977     , o(parent)
1978 {
1979 }
1980 
1981 QPipe::~QPipe()
1982 {
1983 }
1984 
1985 void QPipe::reset()
1986 {
1987     i.reset();
1988     o.reset();
1989 }
1990 
1991 #ifdef QPIPE_SECURE
1992 bool QPipe::create(bool secure)
1993 #else
1994 bool QPipe::create()
1995 #endif
1996 {
1997     reset();
1998 
1999 #ifdef Q_OS_WIN
2000     SECURITY_ATTRIBUTES secAttr;
2001     memset(&secAttr, 0, sizeof secAttr);
2002     secAttr.nLength        = sizeof secAttr;
2003     secAttr.bInheritHandle = false;
2004 
2005     HANDLE r, w;
2006     if (!CreatePipe(&r, &w, &secAttr, 0))
2007         return false;
2008     i.take(r, QPipeDevice::Read);
2009     o.take(w, QPipeDevice::Write);
2010 #endif
2011 
2012 #ifdef Q_OS_UNIX
2013     int p[2];
2014     if (pipe(p) == -1)
2015         return false;
2016     if (!pipe_set_inheritable(p[0], false, nullptr) || !pipe_set_inheritable(p[1], false, nullptr)) {
2017         close(p[0]);
2018         close(p[1]);
2019         return false;
2020     }
2021     i.take(p[0], QPipeDevice::Read);
2022     o.take(p[1], QPipeDevice::Write);
2023 #endif
2024 
2025 #ifdef QPIPE_SECURE
2026     i.setSecurityEnabled(secure);
2027     o.setSecurityEnabled(secure);
2028 #endif
2029 
2030     return true;
2031 }
2032 
2033 }
2034 
2035 #include "qpipe.moc"