Ticket #5780: libs_libmythdb-cosmetic-cleaning.patch

File libs_libmythdb-cosmetic-cleaning.patch, 128.3 KB (added by Erik Hovland <erik@…>, 13 years ago)

Removes extra whitespace and replaces tabs with spaces

  • mythtv/libs/libmythdb/compat.h

    Remove any whitespace at then end of line.
    
    From: Erik Hovland <erik@hovland.org>
    
    
    ---
    
     mythtv/libs/libmythdb/compat.h               |   18 
     mythtv/libs/libmythdb/httpcomms.cpp          |  170 ++--
     mythtv/libs/libmythdb/httpcomms.h            |   46 +
     mythtv/libs/libmythdb/lcddevice.cpp          |   50 +
     mythtv/libs/libmythdb/lcddevice.h            |   48 +
     mythtv/libs/libmythdb/msocketdevice.cpp      |   22 -
     mythtv/libs/libmythdb/msocketdevice.h        |   24 -
     mythtv/libs/libmythdb/msocketdevice_unix.cpp |  818 ++++++++++----------
     mythtv/libs/libmythdb/msocketdevice_win.cpp  | 1066 +++++++++++++-------------
     mythtv/libs/libmythdb/mythdbcon.cpp          |   18 
     mythtv/libs/libmythdb/mythdbcon.h            |   16 
     mythtv/libs/libmythdb/mythevent.h            |   10 
     mythtv/libs/libmythdb/mythobservable.h       |   24 -
     mythtv/libs/libmythdb/mythsocket.cpp         |   52 +
     mythtv/libs/libmythdb/mythsocket.h           |    2 
     mythtv/libs/libmythdb/mythstorage.cpp        |    2 
     mythtv/libs/libmythdb/mythverbose.h          |    6 
     mythtv/libs/libmythdb/oldsettings.cpp        |    6 
     mythtv/libs/libmythdb/oldsettings.h          |    4 
     19 files changed, 1201 insertions(+), 1201 deletions(-)
    
    diff --git a/mythtv/libs/libmythdb/compat.h b/mythtv/libs/libmythdb/compat.h
    index 732b033..6377799 100644
    a b typedef unsigned int uint; 
    3939#undef CreateFont
    4040#endif
    4141
    42 // Dealing with Microsoft min/max mess: 
     42// Dealing with Microsoft min/max mess:
    4343// assume that under Windows the code is compiled with NOMINMAX defined
    4444// which disables #define's for min/max.
    45 // however, Microsoft  violates the C++ standard even with 
    46 // NOMINMAX on, and defines templates _cpp_min and _cpp_max 
     45// however, Microsoft  violates the C++ standard even with
     46// NOMINMAX on, and defines templates _cpp_min and _cpp_max
    4747// instead of templates min/max
    4848// define the correct templates here
    4949
    template<class _Ty> inline 
    5252        const _Ty& max(const _Ty& _X, const _Ty& _Y)
    5353        {return (_X < _Y ? _Y : _X); }
    5454template<class _Ty, class _Pr> inline
    55         const _Ty& max(const _Ty& _X, const _Ty& _Y, _Pr _P)
    56         {return (_P(_X, _Y) ? _Y : _X); }
     55        const _Ty& max(const _Ty& _X, const _Ty& _Y, _Pr _P)
     56        {return (_P(_X, _Y) ? _Y : _X); }
    5757
    5858template<class _Ty> inline
    5959        const _Ty& min(const _Ty& _X, const _Ty& _Y)
    6060        {return (_Y < _X ? _Y : _X); }
    6161template<class _Ty, class _Pr> inline
    62         const _Ty& min(const _Ty& _X, const _Ty& _Y, _Pr _P)
    63         {return (_P(_Y, _X) ? _Y : _X); }
     62        const _Ty& min(const _Ty& _X, const _Ty& _Y, _Pr _P)
     63        {return (_P(_Y, _X) ? _Y : _X); }
    6464#endif // defined(__cplusplus) && defined(_WIN32)
    6565
    6666#ifdef _WIN32
    inline const char *dlerror(void) 
    229229    (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;                          \
    230230    if ((result)->tv_usec >= 1000000)                                         \
    231231      {                                                                       \
    232         ++(result)->tv_sec;                                                   \
    233         (result)->tv_usec -= 1000000;                                         \
     232        ++(result)->tv_sec;                                                   \
     233        (result)->tv_usec -= 1000000;                                         \
    234234      }                                                                       \
    235235  } while (0)
    236236#define timersub(a, b, result)                                                \
  • mythtv/libs/libmythdb/httpcomms.cpp

    diff --git a/mythtv/libs/libmythdb/httpcomms.cpp b/mythtv/libs/libmythdb/httpcomms.cpp
    index b17c487..24a846d 100644
    a b void HttpComms::init() 
    5555    m_responseReason = "";
    5656    m_timer = 0;
    5757    m_timeout = false;
    58    
     58
    5959
    6060    connect(http, SIGNAL(done(bool)), this, SLOT(done(bool)));
    6161    connect(http, SIGNAL(stateChanged(int)), this, SLOT(stateChanged(int)));
    void HttpComms::request(QUrl &url, int timeoutms, bool allowGzip) 
    7878
    7979    header.setValue("Host", url.host());
    8080    header.setValue("User-Agent", userAgent);
    81    
     81
    8282    if (allowGzip)
    8383        header.setValue( "Accept-Encoding", "gzip");
    84    
     84
    8585    request(url, header, timeoutms);
    8686}
    8787
    8888
    8989
    90 void HttpComms::request(QUrl               &url, 
    91                         QHttpRequestHeader &header, 
    92                         int                 timeoutms, 
     90void HttpComms::request(QUrl               &url,
     91                        QHttpRequestHeader &header,
     92                        int                 timeoutms,
    9393                        QIODevice          *pData /* = 0*/ )
    9494{
    9595    quint16 port = 80;
    9696
    97     if (url.port() != -1) 
     97    if (url.port() != -1)
    9898        port = url.port();
    99    
     99
    100100    http->setHost(url.host(), port);
    101101
    102102    m_url = url.toString();
    void HttpComms::request(QUrl &url, 
    104104
    105105    if (m_timer)
    106106        m_timer->stop();
    107    
     107
    108108    if (timeoutms > 0 )
    109109    {
    110110        if (!m_timer)
    void HttpComms::request(QUrl &url, 
    115115        m_timeoutInterval = timeoutms;
    116116        m_timer->setSingleShot(true);
    117117        m_timer->start(timeoutms);
    118     }       
     118    }
    119119
    120120    if (!m_cookie.isEmpty())
    121121    {
    122122        header.setValue("Cookie", m_cookie);
    123123    }
    124    
     124
    125125    http->request(header, pData);
    126126}
    127127
    void HttpComms::done(bool error) 
    147147    else if (m_authNeeded)
    148148    {
    149149        VERBOSE(VB_NETWORK, QString("Authentication pending, ignoring done from first request."));
    150         return;           
     150        return;
    151151    }
    152152    else if (http->bytesAvailable())
    153153    {
    154154        m_data.resize(http->bytesAvailable());
    155155        m_data = http->readAll();
    156156    }
    157    
     157
    158158    VERBOSE(VB_NETWORK, QString("done: %1 bytes").arg(m_data.size()));
    159159
    160160    if (m_timer)
    void HttpComms::done(bool error) 
    166166void HttpComms::stateChanged(int state)
    167167{
    168168    QString stateStr;
    169    
    170     switch (state) 
     169
     170    switch (state)
    171171    {
    172172        case QHttp::Unconnected: stateStr = "unconnected"; break;
    173173        case QHttp::HostLookup: stateStr =  "host lookup"; break;
    void HttpComms::headerReceived(const QHttpResponseHeader &resp) 
    202202            VERBOSE(VB_NETWORK, QString("HttpComms found cookie: %1").arg(m_cookie));
    203203        }
    204204    }
    205    
    206    
     205
     206
    207207    VERBOSE(VB_NETWORK, QString("Got HTTP response: %1:%2")
    208208                        .arg(m_statusCode)
    209                         .arg(m_responseReason));   
     209                        .arg(m_responseReason));
    210210    VERBOSE(VB_NETWORK, QString("Keys: %1")
    211211                        .arg(resp.keys().join(",") ));
    212    
    213212
    214     if (resp.statusCode() >= 300 && resp.statusCode() <= 400)
     213
     214    if (resp.statusCode() >= 300 && resp.statusCode() <= 400)
    215215    {
    216216        // redirection
    217217        QString uri = resp.value("LOCATION");
    218218        VERBOSE(VB_NETWORK, QString("Redirection to: '%1'").arg(uri));
    219        
     219
    220220        m_redirectedURL = resp.value("LOCATION");
    221221        m_authNeeded = false;
    222222    }
    void HttpComms::headerReceived(const QHttpResponseHeader &resp) 
    229229        if (m_authNeeded)
    230230        {
    231231            QString authHeader(resp.value("www-authenticate"));
    232            
     232
    233233            if (authHeader.startsWith("Digest") )
    234             {           
     234            {
    235235                if (!createDigestAuth(false, authHeader, &m_curRequest) )
    236236                {
    237237                    m_authNeeded = false;
    238                     return;   
     238                    return;
    239239                }
    240240            }
    241241            else
    void HttpComms::headerReceived(const QHttpResponseHeader &resp) 
    243243                QString sUser(m_webCredentials.user + ':' + m_webCredentials.pass);
    244244                QByteArray auth = QCodecs::base64Encode(sUser.toLocal8Bit());
    245245                m_curRequest.setValue( "Authorization", QString( "Basic " ).append( auth ) );
    246             } 
    247            
     246            }
     247
    248248            if (m_timer)
    249249            {
    250250                m_timer->stop();
    251251                m_timer->setSingleShot(true);
    252252                m_timer->start(m_timeoutInterval);
    253253            }
    254            
     254
    255255            // Not sure if it's possible to receive a session ID or other cookie
    256256            // before authenticating or not.
    257257            if (!m_cookie.isEmpty())
    258258            {
    259259                m_curRequest.setValue("Cookie", m_cookie);
    260260            }
    261            
     261
    262262            http->request(m_curRequest);
    263263        }
    264264    }
    void HttpComms::headerReceived(const QHttpResponseHeader &resp) 
    268268    }
    269269}
    270270
    271 void HttpComms::timeout() 
     271void HttpComms::timeout()
    272272{
    273273   VERBOSE(VB_IMPORTANT, QString("HttpComms::Timeout for url: %1")
    274274                               .arg(m_url.toString()));
    void HttpComms::dataReadProgress(int done, int total) 
    289289 *   This is a synchronous function, it will block according to the vars.
    290290 */
    291291QString HttpComms::getHttp(QString     &url,
    292                            int          timeoutMS,    int  maxRetries, 
     292                           int          timeoutMS,    int  maxRetries,
    293293                           int          maxRedirects, bool allowGzip,
    294294                           Credentials *webCred,      bool isInQtEventThread)
    295295{
    296296    int redirectCount = 0;
    297297    int timeoutCount = 0;
    298298    QString res = "";
    299     HttpComms *httpGrabber = 0; 
     299    HttpComms *httpGrabber = 0;
    300300    QString hostname = "";
    301301
    302     while (1) 
     302    while (1)
    303303    {
    304304        QUrl qurl(url);
    305305        if (hostname.isEmpty())
    306306            hostname = qurl.host();  // hold onto original host
    307307        if (qurl.host().isEmpty())   // can occur on redirects to partial paths
    308308            qurl.setHost(hostname);
    309        
     309
    310310        VERBOSE(VB_NETWORK, QString("getHttp: grabbing: %1").arg(qurl.toString()));
    311311
    312312        if (httpGrabber)
    313             delete httpGrabber; 
    314        
     313            delete httpGrabber;
     314
    315315        httpGrabber = new HttpComms;
    316        
     316
    317317        if (webCred)
    318318            httpGrabber->setCredentials(*webCred, CRED_WEB);
    319            
    320         httpGrabber->request(qurl, timeoutMS, allowGzip);           
    321        
     319
     320        httpGrabber->request(qurl, timeoutMS, allowGzip);
     321
    322322
    323323        while (!httpGrabber->isDone())
    324324        {
    QString HttpComms::getHttp(QString &url, 
    331331        if (httpGrabber->isTimedout())
    332332        {
    333333            VERBOSE(VB_NETWORK, QString("timeout for url: %1").arg(url));
    334            
     334
    335335            // Increment the counter and check were not over the limit
    336336            if (timeoutCount++ >= maxRetries)
    337337            {
    QString HttpComms::getHttp(QString &url, 
    349349        }
    350350
    351351        // Check for redirection
    352         if (!httpGrabber->getRedirectedURL().isEmpty()) 
     352        if (!httpGrabber->getRedirectedURL().isEmpty())
    353353        {
    354354            VERBOSE(VB_NETWORK, QString("Redirection: %1, count: %2, max: %3")
    355355                                .arg(httpGrabber->getRedirectedURL())
    QString HttpComms::getHttp(QString &url, 
    369369
    370370    delete httpGrabber;
    371371
    372    
     372
    373373    VERBOSE(VB_NETWORK, QString("Got %1 bytes from url: '%2'")
    374374                                .arg(res.length())
    375375                                .arg(url));
    QString HttpComms::getHttp(QString &url, 
    380380
    381381// getHttpFile - static function for grabbing a file from an http url
    382382//      this is a synchronous function, it will block according to the vars
    383 bool HttpComms::getHttpFile(const QString& filename, QString& url, int timeoutMS, 
    384                             int maxRetries, int maxRedirects, 
     383bool HttpComms::getHttpFile(const QString& filename, QString& url, int timeoutMS,
     384                            int maxRetries, int maxRedirects,
    385385                            bool allowGzip, Credentials* webCred)
    386386{
    387387    int redirectCount = 0;
    bool HttpComms::getHttpFile(const QString& filename, QString& url, int timeoutMS 
    396396        QUrl qurl(url);
    397397        if (hostname.isEmpty())
    398398            hostname = qurl.host();  // hold onto original host
    399        
     399
    400400        if (qurl.host().isEmpty())   // can occur on redirects to partial paths
    401401            qurl.setHost(hostname);
    402        
     402
    403403        VERBOSE(VB_NETWORK, QString("getHttp: grabbing: '%1'")
    404404                                    .arg(qurl.toString()));
    405405
    406406        if (httpGrabber)
    407407            delete httpGrabber;
    408        
     408
    409409        httpGrabber = new HttpComms;
    410        
     410
    411411        if (webCred)
    412412            httpGrabber->setCredentials(*webCred, CRED_WEB);
    413            
    414         httpGrabber->request(qurl, timeoutMS, allowGzip);           
     413
     414        httpGrabber->request(qurl, timeoutMS, allowGzip);
    415415
    416416        while (!httpGrabber->isDone())
    417417        {
    bool HttpComms::getHttpFile(const QString& filename, QString& url, int timeoutMS 
    458458                                        .arg(httpGrabber->getRedirectedURL())
    459459                                        .arg(redirectCount)
    460460                                        .arg(maxRedirects));
    461            
     461
    462462            if (redirectCount++ < maxRedirects)
    463463                url = httpGrabber->getRedirectedURL();
    464464
    bool HttpComms::getHttpFile(const QString& filename, QString& url, int timeoutMS 
    506506 *
    507507 *   This is a synchronous function, it will block according to the vars.
    508508 */
    509 QString HttpComms::postHttp(QUrl               &url         , 
     509QString HttpComms::postHttp(QUrl               &url         ,
    510510                            QHttpRequestHeader *pAddlHdr    , QIODevice *pData,
    511                             int                 timeoutMS   , int        maxRetries, 
     511                            int                 timeoutMS   , int        maxRetries,
    512512                            int                 maxRedirects, bool       allowGzip,
    513513                            Credentials        *webCred     , bool       isInQtEventThread)
    514514{
    515515    int redirectCount = 0;
    516516    int timeoutCount = 0;
    517517    QString res = "";
    518     HttpComms *httpGrabber = 0; 
     518    HttpComms *httpGrabber = 0;
    519519    QString hostname = "";
    520520
    521521    QHttpRequestHeader header( "POST", url.path() + url.encodedQuery());
    QString HttpComms::postHttp(QUrl &url , 
    527527
    528528    header.setValue("Host", url.host());
    529529    header.setValue("User-Agent", userAgent);
    530    
     530
    531531    if (allowGzip)
    532532        header.setValue( "Accept-Encoding", "gzip");
    533533
    QString HttpComms::postHttp(QUrl &url , 
    545545        }
    546546    }
    547547
    548     while (1) 
     548    while (1)
    549549    {
    550550        if (hostname.isEmpty())
    551551            hostname = url.host();  // hold onto original host
    552552        if (url.host().isEmpty())   // can occur on redirects to partial paths
    553553            url.setHost(hostname);
    554        
     554
    555555        VERBOSE(VB_NETWORK, QString("postHttp: grabbing: %1").arg(url.toString()));
    556556
    557557        if (httpGrabber)
    558             delete httpGrabber; 
    559        
     558            delete httpGrabber;
     559
    560560        httpGrabber = new HttpComms;
    561        
     561
    562562        if (webCred)
    563563            httpGrabber->setCredentials(*webCred, CRED_WEB);
    564            
    565         httpGrabber->request(url, header, timeoutMS, pData );           
     564
     565        httpGrabber->request(url, header, timeoutMS, pData );
    566566
    567567        while (!httpGrabber->isDone())
    568568        {
    QString HttpComms::postHttp(QUrl &url , 
    575575        if (httpGrabber->isTimedout())
    576576        {
    577577            VERBOSE(VB_NETWORK, QString("timeout for url: %1").arg(url.toString()));
    578            
     578
    579579            // Increment the counter and check were not over the limit
    580580            if (timeoutCount++ >= maxRetries)
    581581            {
    QString HttpComms::postHttp(QUrl &url , 
    593593        }
    594594
    595595        // Check for redirection
    596         if (!httpGrabber->getRedirectedURL().isEmpty()) 
     596        if (!httpGrabber->getRedirectedURL().isEmpty())
    597597        {
    598598            VERBOSE(VB_NETWORK, QString("Redirection: %1, count: %2, max: %3")
    599599                                .arg(httpGrabber->getRedirectedURL())
    QString HttpComms::postHttp(QUrl &url , 
    613613
    614614    delete httpGrabber;
    615615
    616    
     616
    617617    VERBOSE(VB_NETWORK, QString("Got %1 bytes from url: '%2'")
    618618                                .arg(res.length())
    619619                                .arg(url.toString()));
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    634634    DigestAuthInfo info;
    635635
    636636    opaque = "";
    637      
     637
    638638    if ( isForProxy )
    639639    {
    640640        header = "Proxy-Authorization";
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    651651        info.password = qPrintable(m_webCredentials.pass);
    652652        p = qPrintable(authStr);
    653653    }
    654  
     654
    655655    if (!p || !*p)
    656656        return false;
    657657
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    660660    if ( info.username.isEmpty() || info.password.isEmpty() || !p )
    661661        return false;
    662662
    663  
     663
    664664    info.realm = "";
    665665    info.algorithm = "MD5";
    666666    info.nonce = "";
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    669669    // cnonce is recommended to contain about 64 bits of entropy
    670670    // TODO: Fix this
    671671    info.cnonce =  "QPDExMTQ";
    672  
     672
    673673    // HACK: Should be fixed according to RFC 2617 section 3.2.2
    674674    info.nc = "00000001";
    675675
    676676    // Set the method used...
    677677    info.method.clear();
    678678    info.method += request->method();
    679  
     679
    680680    // Parse the Digest response....
    681681    while (*p)
    682682    {
    683683        int i = 0;
    684684        while ( (*p == ' ') || (*p == ',') || (*p == '\t')) {p++;}
    685    
     685
    686686        if (strncasecmp(p, "realm=", 6 )==0)
    687687        {
    688688            p+=6;
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    715715            do
    716716            {
    717717                pos = uri.indexOf( ' ', idx );
    718      
     718
    719719                if ( pos != -1 )
    720720                {
    721721                    QString sUrl = m_url.toString() + "//" + uri.mid(idx, pos-idx);
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    759759
    760760    if (info.realm.isEmpty() || info.nonce.isEmpty())
    761761        return false;
    762  
     762
    763763    info.digestURI.append (m_url.path() + m_url.encodedQuery());
    764  
    765    
     764
     765
    766766//     cerr << " RESULT OF PARSING:" << endl;
    767767//     cerr << "   algorithm: " << info.algorithm << endl;
    768768//     cerr << "   realm:     " << info.realm << endl;
    769769//     cerr << "   nonce:     " << info.nonce << endl;
    770770//     cerr << "   opaque:    " << opaque << endl;
    771771//     cerr << "   qop:       " << info.qop << endl;
    772    
    773    
     772
     773
    774774    // Calculate the response...
    775775    calculateDigestResponse( info, Response );
    776776
    bool HttpComms::createDigestAuth ( bool isForProxy, const QString& authStr, QHtt 
    808808        auth += "\", opaque=\"";
    809809        auth += opaque;
    810810    }
    811  
     811
    812812    auth += "\"";
    813    
    814    
     813
     814
    815815    VERBOSE(VB_NETWORK, QString("Setting auth header %1 to '%2'")
    816816                                .arg(header).arg(auth));
    817817
    818    
     818
    819819    if (request)
    820820        request->setValue(header, auth);
    821        
     821
    822822    return true;
    823823}
    824824
    void HttpComms::calculateDigestResponse( DigestAuthInfo& info, QByteArray& Respo 
    847847        md.reset();
    848848        md.update( authStr );
    849849    }
    850    
     850
    851851    HA1 = md.hexDigest();
    852852
    853853    //cerr << " calculateResponse(): A1 => " << HA1 << endl;
    void HttpComms::calculateDigestResponse( DigestAuthInfo& info, QByteArray& Respo 
    864864        authStr += ':';
    865865        authStr += info.entityBody;
    866866    }
    867    
     867
    868868    md.reset();
    869869    md.update( authStr );
    870870    HA2 = md.hexDigest();
    void HttpComms::calculateDigestResponse( DigestAuthInfo& info, QByteArray& Respo 
    885885        authStr += info.qop;
    886886        authStr += ':';
    887887    }
    888  
     888
    889889    authStr += HA2;
    890890    md.reset();
    891891    md.update( authStr );
  • mythtv/libs/libmythdb/httpcomms.h

    diff --git a/mythtv/libs/libmythdb/httpcomms.h b/mythtv/libs/libmythdb/httpcomms.h
    index 4bc883c..10674c6 100644
    a b class MPUBLIC HttpComms : public QObject 
    2222    bool isDone(void) { return m_done; }
    2323    int getProgress(void) { return m_progress; }
    2424    int getTotal(void) { return m_total; }
    25    
     25
    2626    int getStatusCode(void) { return m_statusCode; }
    2727    QString getResponseReason(void) { return m_responseReason; }
    2828
    class MPUBLIC HttpComms : public QObject 
    4444
    4545            QString user;
    4646            QString pass;
    47     };                           
    48    
     47    };
     48
    4949    enum CredentialTypes { CRED_WEB, CRED_PROXY };
    50    
     50
    5151    void setCredentials(const Credentials& cred, int credType)
    52     { 
     52    {
    5353        if (credType == CRED_PROXY)
    5454            m_proxyCredentials = cred;
    5555        else
    5656            m_webCredentials = cred;
    5757    }
    58    
    59    
    60     static QString getHttp(QString& url, int timeoutMS = 10000, 
     58
     59
     60    static QString getHttp(QString& url, int timeoutMS = 10000,
    6161                           int maxRetries = 3, int maxRedirects = 3,
    6262                           bool allowGzip = false,
    6363                           Credentials* webCred = 0,
    6464                           bool isInQtEventThread = true);
    65    
     65
    6666    static bool getHttpFile(const QString& file, QString& url, int timeoutMS = 10000,
    67                             int maxRetries = 3, int maxRedirects = 3, 
     67                            int maxRetries = 3, int maxRedirects = 3,
    6868                            bool allowGzip = false, Credentials* webCred = 0);
    69    
    70     static QString postHttp(QUrl               &url, 
    71                             QHttpRequestHeader *pAddlHdr          = 0, 
     69
     70    static QString postHttp(QUrl               &url,
     71                            QHttpRequestHeader *pAddlHdr          = 0,
    7272                            QIODevice          *pData             = 0,
    73                             int                 timeoutMS         = 10000, 
    74                             int                 maxRetries        = 3, 
    75                             int                 maxRedirects      = 3, 
     73                            int                 timeoutMS         = 10000,
     74                            int                 maxRetries        = 3,
     75                            int                 maxRedirects      = 3,
    7676                            bool                allowGzip         = false,
    77                             Credentials        *webCred           = 0, 
     77                            Credentials        *webCred           = 0,
    7878                            bool                isInQtEventThread = true );
    7979
    8080    void request(QUrl &url, int timeoutms = -1, bool allowGzip = false);
    8181    void request(QUrl &url, QHttpRequestHeader &header, int timeoutms = -1, QIODevice *pData = 0 );
    82    
     82
    8383    void setCookie( const QString& cookie ) { m_cookie = cookie; }
    8484    const QString& getCookie() const { return m_cookie; }
    85        
     85
    8686  protected:
    8787    struct DigestAuthInfo
    8888    {
    class MPUBLIC HttpComms : public QObject 
    9898        QByteArray algorithm;
    9999        QByteArray entityBody;
    100100    };
    101    
     101
    102102    void init();
    103    
     103
    104104    void calculateDigestResponse( DigestAuthInfo& info, QByteArray& Response );
    105105    bool createDigestAuth( bool isForProxy, const QString& authStr, QHttpRequestHeader* request );
    106    
     106
    107107  private slots:
    108108    void timeout();
    109109    void done(bool error);
    class MPUBLIC HttpComms : public QObject 
    128128    QString m_cookie;
    129129    int m_progress;
    130130    int m_total;
    131    
     131
    132132    QHttpRequestHeader m_curRequest;
    133133};
    134134
  • mythtv/libs/libmythdb/lcddevice.cpp

    diff --git a/mythtv/libs/libmythdb/lcddevice.cpp b/mythtv/libs/libmythdb/lcddevice.cpp
    index ee65d3b..6705f8d 100644
    a b  
    11/*
    22    lcddevice.cpp
    3    
     3
    44    a MythTV project object to control an
    55    LCDproc server
    6    
     6
    77    (c) 2002, 2003 Thor Sigvaldason, Dan Morphis and Isaac Richards
    88*/
    99
    LCD::LCD() 
    6161
    6262    // Constructor for LCD
    6363    //
    64     // Note that this does *not* include opening the socket and initiating 
     64    // Note that this does *not* include opening the socket and initiating
    6565    // communications with the LDCd daemon.
    6666
    6767    VERBOSE(VB_GENERAL|VB_EXTRA, LOC + "An LCD object now exists "
    class LCD * LCD::Get(void) 
    8282    return m_lcd;
    8383}
    8484
    85 void LCD::SetupLCD (void) 
     85void LCD::SetupLCD (void)
    8686{
    8787    QString lcd_host;
    8888    int lcd_port;
    8989
    90     if (m_lcd) 
     90    if (m_lcd)
    9191    {
    9292        delete m_lcd;
    9393        m_lcd = 0;
    void LCD::SetupLCD (void) 
    101101    if (m_enabled && lcd_host.length() > 0 && lcd_port > 1024)
    102102    {
    103103        class LCD * lcd = LCD::Get();
    104         if (lcd->connectToHost(lcd_host, lcd_port) == false) 
     104        if (lcd->connectToHost(lcd_host, lcd_port) == false)
    105105        {
    106106            delete m_lcd;
    107107            m_lcd = 0;
    bool LCD::connectToHost(const QString &lhostname, unsigned int lport) 
    137137
    138138    if (res == 0)
    139139    {
    140         // we need to start the mythlcdserver 
     140        // we need to start the mythlcdserver
    141141        VERBOSE(VB_GENERAL, "Starting mythlcdserver");
    142142        system(qPrintable(GetInstallPrefix() + "/bin/mythlcdserver -v none&"));
    143143        usleep(500000);
    bool LCD::connectToHost(const QString &lhostname, unsigned int lport) 
    150150        {
    151151            ++count;
    152152
    153             VERBOSE(VB_GENERAL, QString("Connecting to lcd server: " 
     153            VERBOSE(VB_GENERAL, QString("Connecting to lcd server: "
    154154                    "%1:%2 (try %3 of 10)").arg(hostname).arg(port)
    155155                                           .arg(count));
    156156
    void LCD::sendToServer(const QString &someText) 
    198198    {
    199199        lcd_ready = false;
    200200
    201         // Ack, connection to server has been severed try to re-establish the 
     201        // Ack, connection to server has been severed try to re-establish the
    202202        // connection
    203203        retryTimer->setSingleShot(false);
    204204        retryTimer->start(10000);
    void LCD::readyRead(MythSocket *sock) 
    254254    // This gets activated automatically by the MythSocket class whenever
    255255    // there's something to read.
    256256    //
    257     // We currently spend most of our time (except for the first line sent 
     257    // We currently spend most of our time (except for the first line sent
    258258    // back) ignoring it.
    259259
    260     int dataSize = socket->bytesAvailable() + 1; 
     260    int dataSize = socket->bytesAvailable() + 1;
    261261    QByteArray data(dataSize + 1, 0);
    262262
    263263    socket->readBlock(data.data(), dataSize);
    void LCD::init() 
    345345    lcd_showvolume = (GetMythDB()->GetSetting("LCDShowVolume", "1") == "1");
    346346    lcd_showmenu = (GetMythDB()->GetSetting("LCDShowMenu", "1") == "1");
    347347    lcd_showrecstatus = (GetMythDB()->GetSetting("LCDShowRecStatus", "1") == "1");
    348     lcd_keystring = GetMythDB()->GetSetting("LCDKeyString", "ABCDEF");   
     348    lcd_keystring = GetMythDB()->GetSetting("LCDKeyString", "ABCDEF");
    349349
    350350    bConnected = true;
    351351    lcd_ready = true;
    void LCD::setMusicProgress(QString time, float value) 
    413413        return;
    414414
    415415    value = min(max(0.0f, value), 1.0f);
    416     sendToServer("SET_MUSIC_PROGRESS " + quotedString(time) + ' ' + 
    417             QString().setNum(value));   
     416    sendToServer("SET_MUSIC_PROGRESS " + quotedString(time) + ' ' +
     417            QString().setNum(value));
    418418}
    419419
    420420void LCD::setMusicShuffle(int shuffle)
    void LCD::setVolumeLevel(float value) 
    443443    else if (value > 1.0)
    444444        value = 1.0;
    445445
    446     sendToServer("SET_VOLUME_LEVEL " + QString().setNum(value));   
     446    sendToServer("SET_VOLUME_LEVEL " + QString().setNum(value));
    447447}
    448448
    449449void LCD::setupLEDs(int(*LedMaskFunc)(void))
    450 { 
     450{
    451451    GetLEDMask = LedMaskFunc;
    452452    // update LED status every 10 seconds
    453453    LEDTimer->setSingleShot(false);
    454     LEDTimer->start(10000); 
     454    LEDTimer->start(10000);
    455455}
    456456
    457457void LCD::outputLEDs()
    void LCD::switchToMusic(const QString &artist, const QString &album, const QStri 
    485485
    486486    VERBOSE(VB_IMPORTANT|VB_EXTRA, LOC + "switchToMusic");
    487487
    488     sendToServer("SWITCH_TO_MUSIC " + quotedString(artist) + ' ' 
    489             + quotedString(album) + ' ' 
     488    sendToServer("SWITCH_TO_MUSIC " + quotedString(artist) + ' '
     489            + quotedString(album) + ' '
    490490            + quotedString(track));
    491491}
    492492
    void LCD::switchToChannel(QString channum, QString title, QString subtitle) 
    497497
    498498    VERBOSE(VB_IMPORTANT|VB_EXTRA, LOC + "switchToChannel");
    499499
    500     sendToServer("SWITCH_TO_CHANNEL " + quotedString(channum) + ' ' 
    501             + quotedString(title) + ' ' 
     500    sendToServer("SWITCH_TO_CHANNEL " + quotedString(channum) + ' '
     501            + quotedString(title) + ' '
    502502            + quotedString(subtitle));
    503503}
    504504
    void LCD::switchToMenu(QList<LCDMenuItem> &menuItems, QString app_name, 
    528528        s += ' ' + quotedString(curItem->ItemName());
    529529
    530530        if (curItem->isChecked() == CHECKED)
    531             s += " CHECKED";   
    532         else if (curItem->isChecked() == UNCHECKED) 
     531            s += " CHECKED";
     532        else if (curItem->isChecked() == UNCHECKED)
    533533            s += " UNCHECKED";
    534534        else if (curItem->isChecked() == NOTCHECKABLE)
    535535            s += " NOTCHECKABLE";
    void LCD::switchToGeneric(QList<LCDTextItem> &textItems) 
    568568        s += ' ' + sRow;
    569569
    570570        if (curItem->getAlignment() == ALIGN_LEFT)
    571             s += " ALIGN_LEFT";   
    572         else if (curItem->getAlignment() == ALIGN_RIGHT) 
     571            s += " ALIGN_LEFT";
     572        else if (curItem->getAlignment() == ALIGN_RIGHT)
    573573            s += " ALIGN_RIGHT";
    574574        else if (curItem->getAlignment() == ALIGN_CENTERED)
    575575            s += " ALIGN_CENTERED";
  • mythtv/libs/libmythdb/lcddevice.h

    diff --git a/mythtv/libs/libmythdb/lcddevice.h b/mythtv/libs/libmythdb/lcddevice.h
    index 9d62b07..6adb7c6 100644
    a b class MPUBLIC LCDMenuItem 
    3131        scrollPosition = indent;
    3232    }
    3333
    34     CHECKED_STATE isChecked() const { return checked; } 
    35     bool isSelected() const { return selected; } 
    36     QString ItemName() const { return name; } 
    37     bool Scroll() const { return scroll; } 
    38     unsigned int getIndent() const { return indent; } 
     34    CHECKED_STATE isChecked() const { return checked; }
     35    bool isSelected() const { return selected; }
     36    QString ItemName() const { return name; }
     37    bool Scroll() const { return scroll; }
     38    unsigned int getIndent() const { return indent; }
    3939    unsigned int getScrollPos() const { return scrollPosition; }
    4040
    4141    void setChecked(CHECKED_STATE value) { checked = value; }
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    109109  public:
    110110   ~LCD();
    111111
    112     enum { 
     112    enum {
    113113        MUSIC_REPEAT_NONE  = 0,
    114114        MUSIC_REPEAT_TRACK = 1,
    115115        MUSIC_REPEAT_ALL   = 2,
    116116    };
    117117
    118     enum { 
     118    enum {
    119119        MUSIC_SHUFFLE_NONE  = 0,
    120120        MUSIC_SHUFFLE_RAND  = 1,
    121121        MUSIC_SHUFFLE_SMART = 2,
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    126126    static class LCD * Get(void);
    127127    static void SetupLCD (void);
    128128
    129     // Used to actually connect to an LCD device       
     129    // Used to actually connect to an LCD device
    130130    bool connectToHost(const QString &hostname, unsigned int port);
    131131
    132132    // When nothing else is going on, show the time
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    134134
    135135    // When playing music, switch to this and give artist and track name
    136136    //
    137     // Note: the use of switchToMusic and setLevels is discouraged, because it 
    138     // has become obvious that most LCD devices cannot handle communications 
     137    // Note: the use of switchToMusic and setLevels is discouraged, because it
     138    // has become obvious that most LCD devices cannot handle communications
    139139    // fast enough to make them useful.
    140140    void switchToMusic(const QString &artist, const QString &album, const QString &track);
    141141
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    143143    void setLevels(int numbLevels, float *values);
    144144
    145145    // For Live TV, supply the channel number, program title and subtitle
    146     //   
     146    //
    147147    // Note that the "channel" screen can be used for any kind of progress meter
    148     // just put whatever you want in the strings, and update the progress as 
     148    // just put whatever you want in the strings, and update the progress as
    149149    // appropriate; see the demo app mythlcd for an example)
    150     void switchToChannel(QString channum = "", QString title = "", 
     150    void switchToChannel(QString channum = "", QString title = "",
    151151                         QString subtitle = "");
    152152
    153     // While watching Live/Recording/Pause Buffer, occasionaly describe how 
     153    // While watching Live/Recording/Pause Buffer, occasionaly describe how
    154154    // much of the program has been seen (between 0.0 and 1.0)
    155155    // (e.g. [current time - start time] / [end time - start time]  )
    156156    void setChannelProgress(float percentViewed);
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    162162                      bool popMenu = true);
    163163
    164164    // Show the Generic Progress
    165     // QPtrList contains pointers to LCDTextItem objects which allow you to 
     165    // QPtrList contains pointers to LCDTextItem objects which allow you to
    166166    // define the screen, row, and alignment of the text
    167167    void switchToGeneric(QList<LCDTextItem> &textItems);
    168168
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    173173
    174174    /** \brief Update the generic screen to display a busy spinner.
    175175        \note The LCD busy spinner only 'moves' when this is called
    176               instead of the lcdserver just handling it itself. 
     176              instead of the lcdserver just handling it itself.
    177177    */
    178178    void setGenericBusy();
    179179
    180180    // Do a music progress bar with the generic level between 0 and 1.0
    181181    void setMusicProgress(QString time, float generic_progress);
    182182
    183     /** \brief Set music player's repeat properties         
     183    /** \brief Set music player's repeat properties
    184184        \param repeat the state of repeat
    185185    */
    186186    void setMusicRepeat(int repeat);
    187187
    188     /** \brief Set music player's shuffle properties             
     188    /** \brief Set music player's shuffle properties
    189189        \param shuffle the state of shuffle
    190190    */
    191191    void setMusicShuffle(int shuffle);
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    196196    // Do a progress bar with the volume level between 0 and 1.0
    197197    void setVolumeLevel(float volume_level);
    198198
    199     // If some other process should be getting all the LCDd screen time (e.g. 
    200     // mythMusic) we can use this to try and prevent and screens from showing 
     199    // If some other process should be getting all the LCDd screen time (e.g.
     200    // mythMusic) we can use this to try and prevent and screens from showing
    201201    // up without having to actual destroy the LCD object
    202202    void switchToNothing();
    203203
    204     // If you want to be pleasant, call shutdown() before deleting your LCD 
     204    // If you want to be pleasant, call shutdown() before deleting your LCD
    205205    // device
    206206    void shutdown();
    207207
    class MPUBLIC LCD : public QObject, public MythSocketCBs 
    214214
    215215    void resetServer(void); // tell the mythlcdserver to reload its settings
    216216
    217   private slots: 
    218     void restartConnection();      // Try to re-establish the connection to 
     217  private slots:
     218    void restartConnection();      // Try to re-establish the connection to
    219219                                   // LCDServer every 10 seconds
    220     void outputLEDs(); 
     220    void outputLEDs();
    221221
    222222  private:
    223223    void sendToServer(const QString &someText);
  • mythtv/libs/libmythdb/msocketdevice.cpp

    diff --git a/mythtv/libs/libmythdb/msocketdevice.cpp b/mythtv/libs/libmythdb/msocketdevice.cpp
    index 7f72faa..1cd707e 100644
    a b class MSocketDevicePrivate 
    5353{
    5454public:
    5555    MSocketDevicePrivate( MSocketDevice::Protocol p )
    56         : protocol(p)
     56        : protocol(p)
    5757    { }
    5858
    5959    MSocketDevice::Protocol protocol;
    public: 
    9595    \value IPv4 The socket is an IPv4 socket.
    9696    \value IPv6 The socket is an IPv6 socket.
    9797    \value Unknown The protocol family of the socket is not known. This can
    98            happen if you use MSocketDevice with an already existing socket; it
    99            tries to determine the protocol family, but this can fail if the
    100            protocol family is not known to MSocketDevice.
     98           happen if you use MSocketDevice with an already existing socket; it
     99           tries to determine the protocol family, but this can fail if the
     100           protocol family is not known to MSocketDevice.
    101101
    102102    \sa protocol() setSocket()
    103103*/
    public: 
    112112    \value AlreadyBound  The device is already bound, according to bind().
    113113
    114114    \value Inaccessible  The operating system or firewall prohibited
    115                         the action.
     115                        the action.
    116116
    117117    \value NoResources  The operating system ran out of a resource.
    118118
    MSocketDevice::MSocketDevice( int socket, Type type ) 
    161161{
    162162#if defined(MSOCKETDEVICE_DEBUG)
    163163    qDebug( "MSocketDevice: Created MSocketDevice %p (socket %x, type %d)",
    164            this, socket, type );
     164           this, socket, type );
    165165#endif
    166166    init();
    167167    setSocket( socket, type );
    MSocketDevice::MSocketDevice( Type type ) 
    184184{
    185185#if defined(MSOCKETDEVICE_DEBUG)
    186186    qDebug( "MSocketDevice: Created MSocketDevice object %p, type %d",
    187             this, type );
     187            this, type );
    188188#endif
    189189    init();
    190190    setSocket( createNewSocket(), type );
    MSocketDevice::MSocketDevice( Type type, Protocol protocol, int ) 
    213213{
    214214#if defined(MSOCKETDEVICE_DEBUG)
    215215    qDebug( "MSocketDevice: Created MSocketDevice object %p, type %d",
    216             this, type );
     216            this, type );
    217217#endif
    218218    init();
    219219    setSocket( createNewSocket(), type );
    MSocketDevice::Type MSocketDevice::type() const 
    272272MSocketDevice::Protocol MSocketDevice::protocol() const
    273273{
    274274    if ( d->protocol == Unknown )
    275         d->protocol = getProtocol();
     275        d->protocol = getProtocol();
    276276    return d->protocol;
    277277}
    278278
    int MSocketDevice::socket() const 
    303303void MSocketDevice::setSocket( int socket, Type type )
    304304{
    305305    if ( fd != -1 )                     // close any open socket
    306         close();
     306        close();
    307307#if defined(MSOCKETDEVICE_DEBUG)
    308308    qDebug( "MSocketDevice::setSocket: socket %x, type %d", socket, type );
    309309#endif
    void MSocketDevice::setSocket( int socket, Type type ) 
    327327bool MSocketDevice::open( OpenMode mode )
    328328{
    329329    if ( isOpen() || !isValid() )
    330         return false;
     330        return false;
    331331#if defined(MSOCKETDEVICE_DEBUG)
    332332    qDebug( "MSocketDevice::open: mode %x", mode );
    333333#endif
  • mythtv/libs/libmythdb/msocketdevice.h

    diff --git a/mythtv/libs/libmythdb/msocketdevice.h b/mythtv/libs/libmythdb/msocketdevice.h
    index db3b7a2..e218d68 100644
    a b public: 
    100100    qint64       bytesAvailable() const;
    101101    qint64       waitForMore( int msecs, bool *timeout=0 ) const;
    102102    virtual qint64 writeBlock( const char *data, quint64 len,
    103                                const QHostAddress & host, quint16 port );
     103                                const QHostAddress & host, quint16 port );
    104104    inline qint64  writeBlock(const char *data, quint64 len)
    105105        { return qint64(write(data, qint64(len))); }
    106106    inline qint64 readBlock(char *data, quint64 maxlen)
    public: 
    112112    QHostAddress peerAddress() const;
    113113
    114114    enum Error {
    115         NoError,
    116         AlreadyBound,
    117         Inaccessible,
    118         NoResources,
    119         InternalError,
    120         Bug = InternalError, // ### remove in 4.0?
    121         Impossible,
    122         NoFiles,
    123         ConnectionRefused,
    124         NetworkFailure,
    125         UnknownError
     115        NoError,
     116        AlreadyBound,
     117        Inaccessible,
     118        NoResources,
     119        InternalError,
     120        Bug = InternalError, // ### remove in 4.0?
     121        Impossible,
     122        NoFiles,
     123        ConnectionRefused,
     124        NetworkFailure,
     125        UnknownError
    126126    };
    127127    Error        error() const;
    128128
  • mythtv/libs/libmythdb/msocketdevice_unix.cpp

    diff --git a/mythtv/libs/libmythdb/msocketdevice_unix.cpp b/mythtv/libs/libmythdb/msocketdevice_unix.cpp
    index 1c1f7eb..cdda985 100644
    a b static inline int qt_socket_socket(int domain, int type, int protocol) 
    7777#include <sys/types.h>
    7878
    7979static inline void qt_socket_getportaddr( struct sockaddr *sa,
    80                                           quint16 *port, QHostAddress *addr )
     80                                          quint16 *port, QHostAddress *addr )
    8181{
    8282#if !defined(QT_NO_IPV6)
    8383    if ( sa->sa_family == AF_INET6 ) {
    84         struct sockaddr_in6 *sa6 = ( struct sockaddr_in6 * )sa;
    85         Q_IPV6ADDR tmp;
    86         memcpy( &tmp, &sa6->sin6_addr.s6_addr, sizeof(tmp) );
    87         QHostAddress a( tmp );
    88         *addr = a;
    89         *port = ntohs( sa6->sin6_port );
    90         return;
     84        struct sockaddr_in6 *sa6 = ( struct sockaddr_in6 * )sa;
     85        Q_IPV6ADDR tmp;
     86        memcpy( &tmp, &sa6->sin6_addr.s6_addr, sizeof(tmp) );
     87        QHostAddress a( tmp );
     88        *addr = a;
     89        *port = ntohs( sa6->sin6_port );
     90        return;
    9191    }
    9292#endif
    9393    struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
    MSocketDevice::Protocol MSocketDevice::getProtocol() const 
    110110{
    111111    if ( isValid() ) {
    112112#if !defined (QT_NO_IPV6)
    113         struct sockaddr_storage sa;
     113        struct sockaddr_storage sa;
    114114#else
    115         struct sockaddr sa;
     115        struct sockaddr sa;
    116116#endif
    117         memset( &sa, 0, sizeof(sa) );
    118         QT_SOCKLEN_T sz = sizeof( sa );
     117        memset( &sa, 0, sizeof(sa) );
     118        QT_SOCKLEN_T sz = sizeof( sa );
    119119#if !defined (QT_NO_IPV6)
    120         struct sockaddr *sap = reinterpret_cast<struct sockaddr *>(&sa);
    121         if ( !::getsockname(fd, sap, &sz) ) {
    122             switch ( sap->sa_family ) {
    123                 case AF_INET:
    124                     return IPv4;
    125                 case AF_INET6:
    126                     return IPv6;
    127                 default:
    128                     return Unknown;
    129             }
    130         }
     120        struct sockaddr *sap = reinterpret_cast<struct sockaddr *>(&sa);
     121        if ( !::getsockname(fd, sap, &sz) ) {
     122            switch ( sap->sa_family ) {
     123                case AF_INET:
     124                    return IPv4;
     125                case AF_INET6:
     126                    return IPv6;
     127                default:
     128                    return Unknown;
     129            }
     130        }
    131131#else
    132         if ( !::getsockname(fd, &sa, &sz) ) {
    133             switch ( sa.sa_family ) {
    134                 case AF_INET:
    135                     return IPv4;
    136                 default:
    137                     return Unknown;
    138             }
    139         }
     132        if ( !::getsockname(fd, &sa, &sz) ) {
     133            switch ( sa.sa_family ) {
     134                case AF_INET:
     135                    return IPv4;
     136                default:
     137                    return Unknown;
     138            }
     139        }
    140140#endif
    141141    }
    142142    return Unknown;
    int MSocketDevice::createNewSocket() 
    153153{
    154154#if !defined(QT_NO_IPV6)
    155155    int s = qt_socket_socket( protocol() == IPv6 ? AF_INET6 : AF_INET,
    156                               t == Datagram ? SOCK_DGRAM : SOCK_STREAM, 0 );
     156                              t == Datagram ? SOCK_DGRAM : SOCK_STREAM, 0 );
    157157#else
    158158    int s = qt_socket_socket( AF_INET, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );
    159159#endif
    160160    if ( s < 0 ) {
    161         switch( errno ) {
    162         case EPROTONOSUPPORT:
    163             e = InternalError; // 0 is supposed to work for both types
    164             break;
    165         case ENFILE:
    166             e = NoFiles; // special case for this
    167             break;
    168         case EACCES:
    169             e = Inaccessible;
    170             break;
    171         case ENOBUFS:
    172         case ENOMEM:
    173             e = NoResources;
    174             break;
    175         case EINVAL:
    176             e = Impossible;
    177             break;
    178         default:
    179             e = UnknownError;
    180             break;
    181         }
     161        switch( errno ) {
     162        case EPROTONOSUPPORT:
     163            e = InternalError; // 0 is supposed to work for both types
     164            break;
     165        case ENFILE:
     166            e = NoFiles; // special case for this
     167            break;
     168        case EACCES:
     169            e = Inaccessible;
     170            break;
     171        case ENOBUFS:
     172        case ENOMEM:
     173            e = NoResources;
     174            break;
     175        case EINVAL:
     176            e = Impossible;
     177            break;
     178        default:
     179            e = UnknownError;
     180            break;
     181        }
    182182    } else {
    183         return s;
     183        return s;
    184184    }
    185185    return -1;
    186186}
    int MSocketDevice::createNewSocket() 
    201201void MSocketDevice::close()
    202202{
    203203    if ( fd == -1 || !isOpen() )                // already closed
    204         return;
     204        return;
    205205    setOpenMode(NotOpen);
    206206    ::close( fd );
    207207#if defined(QSOCKETDEVICE_DEBUG)
    void MSocketDevice::close() 
    227227bool MSocketDevice::blocking() const
    228228{
    229229    if ( !isValid() )
    230         return true;
     230        return true;
    231231    int s = fcntl(fd, F_GETFL, 0);
    232232    return !(s >= 0 && ((s & O_NDELAY) != 0));
    233233}
    void MSocketDevice::setBlocking( bool enable ) 
    253253    qDebug( "MSocketDevice::setBlocking( %d )", enable );
    254254#endif
    255255    if ( !isValid() )
    256         return;
     256        return;
    257257    int tmp = ::fcntl(fd, F_GETFL, 0);
    258258    if ( tmp >= 0 )
    259         tmp = ::fcntl( fd, F_SETFL, enable ? (tmp&~O_NDELAY) : (tmp|O_NDELAY) );
     259        tmp = ::fcntl( fd, F_SETFL, enable ? (tmp&~O_NDELAY) : (tmp|O_NDELAY) );
    260260    if ( tmp >= 0 )
    261         return;
     261        return;
    262262    if ( e )
    263         return;
     263        return;
    264264    switch( errno ) {
    265265    case EACCES:
    266266    case EBADF:
    267         e = Impossible;
    268         break;
     267        e = Impossible;
     268        break;
    269269    case EFAULT:
    270270    case EAGAIN:
    271271#if EAGAIN != EWOULDBLOCK
    void MSocketDevice::setBlocking( bool enable ) 
    278278    case ENOLCK:
    279279    case EPERM:
    280280    default:
    281         e = UnknownError;
     281        e = UnknownError;
    282282    }
    283283}
    284284
    void MSocketDevice::setBlocking( bool enable ) 
    289289int MSocketDevice::option( Option opt ) const
    290290{
    291291    if ( !isValid() )
    292         return -1;
     292        return -1;
    293293    int n = -1;
    294294    int v = -1;
    295295    switch ( opt ) {
    296296    case Broadcast:
    297         n = SO_BROADCAST;
    298         break;
     297        n = SO_BROADCAST;
     298        break;
    299299    case ReceiveBuffer:
    300         n = SO_RCVBUF;
    301         break;
     300        n = SO_RCVBUF;
     301        break;
    302302    case ReuseAddress:
    303         n = SO_REUSEADDR;
    304         break;
     303        n = SO_REUSEADDR;
     304        break;
    305305    case SendBuffer:
    306         n = SO_SNDBUF;
    307         break;
     306        n = SO_SNDBUF;
     307        break;
    308308    }
    309309    if ( n != -1 ) {
    310         QT_SOCKOPTLEN_T len;
    311         len = sizeof(v);
    312         int r = ::getsockopt( fd, SOL_SOCKET, n, (char*)&v, &len );
    313         if ( r >= 0 )
    314             return v;
    315         if ( !e ) {
    316             MSocketDevice *that = (MSocketDevice*)this; // mutable function
    317             switch( errno ) {
    318             case EBADF:
    319             case ENOTSOCK:
    320                 that->e = Impossible;
    321                 break;
    322             case EFAULT:
    323                 that->e = InternalError;
    324                 break;
    325             default:
    326                 that->e = UnknownError;
    327                 break;
    328             }
    329         }
    330         return -1;
     310        QT_SOCKOPTLEN_T len;
     311        len = sizeof(v);
     312        int r = ::getsockopt( fd, SOL_SOCKET, n, (char*)&v, &len );
     313        if ( r >= 0 )
     314            return v;
     315        if ( !e ) {
     316            MSocketDevice *that = (MSocketDevice*)this; // mutable function
     317            switch( errno ) {
     318            case EBADF:
     319            case ENOTSOCK:
     320                that->e = Impossible;
     321                break;
     322            case EFAULT:
     323                that->e = InternalError;
     324                break;
     325            default:
     326                that->e = UnknownError;
     327                break;
     328            }
     329        }
     330        return -1;
    331331    }
    332332    return v;
    333333}
    int MSocketDevice::option( Option opt ) const 
    339339void MSocketDevice::setOption( Option opt, int v )
    340340{
    341341    if ( !isValid() )
    342         return;
     342        return;
    343343    int n = -1; // for really, really bad compilers
    344344    switch ( opt ) {
    345345    case Broadcast:
    346         n = SO_BROADCAST;
    347         break;
     346        n = SO_BROADCAST;
     347        break;
    348348    case ReceiveBuffer:
    349         n = SO_RCVBUF;
    350         break;
     349        n = SO_RCVBUF;
     350        break;
    351351    case ReuseAddress:
    352         n = SO_REUSEADDR;
    353         break;
     352        n = SO_REUSEADDR;
     353        break;
    354354    case SendBuffer:
    355         n = SO_SNDBUF;
    356         break;
     355        n = SO_SNDBUF;
     356        break;
    357357    default:
    358         return;
     358        return;
    359359    }
    360360    if ( ::setsockopt( fd, SOL_SOCKET, n, (char*)&v, sizeof(v)) < 0 &&
    361         e == NoError ) {
    362         switch( errno ) {
    363         case EBADF:
    364         case ENOTSOCK:
    365             e = Impossible;
    366             break;
    367         case EFAULT:
    368             e = InternalError;
    369             break;
    370         default:
    371             e = UnknownError;
    372             break;
    373         }
     361        e == NoError ) {
     362        switch( errno ) {
     363        case EBADF:
     364        case ENOTSOCK:
     365            e = Impossible;
     366            break;
     367        case EFAULT:
     368            e = InternalError;
     369            break;
     370        default:
     371            e = UnknownError;
     372            break;
     373        }
    374374    }
    375375}
    376376
    void MSocketDevice::setOption( Option opt, int v ) 
    387387bool MSocketDevice::connect( const QHostAddress &addr, quint16 port )
    388388{
    389389    if ( !isValid() )
    390         return false;
     390        return false;
    391391
    392392    pa = addr;
    393393    pp = port;
    bool MSocketDevice::connect( const QHostAddress &addr, quint16 port ) 
    400400    struct sockaddr_in6 a6;
    401401
    402402    if ( addr.protocol() == QAbstractSocket::IPv6Protocol ) {
    403         memset( &a6, 0, sizeof(a6) );
    404         a6.sin6_family = AF_INET6;
    405         a6.sin6_port = htons( port );
    406         Q_IPV6ADDR ip6 = addr.toIPv6Address();
    407         memcpy( &a6.sin6_addr.s6_addr, &ip6, sizeof(ip6) );
    408 
    409         aalen = sizeof( a6 );
    410         aa = (struct sockaddr *)&a6;
     403        memset( &a6, 0, sizeof(a6) );
     404        a6.sin6_family = AF_INET6;
     405        a6.sin6_port = htons( port );
     406        Q_IPV6ADDR ip6 = addr.toIPv6Address();
     407        memcpy( &a6.sin6_addr.s6_addr, &ip6, sizeof(ip6) );
     408
     409        aalen = sizeof( a6 );
     410        aa = (struct sockaddr *)&a6;
    411411    } else
    412412#endif
    413413    if ( addr.protocol() == QAbstractSocket::IPv4Protocol ) {
    414         memset( &a4, 0, sizeof(a4) );
    415         a4.sin_family = AF_INET;
    416         a4.sin_port = htons( port );
    417         a4.sin_addr.s_addr = htonl( addr.toIPv4Address() );
     414        memset( &a4, 0, sizeof(a4) );
     415        a4.sin_family = AF_INET;
     416        a4.sin_port = htons( port );
     417        a4.sin_addr.s_addr = htonl( addr.toIPv4Address() );
    418418
    419         aalen = sizeof(a4);
    420         aa = (struct sockaddr *)&a4;
     419        aalen = sizeof(a4);
     420        aa = (struct sockaddr *)&a4;
    421421    } else {
    422         e = Impossible;
    423         return false;
     422        e = Impossible;
     423        return false;
    424424    }
    425425
    426426    int r = QT_SOCKET_CONNECT( fd, aa, aalen );
    427427    if ( r == 0 ) {
    428         fetchConnectionParameters();
    429         return true;
     428        fetchConnectionParameters();
     429        return true;
    430430    }
    431431    if ( errno == EISCONN || errno == EALREADY || errno == EINPROGRESS ) {
    432         fetchConnectionParameters();
    433         return true;
     432        fetchConnectionParameters();
     433        return true;
    434434    }
    435435    if ( e != NoError || errno == EAGAIN || errno == EWOULDBLOCK ) {
    436         return false;
     436        return false;
    437437    }
    438438    switch( errno ) {
    439439    case EBADF:
    440440    case ENOTSOCK:
    441         e = Impossible;
    442         break;
     441        e = Impossible;
     442        break;
    443443    case EFAULT:
    444444    case EAFNOSUPPORT:
    445         e = InternalError;
    446         break;
     445        e = InternalError;
     446        break;
    447447    case ECONNREFUSED:
    448         e = ConnectionRefused;
    449         break;
     448        e = ConnectionRefused;
     449        break;
    450450    case ETIMEDOUT:
    451451    case ENETUNREACH:
    452         e = NetworkFailure;
    453         break;
     452        e = NetworkFailure;
     453        break;
    454454    case EADDRINUSE:
    455         e = NoResources;
    456         break;
     455        e = NoResources;
     456        break;
    457457    case EACCES:
    458458    case EPERM:
    459         e = Inaccessible;
    460         break;
     459        e = Inaccessible;
     460        break;
    461461    default:
    462         e = UnknownError;
    463         break;
     462        e = UnknownError;
     463        break;
    464464    }
    465465    return false;
    466466}
    bool MSocketDevice::connect( const QHostAddress &addr, quint16 port ) 
    478478bool MSocketDevice::bind( const QHostAddress &address, quint16 port )
    479479{
    480480    if ( !isValid() )
    481         return false;
     481        return false;
    482482    int r;
    483483    struct sockaddr_in a4;
    484484#if !defined(QT_NO_IPV6)
    485485    struct sockaddr_in6 a6;
    486486
    487487    if ( address.protocol() == QAbstractSocket::IPv6Protocol ) {
    488         memset( &a6, 0, sizeof(a6) );
    489         a6.sin6_family = AF_INET6;
    490         a6.sin6_port = htons( port );
    491         Q_IPV6ADDR tmp = address.toIPv6Address();
    492         memcpy( &a6.sin6_addr.s6_addr, &tmp, sizeof(tmp) );
     488        memset( &a6, 0, sizeof(a6) );
     489        a6.sin6_family = AF_INET6;
     490        a6.sin6_port = htons( port );
     491        Q_IPV6ADDR tmp = address.toIPv6Address();
     492        memcpy( &a6.sin6_addr.s6_addr, &tmp, sizeof(tmp) );
    493493
    494         r = QT_SOCKET_BIND( fd, (struct sockaddr *)&a6, sizeof(a6) );
     494        r = QT_SOCKET_BIND( fd, (struct sockaddr *)&a6, sizeof(a6) );
    495495    } else
    496496#endif
    497497    if ( address.protocol() == QAbstractSocket::IPv4Protocol ) {
    498         memset( &a4, 0, sizeof(a4) );
    499         a4.sin_family = AF_INET;
    500         a4.sin_port = htons( port );
    501         a4.sin_addr.s_addr = htonl( address.toIPv4Address() );
     498        memset( &a4, 0, sizeof(a4) );
     499        a4.sin_family = AF_INET;
     500        a4.sin_port = htons( port );
     501        a4.sin_addr.s_addr = htonl( address.toIPv4Address() );
    502502
    503         r = QT_SOCKET_BIND( fd, (struct sockaddr*)&a4, sizeof(a4) );
     503        r = QT_SOCKET_BIND( fd, (struct sockaddr*)&a4, sizeof(a4) );
    504504    } else {
    505         e = Impossible;
    506         return false;
     505        e = Impossible;
     506        return false;
    507507    }
    508508
    509509    if ( r < 0 ) {
    510         switch( errno ) {
    511         case EINVAL:
    512             e = AlreadyBound;
    513             break;
    514         case EACCES:
    515             e = Inaccessible;
    516             break;
    517         case ENOMEM:
    518             e = NoResources;
    519             break;
    520         case EFAULT: // a was illegal
    521         case ENAMETOOLONG: // sz was wrong
    522             e = InternalError;
    523             break;
    524         case EBADF: // AF_UNIX only
    525         case ENOTSOCK: // AF_UNIX only
    526         case EROFS: // AF_UNIX only
    527         case ENOENT: // AF_UNIX only
    528         case ENOTDIR: // AF_UNIX only
    529         case ELOOP: // AF_UNIX only
    530             e = Impossible;
    531             break;
    532         default:
    533             e = UnknownError;
    534             break;
    535         }
    536         return false;
     510        switch( errno ) {
     511        case EINVAL:
     512            e = AlreadyBound;
     513            break;
     514        case EACCES:
     515            e = Inaccessible;
     516            break;
     517        case ENOMEM:
     518            e = NoResources;
     519            break;
     520        case EFAULT: // a was illegal
     521        case ENAMETOOLONG: // sz was wrong
     522            e = InternalError;
     523            break;
     524        case EBADF: // AF_UNIX only
     525        case ENOTSOCK: // AF_UNIX only
     526        case EROFS: // AF_UNIX only
     527        case ENOENT: // AF_UNIX only
     528        case ENOTDIR: // AF_UNIX only
     529        case ELOOP: // AF_UNIX only
     530            e = Impossible;
     531            break;
     532        default:
     533            e = UnknownError;
     534            break;
     535        }
     536        return false;
    537537    }
    538538    fetchConnectionParameters();
    539539    return true;
    bool MSocketDevice::bind( const QHostAddress &address, quint16 port ) 
    554554bool MSocketDevice::listen( int backlog )
    555555{
    556556    if ( !isValid() )
    557         return false;
     557        return false;
    558558    if ( qt_socket_listen( fd, backlog ) >= 0 )
    559         return true;
     559        return true;
    560560    if ( !e )
    561         e = Impossible;
     561        e = Impossible;
    562562    return false;
    563563}
    564564
    bool MSocketDevice::listen( int backlog ) 
    573573int MSocketDevice::accept()
    574574{
    575575    if ( !isValid() )
    576         return -1;
     576        return -1;
    577577
    578578#if !defined (QT_NO_IPV6)
    579579    struct sockaddr_storage aa;
    int MSocketDevice::accept() 
    593593                done = false;
    594594                break;
    595595#if defined(EPROTO)
    596             case EPROTO:
     596            case EPROTO:
    597597#endif
    598598#if defined(ENONET)
    599             case ENONET:
     599            case ENONET:
    600600#endif
    601             case ENOPROTOOPT:
    602             case EHOSTDOWN:
    603             case EOPNOTSUPP:
    604             case EHOSTUNREACH:
    605             case ENETDOWN:
    606             case ENETUNREACH:
    607             case ETIMEDOUT:
    608                 // in all these cases, an error happened during connection
    609                 // setup.  we're not interested in what happened, so we
    610                 // just treat it like the client-closed-quickly case.
    611             case EPERM:
    612                 // firewalling wouldn't let us accept.  we treat it like
    613                 // the client-closed-quickly case.
    614             case EAGAIN:
     601            case ENOPROTOOPT:
     602            case EHOSTDOWN:
     603            case EOPNOTSUPP:
     604            case EHOSTUNREACH:
     605            case ENETDOWN:
     606            case ENETUNREACH:
     607            case ETIMEDOUT:
     608                // in all these cases, an error happened during connection
     609                // setup.  we're not interested in what happened, so we
     610                // just treat it like the client-closed-quickly case.
     611            case EPERM:
     612                // firewalling wouldn't let us accept.  we treat it like
     613                // the client-closed-quickly case.
     614            case EAGAIN:
    615615#if EAGAIN != EWOULDBLOCK
    616             case EWOULDBLOCK:
     616            case EWOULDBLOCK:
    617617#endif
    618                 // the client closed the connection before we got around
    619                 // to accept()ing it.
    620                 break;
    621             case EBADF:
    622             case ENOTSOCK:
    623                 e = Impossible;
    624                 break;
    625             case EFAULT:
    626                 e = InternalError;
    627                 break;
    628             case ENOMEM:
    629             case ENOBUFS:
    630                 e = NoResources;
    631                 break;
    632             default:
    633                 e = UnknownError;
    634                 break;
    635             }
    636         }
     618                // the client closed the connection before we got around
     619                // to accept()ing it.
     620                break;
     621            case EBADF:
     622            case ENOTSOCK:
     623                e = Impossible;
     624                break;
     625            case EFAULT:
     626                e = InternalError;
     627                break;
     628            case ENOMEM:
     629            case ENOBUFS:
     630                e = NoResources;
     631                break;
     632            default:
     633                e = UnknownError;
     634                break;
     635            }
     636        }
    637637    } while (!done);
    638638    return s;
    639639}
    int MSocketDevice::accept() 
    653653qint64 MSocketDevice::bytesAvailable() const
    654654{
    655655    if ( !isValid() )
    656         return -1;
     656        return -1;
    657657
    658658    /*
    659659      Apparently, there is not consistency among different operating
    qint64 MSocketDevice::bytesAvailable() const 
    673673    size_t nbytes = 0;
    674674    // gives shorter than true amounts on Unix domain sockets.
    675675    if ( ::ioctl(fd, FIONREAD, (char*)&nbytes) < 0 )
    676         return -1;
     676        return -1;
    677677    return (qint64) *((int *)&nbytes) + QIODevice::bytesAvailable();
    678678}
    679679
    qint64 MSocketDevice::bytesAvailable() const 
    699699qint64 MSocketDevice::waitForMore( int msecs, bool *timeout ) const
    700700{
    701701    if ( !isValid() )
    702         return -1;
     702        return -1;
    703703    if ( fd >= FD_SETSIZE )
    704         return -1;
     704        return -1;
    705705
    706706    fd_set fds;
    707707    struct timeval tv;
    qint64 MSocketDevice::waitForMore( int msecs, bool *timeout ) const 
    715715    int rv = select( fd+1, &fds, 0, 0, msecs < 0 ? 0 : &tv );
    716716
    717717    if ( rv < 0 )
    718         return -1;
     718        return -1;
    719719
    720720    if ( timeout ) {
    721         if ( rv == 0 )
    722             *timeout = true;
    723         else
    724             *timeout = false;
     721        if ( rv == 0 )
     722            *timeout = true;
     723        else
     724            *timeout = false;
    725725    }
    726726
    727727    return bytesAvailable();
    qint64 MSocketDevice::readData( char *data, qint64 maxlen ) 
    736736{
    737737#if defined(QT_CHECK_NULL)
    738738    if ( data == 0 && maxlen != 0 ) {
    739         qWarning( "MSocketDevice::readBlock: Null pointer error" );
     739        qWarning( "MSocketDevice::readBlock: Null pointer error" );
    740740    }
    741741#endif
    742742#if defined(QT_CHECK_STATE)
    743743    if ( !isValid() ) {
    744         qWarning( "MSocketDevice::readBlock: Invalid socket" );
    745         return -1;
     744        qWarning( "MSocketDevice::readBlock: Invalid socket" );
     745        return -1;
    746746    }
    747747    if ( !isOpen() ) {
    748         qWarning( "MSocketDevice::readBlock: Device is not open" );
    749         return -1;
     748        qWarning( "MSocketDevice::readBlock: Device is not open" );
     749        return -1;
    750750    }
    751751    if ( !isReadable() ) {
    752         qWarning( "MSocketDevice::readBlock: Read operation not permitted" );
    753         return -1;
     752        qWarning( "MSocketDevice::readBlock: Read operation not permitted" );
     753        return -1;
    754754    }
    755755#endif
    756756    bool done = false;
    757757    int r = 0;
    758758    while ( done == false ) {
    759         if ( t == Datagram ) {
     759        if ( t == Datagram ) {
    760760#if !defined(QT_NO_IPV6)
    761761            struct sockaddr_storage aa;
    762762#else
    763763            struct sockaddr_in aa;
    764764#endif
    765             memset( &aa, 0, sizeof(aa) );
    766             QT_SOCKLEN_T sz;
    767             sz = sizeof( aa );
    768             r = ::recvfrom( fd, data, maxlen, 0,
    769                             (struct sockaddr *)&aa, &sz );
    770 
    771             qt_socket_getportaddr( (struct sockaddr *)&aa, &pp, &pa);
    772 
    773         } else {
    774             r = ::read( fd, data, maxlen );
    775         }
    776         done = true;
     765            memset( &aa, 0, sizeof(aa) );
     766            QT_SOCKLEN_T sz;
     767            sz = sizeof( aa );
     768            r = ::recvfrom( fd, data, maxlen, 0,
     769                            (struct sockaddr *)&aa, &sz );
     770
     771            qt_socket_getportaddr( (struct sockaddr *)&aa, &pp, &pa);
     772
     773        } else {
     774            r = ::read( fd, data, maxlen );
     775        }
     776        done = true;
    777777        if ( r == 0 && t == Stream && maxlen > 0 ) {
    778778            // connection closed
    779779            close();
    780780        } else if ( r >= 0 || errno == EAGAIN || errno == EWOULDBLOCK ) {
    781             // nothing
    782         } else if ( errno == EINTR ) {
    783             done = false;
    784         } else if ( e == NoError ) {
    785             switch( errno ) {
    786             case EIO:
    787             case EISDIR:
    788             case EBADF:
    789             case EINVAL:
    790             case EFAULT:
    791             case ENOTCONN:
    792             case ENOTSOCK:
    793                 e = Impossible;
    794                 break;
     781            // nothing
     782        } else if ( errno == EINTR ) {
     783            done = false;
     784        } else if ( e == NoError ) {
     785            switch( errno ) {
     786            case EIO:
     787            case EISDIR:
     788            case EBADF:
     789            case EINVAL:
     790            case EFAULT:
     791            case ENOTCONN:
     792            case ENOTSOCK:
     793                e = Impossible;
     794                break;
    795795#if defined(ENONET)
    796             case ENONET:
     796            case ENONET:
    797797#endif
    798             case EHOSTUNREACH:
    799             case ENETDOWN:
    800             case ENETUNREACH:
    801             case ETIMEDOUT:
    802                 e = NetworkFailure;
    803                 break;
    804             case EPIPE:
    805             case ECONNRESET:
    806                 // connection closed
    807                 close();
    808                 r = 0;
    809                 break;
    810             default:
    811                 e = UnknownError;
    812                 break;
    813             }
    814         }
     798            case EHOSTUNREACH:
     799            case ENETDOWN:
     800            case ENETUNREACH:
     801            case ETIMEDOUT:
     802                e = NetworkFailure;
     803                break;
     804            case EPIPE:
     805            case ECONNRESET:
     806                // connection closed
     807                close();
     808                r = 0;
     809                break;
     810            default:
     811                e = UnknownError;
     812                break;
     813            }
     814        }
    815815    }
    816816    return r;
    817817}
    qint64 MSocketDevice::readData( char *data, qint64 maxlen ) 
    826826qint64 MSocketDevice::writeData( const char *data, qint64 len )
    827827{
    828828    if ( len == 0 )
    829         return 0;
     829        return 0;
    830830
    831831    if ( data == 0 ) {
    832832#if defined(QT_CHECK_NULL) || defined(QSOCKETDEVICE_DEBUG)
    833         qWarning( "MSocketDevice::writeBlock: Null pointer error" );
     833        qWarning( "MSocketDevice::writeBlock: Null pointer error" );
    834834#endif
    835         return -1;
     835        return -1;
    836836    }
    837837    if ( !isValid() ) {
    838838#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    839         qWarning( "MSocketDevice::writeBlock: Invalid socket" );
     839        qWarning( "MSocketDevice::writeBlock: Invalid socket" );
    840840#endif
    841         return -1;
     841        return -1;
    842842    }
    843843    if ( !isOpen() ) {
    844844#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    845         qWarning( "MSocketDevice::writeBlock: Device is not open" );
     845        qWarning( "MSocketDevice::writeBlock: Device is not open" );
    846846#endif
    847         return -1;
     847        return -1;
    848848    }
    849849    if ( !isWritable() ) {
    850850#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    851         qWarning( "MSocketDevice::writeBlock: Write operation not permitted" );
     851        qWarning( "MSocketDevice::writeBlock: Write operation not permitted" );
    852852#endif
    853         return -1;
     853        return -1;
    854854    }
    855855    bool done = false;
    856856    int r = 0;
    857857    bool timeout;
    858858    while ( !done ) {
    859         r = ::write( fd, data, len );
    860         done = true;
    861         if ( r < 0 && e == NoError &&
    862              errno != EAGAIN && errno != EWOULDBLOCK ) {
    863             switch( errno ) {
    864             case EINTR: // signal - call read() or whatever again
    865                 done = false;
    866                 break;
    867             case EPIPE:
     859        r = ::write( fd, data, len );
     860        done = true;
     861        if ( r < 0 && e == NoError &&
     862             errno != EAGAIN && errno != EWOULDBLOCK ) {
     863            switch( errno ) {
     864            case EINTR: // signal - call read() or whatever again
     865                done = false;
     866                break;
     867            case EPIPE:
    868868            case ECONNRESET:
    869                 // connection closed
    870                 close();
    871                 r = 0;
    872                 break;
    873             case ENOSPC:
    874             case EIO:
    875             case EISDIR:
    876             case EBADF:
    877             case EINVAL:
    878             case EFAULT:
    879             case ENOTCONN:
    880             case ENOTSOCK:
    881                 e = Impossible;
    882                 break;
     869                // connection closed
     870                close();
     871                r = 0;
     872                break;
     873            case ENOSPC:
     874            case EIO:
     875            case EISDIR:
     876            case EBADF:
     877            case EINVAL:
     878            case EFAULT:
     879            case ENOTCONN:
     880            case ENOTSOCK:
     881                e = Impossible;
     882                break;
    883883#if defined(ENONET)
    884             case ENONET:
     884            case ENONET:
    885885#endif
    886             case EHOSTUNREACH:
    887             case ENETDOWN:
    888             case ENETUNREACH:
    889             case ETIMEDOUT:
    890                 e = NetworkFailure;
    891                 break;
    892             default:
    893                 e = UnknownError;
    894                 break;
    895             }
    896         } else if ( waitForMore( 0, &timeout ) == 0 ) {
    897             if ( !timeout ) {
    898                 // connection closed
    899                 close();
    900             }
    901         }
     886            case EHOSTUNREACH:
     887            case ENETDOWN:
     888            case ENETUNREACH:
     889            case ETIMEDOUT:
     890                e = NetworkFailure;
     891                break;
     892            default:
     893                e = UnknownError;
     894                break;
     895            }
     896        } else if ( waitForMore( 0, &timeout ) == 0 ) {
     897            if ( !timeout ) {
     898                // connection closed
     899                close();
     900            }
     901        }
    902902    }
    903903    return r;
    904904}
    qint64 MSocketDevice::writeData( const char *data, qint64 len ) 
    914914    specify the \a host and \a port of the destination of the data.
    915915*/
    916916qint64 MSocketDevice::writeBlock( const char * data, quint64 len,
    917                                const QHostAddress & host, quint16 port )
     917                               const QHostAddress & host, quint16 port )
    918918{
    919919    if ( len == 0 )
    920         return 0;
     920        return 0;
    921921
    922922    if ( t != Datagram ) {
    923923#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    924         qWarning( "MSocketDevice::sendBlock: Not datagram" );
     924        qWarning( "MSocketDevice::sendBlock: Not datagram" );
    925925#endif
    926         return -1; // for now - later we can do t/tcp
     926        return -1; // for now - later we can do t/tcp
    927927    }
    928928
    929929    if ( data == 0 ) {
    930930#if defined(QT_CHECK_NULL) || defined(QSOCKETDEVICE_DEBUG)
    931         qWarning( "MSocketDevice::sendBlock: Null pointer error" );
     931        qWarning( "MSocketDevice::sendBlock: Null pointer error" );
    932932#endif
    933         return -1;
     933        return -1;
    934934    }
    935935    if ( !isValid() ) {
    936936#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    937         qWarning( "MSocketDevice::sendBlock: Invalid socket" );
     937        qWarning( "MSocketDevice::sendBlock: Invalid socket" );
    938938#endif
    939         return -1;
     939        return -1;
    940940    }
    941941    if ( !isOpen() ) {
    942942#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    943         qWarning( "MSocketDevice::sendBlock: Device is not open" );
     943        qWarning( "MSocketDevice::sendBlock: Device is not open" );
    944944#endif
    945         return -1;
     945        return -1;
    946946    }
    947947    if ( !isWritable() ) {
    948948#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    949         qWarning( "MSocketDevice::sendBlock: Write operation not permitted" );
     949        qWarning( "MSocketDevice::sendBlock: Write operation not permitted" );
    950950#endif
    951         return -1;
     951        return -1;
    952952    }
    953953    struct sockaddr_in a4;
    954954    struct sockaddr *aa;
    qint64 MSocketDevice::writeBlock( const char * data, quint64 len, 
    956956#if !defined(QT_NO_IPV6)
    957957    struct sockaddr_in6 a6;
    958958    if ( host.protocol() == QAbstractSocket::IPv6Protocol ) {
    959         memset( &a6, 0, sizeof(a6) );
    960         a6.sin6_family = AF_INET6;
    961         a6.sin6_port = htons( port );
    962 
    963         Q_IPV6ADDR tmp = host.toIPv6Address();
    964         memcpy( &a6.sin6_addr.s6_addr, &tmp, sizeof(tmp) );
    965         slen = sizeof( a6 );
    966         aa = (struct sockaddr *)&a6;
     959        memset( &a6, 0, sizeof(a6) );
     960        a6.sin6_family = AF_INET6;
     961        a6.sin6_port = htons( port );
     962
     963        Q_IPV6ADDR tmp = host.toIPv6Address();
     964        memcpy( &a6.sin6_addr.s6_addr, &tmp, sizeof(tmp) );
     965        slen = sizeof( a6 );
     966        aa = (struct sockaddr *)&a6;
    967967    } else
    968968#endif
    969969    if ( host.protocol() == QAbstractSocket::IPv4Protocol ) {
    970         memset( &a4, 0, sizeof(a4) );
    971         a4.sin_family = AF_INET;
    972         a4.sin_port = htons( port );
    973         a4.sin_addr.s_addr = htonl( host.toIPv4Address() );
    974         slen = sizeof(a4);
    975         aa = (struct sockaddr *)&a4;
     970        memset( &a4, 0, sizeof(a4) );
     971        a4.sin_family = AF_INET;
     972        a4.sin_port = htons( port );
     973        a4.sin_addr.s_addr = htonl( host.toIPv4Address() );
     974        slen = sizeof(a4);
     975        aa = (struct sockaddr *)&a4;
    976976    } else {
    977         e = Impossible;
    978         return -1;
     977        e = Impossible;
     978        return -1;
    979979    }
    980980
    981981    // we'd use MSG_DONTWAIT + MSG_NOSIGNAL if Stevens were right.
    qint64 MSocketDevice::writeBlock( const char * data, quint64 len, 
    983983    bool done = false;
    984984    int r = 0;
    985985    while ( !done ) {
    986         r = ::sendto( fd, data, len, 0, aa, slen);
    987         done = true;
    988         if ( r < 0 && e == NoError &&
    989              errno != EAGAIN && errno != EWOULDBLOCK ) {
    990             switch( errno ) {
    991             case EINTR: // signal - call read() or whatever again
    992                 done = false;
    993                 break;
    994             case ENOSPC:
    995             case EPIPE:
    996             case EIO:
    997             case EISDIR:
    998             case EBADF:
    999             case EINVAL:
    1000             case EFAULT:
    1001             case ENOTCONN:
    1002             case ENOTSOCK:
    1003                 e = Impossible;
    1004                 break;
     986        r = ::sendto( fd, data, len, 0, aa, slen);
     987        done = true;
     988        if ( r < 0 && e == NoError &&
     989             errno != EAGAIN && errno != EWOULDBLOCK ) {
     990            switch( errno ) {
     991            case EINTR: // signal - call read() or whatever again
     992                done = false;
     993                break;
     994            case ENOSPC:
     995            case EPIPE:
     996            case EIO:
     997            case EISDIR:
     998            case EBADF:
     999            case EINVAL:
     1000            case EFAULT:
     1001            case ENOTCONN:
     1002            case ENOTSOCK:
     1003                e = Impossible;
     1004                break;
    10051005#if defined(ENONET)
    1006             case ENONET:
     1006            case ENONET:
    10071007#endif
    1008             case EHOSTUNREACH:
    1009             case ENETDOWN:
    1010             case ENETUNREACH:
    1011             case ETIMEDOUT:
    1012                 e = NetworkFailure;
    1013                 break;
    1014             default:
    1015                 e = UnknownError;
    1016                 break;
    1017             }
    1018         }
     1008            case EHOSTUNREACH:
     1009            case ENETDOWN:
     1010            case ENETUNREACH:
     1011            case ETIMEDOUT:
     1012                e = NetworkFailure;
     1013                break;
     1014            default:
     1015                e = UnknownError;
     1016                break;
     1017            }
     1018        }
    10191019    }
    10201020    return r;
    10211021}
    qint64 MSocketDevice::writeBlock( const char * data, quint64 len, 
    10281028void MSocketDevice::fetchConnectionParameters()
    10291029{
    10301030    if ( !isValid() ) {
    1031         p = 0;
    1032         a = QHostAddress();
    1033         pp = 0;
    1034         pa = QHostAddress();
    1035         return;
     1031        p = 0;
     1032        a = QHostAddress();
     1033        pp = 0;
     1034        pa = QHostAddress();
     1035        return;
    10361036    }
    10371037#if !defined(QT_NO_IPV6)
    10381038    struct sockaddr_storage sa;
    void MSocketDevice::fetchConnectionParameters() 
    10431043    QT_SOCKLEN_T sz;
    10441044    sz = sizeof( sa );
    10451045    if ( !::getsockname( fd, (struct sockaddr *)(&sa), &sz ) )
    1046         qt_socket_getportaddr( (struct sockaddr *)&sa, &p, &a );
     1046        qt_socket_getportaddr( (struct sockaddr *)&sa, &p, &a );
    10471047
    10481048    sz = sizeof( sa );
    10491049    if ( !::getpeername( fd, (struct sockaddr *)(&sa), &sz ) )
    1050         qt_socket_getportaddr( (struct sockaddr *)&sa, &pp, &pa );
     1050        qt_socket_getportaddr( (struct sockaddr *)&sa, &pp, &pa );
    10511051}
    10521052
    10531053
  • mythtv/libs/libmythdb/msocketdevice_win.cpp

    diff --git a/mythtv/libs/libmythdb/msocketdevice_win.cpp b/mythtv/libs/libmythdb/msocketdevice_win.cpp
    index a986a8b..32af3ad 100644
    a b static void cleanupWinSock() // post-routine 
    120120}
    121121
    122122static inline void qt_socket_getportaddr( struct sockaddr *sa,
    123                                           quint16 *port, QHostAddress *addr )
     123                                          quint16 *port, QHostAddress *addr )
    124124{
    125125#if !defined (QT_NO_IPV6)
    126126    if (sa->sa_family == AF_INET6) {
    127         qt_sockaddr_in6 *sa6 = (qt_sockaddr_in6 *)sa;
    128         Q_IPV6ADDR tmp;
    129         for ( int i = 0; i < 16; ++i )
    130             tmp.c[i] = sa6->sin6_addr.qt_s6_addr[i];
    131         QHostAddress a( tmp );
     127        qt_sockaddr_in6 *sa6 = (qt_sockaddr_in6 *)sa;
     128        Q_IPV6ADDR tmp;
     129        for ( int i = 0; i < 16; ++i )
     130            tmp.c[i] = sa6->sin6_addr.qt_s6_addr[i];
     131        QHostAddress a( tmp );
    132132        *addr = a;
    133133        *port = ntohs( sa6->sin6_port );
    134         return;
     134        return;
    135135    }
    136136#endif
    137137    struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
    void MSocketDevice::init() 
    144144{
    145145#if !defined(QT_NO_IPV6)
    146146    if ( !initialized ) {
    147         WSAData wsadata;
    148         // IPv6 requires Winsock v2.0 or better.
    149         if ( WSAStartup( MAKEWORD(2,0), &wsadata ) != 0 ) {
     147        WSAData wsadata;
     148        // IPv6 requires Winsock v2.0 or better.
     149        if ( WSAStartup( MAKEWORD(2,0), &wsadata ) != 0 ) {
    150150#  if defined(QSOCKETDEVICE_DEBUG)
    151             qDebug( "MSocketDevice: WinSock v2.0 initialization failed, disabling IPv6 support." );
     151            qDebug( "MSocketDevice: WinSock v2.0 initialization failed, disabling IPv6 support." );
    152152#  endif
    153         } else {
    154             qAddPostRoutine( cleanupWinSock );
    155             initialized = 0x20;
    156             return;
    157         }
     153        } else {
     154            qAddPostRoutine( cleanupWinSock );
     155            initialized = 0x20;
     156            return;
     157        }
    158158    }
    159159#endif
    160160
    161161    if (!initialized) {
    162         WSAData wsadata;
    163         if ( WSAStartup( MAKEWORD(1,1), &wsadata ) != 0 ) {
     162        WSAData wsadata;
     163        if ( WSAStartup( MAKEWORD(1,1), &wsadata ) != 0 ) {
    164164#if defined(QT_CHECK_NULL)
    165             qWarning( "MSocketDevice: WinSock initialization failed" );
     165            qWarning( "MSocketDevice: WinSock initialization failed" );
    166166#endif
    167167#if defined(QSOCKETDEVICE_DEBUG)
    168             qDebug( "MSocketDevice: WinSock initialization failed"  );
     168            qDebug( "MSocketDevice: WinSock initialization failed"  );
    169169#endif
    170             return;
    171         }
    172         qAddPostRoutine( cleanupWinSock );
    173         initialized = 0x11;
     170            return;
     171        }
     172        qAddPostRoutine( cleanupWinSock );
     173        initialized = 0x11;
    174174    }
    175175}
    176176
    MSocketDevice::Protocol MSocketDevice::getProtocol() const 
    178178{
    179179    if ( isValid() ) {
    180180#if !defined (QT_NO_IPV6)
    181         struct qt_sockaddr_storage sa;
     181        struct qt_sockaddr_storage sa;
    182182#else
    183         struct sockaddr_in sa;
     183        struct sockaddr_in sa;
    184184#endif
    185         memset( &sa, 0, sizeof(sa) );
    186         SOCKLEN_T sz = sizeof( sa );
    187         if ( !::getsockname(fd, (struct sockaddr *)&sa, &sz) ) {
     185        memset( &sa, 0, sizeof(sa) );
     186        SOCKLEN_T sz = sizeof( sa );
     187        if ( !::getsockname(fd, (struct sockaddr *)&sa, &sz) ) {
    188188#if !defined (QT_NO_IPV6)
    189             switch ( sa.ss_family ) {
    190                 case AF_INET:
    191                     return IPv4;
    192                 case AF_INET6:
    193                     return IPv6;
    194                 default:
    195                     return Unknown;
    196             }
     189            switch ( sa.ss_family ) {
     190                case AF_INET:
     191                    return IPv4;
     192                case AF_INET6:
     193                    return IPv6;
     194                default:
     195                    return Unknown;
     196            }
    197197#else
    198             switch ( sa.sin_family ) {
    199                 case AF_INET:
    200                     return IPv4;
    201                 default:
    202                     return Unknown;
    203             }
     198            switch ( sa.sin_family ) {
     199                case AF_INET:
     200                    return IPv4;
     201                default:
     202                    return Unknown;
     203            }
    204204#endif
    205         }
     205        }
    206206    }
    207207    return Unknown;
    208208}
    int MSocketDevice::createNewSocket( ) 
    213213    SOCKET s;
    214214    // Support IPv6 for Winsock v2.0++
    215215    if ( initialized >= 0x20 && protocol() == IPv6 ) {
    216         s = ::socket( AF_INET6, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );
     216        s = ::socket( AF_INET6, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );
    217217    } else {
    218         s = ::socket( AF_INET, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );
     218        s = ::socket( AF_INET, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );
    219219    }
    220220#else
    221221    SOCKET s = ::socket( AF_INET, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );
    222222#endif
    223223    if ( s == INVALID_SOCKET ) {
    224         switch( WSAGetLastError() ) {
    225             case WSANOTINITIALISED:
    226                 e = Impossible;
    227                 break;
    228             case WSAENETDOWN:
    229                 // ### what to use here?
    230                 e = NetworkFailure;
    231                 //e = Inaccessible;
    232                 break;
    233             case WSAEMFILE:
    234                 e = NoFiles; // special case for this
    235                 break;
    236             case WSAEINPROGRESS:
    237             case WSAENOBUFS:
    238                 e = NoResources;
    239                 break;
    240             case WSAEAFNOSUPPORT:
    241             case WSAEPROTOTYPE:
    242             case WSAEPROTONOSUPPORT:
    243             case WSAESOCKTNOSUPPORT:
    244                 e = InternalError;
    245                 break;
    246             default:
    247                 e = UnknownError;
    248                 break;
    249         }
     224        switch( WSAGetLastError() ) {
     225            case WSANOTINITIALISED:
     226                e = Impossible;
     227                break;
     228            case WSAENETDOWN:
     229                // ### what to use here?
     230                e = NetworkFailure;
     231                //e = Inaccessible;
     232                break;
     233            case WSAEMFILE:
     234                e = NoFiles; // special case for this
     235                break;
     236            case WSAEINPROGRESS:
     237            case WSAENOBUFS:
     238                e = NoResources;
     239                break;
     240            case WSAEAFNOSUPPORT:
     241            case WSAEPROTOTYPE:
     242            case WSAEPROTONOSUPPORT:
     243            case WSAESOCKTNOSUPPORT:
     244                e = InternalError;
     245                break;
     246            default:
     247                e = UnknownError;
     248                break;
     249        }
    250250    } else {
    251         return s;
     251        return s;
    252252    }
    253253    return -1;
    254254}
    int MSocketDevice::createNewSocket( ) 
    257257void MSocketDevice::close()
    258258{
    259259    if ( fd == -1 || !isOpen() )                // already closed
    260         return;
     260        return;
    261261    setOpenMode(NotOpen);
    262262    ::closesocket( fd );
    263263#if defined(QSOCKETDEVICE_DEBUG)
    void MSocketDevice::setBlocking( bool enable ) 
    281281    qDebug( "MSocketDevice::setBlocking( %d )", enable );
    282282#endif
    283283    if ( !isValid() )
    284         return;
     284        return;
    285285
    286286    unsigned long dummy = enable ? 0 : 1;
    287287    ioctlsocket( fd, FIONBIO, &dummy );
    void MSocketDevice::setBlocking( bool enable ) 
    291291int MSocketDevice::option( Option opt ) const
    292292{
    293293    if ( !isValid() )
    294         return -1;
     294        return -1;
    295295    int n = -1;
    296296    int v = -1;
    297297    switch ( opt ) {
    298         case Broadcast:
    299             n = SO_BROADCAST;
    300             break;
    301         case ReceiveBuffer:
    302             n = SO_RCVBUF;
    303             break;
    304         case ReuseAddress:
    305             n = SO_REUSEADDR;
    306             break;
    307         case SendBuffer:
    308             n = SO_SNDBUF;
    309             break;
     298        case Broadcast:
     299            n = SO_BROADCAST;
     300            break;
     301        case ReceiveBuffer:
     302            n = SO_RCVBUF;
     303            break;
     304        case ReuseAddress:
     305            n = SO_REUSEADDR;
     306            break;
     307        case SendBuffer:
     308            n = SO_SNDBUF;
     309            break;
    310310    }
    311311    if ( n != -1 ) {
    312         SOCKLEN_T len = sizeof(v);
    313         int r = ::getsockopt( fd, SOL_SOCKET, n, (char*)&v, &len );
    314         if ( r != SOCKET_ERROR )
    315             return v;
    316         if ( !e ) {
     312        SOCKLEN_T len = sizeof(v);
     313        int r = ::getsockopt( fd, SOL_SOCKET, n, (char*)&v, &len );
     314        if ( r != SOCKET_ERROR )
     315            return v;
     316        if ( !e ) {
    317317            MSocketDevice *that = (MSocketDevice*)this; // mutable function
    318             switch( WSAGetLastError() ) {
    319                 case WSANOTINITIALISED:
    320                     that->e = Impossible;
    321                     break;
    322                 case WSAENETDOWN:
    323                     that->e = NetworkFailure;
    324                     break;
    325                 case WSAEFAULT:
    326                 case WSAEINVAL:
    327                 case WSAENOPROTOOPT:
    328                     that->e = InternalError;
    329                     break;
    330                 case WSAEINPROGRESS:
    331                     that->e = NoResources;
    332                     break;
    333                 case WSAENOTSOCK:
    334                     that->e = Impossible;
    335                     break;
    336                 default:
    337                     that->e = UnknownError;
    338                     break;
    339             }
    340         }
    341         return -1;
     318            switch( WSAGetLastError() ) {
     319                case WSANOTINITIALISED:
     320                    that->e = Impossible;
     321                    break;
     322                case WSAENETDOWN:
     323                    that->e = NetworkFailure;
     324                    break;
     325                case WSAEFAULT:
     326                case WSAEINVAL:
     327                case WSAENOPROTOOPT:
     328                    that->e = InternalError;
     329                    break;
     330                case WSAEINPROGRESS:
     331                    that->e = NoResources;
     332                    break;
     333                case WSAENOTSOCK:
     334                    that->e = Impossible;
     335                    break;
     336                default:
     337                    that->e = UnknownError;
     338                    break;
     339            }
     340        }
     341        return -1;
    342342    }
    343343    return v;
    344344}
    int MSocketDevice::option( Option opt ) const 
    347347void MSocketDevice::setOption( Option opt, int v )
    348348{
    349349    if ( !isValid() )
    350         return;
     350        return;
    351351    int n = -1; // for really, really bad compilers
    352352    switch ( opt ) {
    353         case Broadcast:
    354             n = SO_BROADCAST;
    355             break;
    356         case ReceiveBuffer:
    357             n = SO_RCVBUF;
    358             break;
    359         case ReuseAddress:
    360             n = SO_REUSEADDR;
    361             break;
    362         case SendBuffer:
    363             n = SO_SNDBUF;
    364             break;
    365         default:
    366             return;
     353        case Broadcast:
     354            n = SO_BROADCAST;
     355            break;
     356        case ReceiveBuffer:
     357            n = SO_RCVBUF;
     358            break;
     359        case ReuseAddress:
     360            n = SO_REUSEADDR;
     361            break;
     362        case SendBuffer:
     363            n = SO_SNDBUF;
     364            break;
     365        default:
     366            return;
    367367    }
    368368    int r = ::setsockopt( fd, SOL_SOCKET, n, (char*)&v, sizeof(v) );
    369369    if ( r == SOCKET_ERROR && e == NoError ) {
    370         switch( WSAGetLastError() ) {
    371             case WSANOTINITIALISED:
    372                 e = Impossible;
    373                 break;
    374             case WSAENETDOWN:
    375                 e = NetworkFailure;
    376                 break;
    377             case WSAEFAULT:
    378             case WSAEINVAL:
    379             case WSAENOPROTOOPT:
    380                 e = InternalError;
    381                 break;
    382             case WSAEINPROGRESS:
    383                 e = NoResources;
    384                 break;
    385             case WSAENETRESET:
    386             case WSAENOTCONN:
    387                 e =  Impossible; // ### ?
    388                 break;
    389             case WSAENOTSOCK:
    390                 e = Impossible;
    391                 break;
    392             default:
    393                 e = UnknownError;
    394                 break;
    395         }
     370        switch( WSAGetLastError() ) {
     371            case WSANOTINITIALISED:
     372                e = Impossible;
     373                break;
     374            case WSAENETDOWN:
     375                e = NetworkFailure;
     376                break;
     377            case WSAEFAULT:
     378            case WSAEINVAL:
     379            case WSAENOPROTOOPT:
     380                e = InternalError;
     381                break;
     382            case WSAEINPROGRESS:
     383                e = NoResources;
     384                break;
     385            case WSAENETRESET:
     386            case WSAENOTCONN:
     387                e =  Impossible; // ### ?
     388                break;
     389            case WSAENOTSOCK:
     390                e = Impossible;
     391                break;
     392            default:
     393                e = UnknownError;
     394                break;
     395        }
    396396    }
    397397}
    398398
    void MSocketDevice::setOption( Option opt, int v ) 
    400400bool MSocketDevice::connect( const QHostAddress &addr, quint16 port )
    401401{
    402402    if ( !isValid() )
    403         return false;
     403        return false;
    404404
    405405    pa = addr;
    406406    pp = port;
    bool MSocketDevice::connect( const QHostAddress &addr, quint16 port ) 
    414414
    415415    if ( initialized >= 0x20 && addr.protocol() == QAbstractSocket::IPv6Protocol ) {
    416416        memset(&a6, 0, sizeof(a6));
    417         a6.sin6_family = AF_INET6;
    418         a6.sin6_port = htons( port );
    419         Q_IPV6ADDR ip6 = addr.toIPv6Address();
    420         memcpy( &a6.sin6_addr.qt_s6_addr, &ip6, sizeof(ip6) );
     417        a6.sin6_family = AF_INET6;
     418        a6.sin6_port = htons( port );
     419        Q_IPV6ADDR ip6 = addr.toIPv6Address();
     420        memcpy( &a6.sin6_addr.qt_s6_addr, &ip6, sizeof(ip6) );
    421421
    422         aalen = sizeof( a6 );
    423         aa = (struct sockaddr *)&a6;
     422        aalen = sizeof( a6 );
     423        aa = (struct sockaddr *)&a6;
    424424    } else
    425425#endif
    426426    if ( addr.protocol() == QAbstractSocket::IPv4Protocol ) {
    427         memset(&a4, 0, sizeof(a4));
    428         a4.sin_family = AF_INET;
    429         a4.sin_port = htons(port);
    430         a4.sin_addr.s_addr = htonl(addr.toIPv4Address());
     427        memset(&a4, 0, sizeof(a4));
     428        a4.sin_family = AF_INET;
     429        a4.sin_port = htons(port);
     430        a4.sin_addr.s_addr = htonl(addr.toIPv4Address());
    431431
    432         aalen = sizeof(a4);
    433         aa = (struct sockaddr *)&a4;
     432        aalen = sizeof(a4);
     433        aa = (struct sockaddr *)&a4;
    434434    } else {
    435         e = Impossible;
    436         return false;
     435        e = Impossible;
     436        return false;
    437437    }
    438438
    439439    int r = ::connect( fd, aa, aalen );
    440440
    441441    if ( r == SOCKET_ERROR )
    442442    {
    443         switch( WSAGetLastError() ) {
    444             case WSANOTINITIALISED:
    445                 e = Impossible;
    446                 break;
    447             case WSAENETDOWN:
    448                 e = NetworkFailure;
    449                 break;
    450             case WSAEADDRINUSE:
    451             case WSAEINPROGRESS:
    452             case WSAENOBUFS:
    453                 e = NoResources;
    454                 break;
    455             case WSAEINTR:
    456                 e = UnknownError; // ### ?
    457                 break;
    458             case WSAEALREADY:
    459                 // ### ?
    460                 break;
    461             case WSAEADDRNOTAVAIL:
    462                 e = ConnectionRefused; // ### ?
    463                 break;
    464             case WSAEAFNOSUPPORT:
    465             case WSAEFAULT:
    466                 e = InternalError;
    467                 break;
    468             case WSAEINVAL:
    469                 break;
    470             case WSAECONNREFUSED:
    471                 e = ConnectionRefused;
    472                 break;
    473             case WSAEISCONN:
    474                 goto successful;
    475             case WSAENETUNREACH:
    476             case WSAETIMEDOUT:
    477                 e = NetworkFailure;
    478                 break;
    479             case WSAENOTSOCK:
    480                 e = Impossible;
    481                 break;
    482             case WSAEWOULDBLOCK:
    483                 break;
    484             case WSAEACCES:
    485                 e = Inaccessible;
    486                 break;
    487             case 10107:
    488                 // Workaround for a problem with the WinSock Proxy Server. See
    489                 // also support/arc-12/25557 for details on the problem.
    490                 goto successful;
    491             default:
    492                 e = UnknownError;
    493                 break;
    494         }
    495         return false;
     443        switch( WSAGetLastError() ) {
     444            case WSANOTINITIALISED:
     445                e = Impossible;
     446                break;
     447            case WSAENETDOWN:
     448                e = NetworkFailure;
     449                break;
     450            case WSAEADDRINUSE:
     451            case WSAEINPROGRESS:
     452            case WSAENOBUFS:
     453                e = NoResources;
     454                break;
     455            case WSAEINTR:
     456                e = UnknownError; // ### ?
     457                break;
     458            case WSAEALREADY:
     459                // ### ?
     460                break;
     461            case WSAEADDRNOTAVAIL:
     462                e = ConnectionRefused; // ### ?
     463                break;
     464            case WSAEAFNOSUPPORT:
     465            case WSAEFAULT:
     466                e = InternalError;
     467                break;
     468            case WSAEINVAL:
     469                break;
     470            case WSAECONNREFUSED:
     471                e = ConnectionRefused;
     472                break;
     473            case WSAEISCONN:
     474                goto successful;
     475            case WSAENETUNREACH:
     476            case WSAETIMEDOUT:
     477                e = NetworkFailure;
     478                break;
     479            case WSAENOTSOCK:
     480                e = Impossible;
     481                break;
     482            case WSAEWOULDBLOCK:
     483                break;
     484            case WSAEACCES:
     485                e = Inaccessible;
     486                break;
     487            case 10107:
     488                // Workaround for a problem with the WinSock Proxy Server. See
     489                // also support/arc-12/25557 for details on the problem.
     490                goto successful;
     491            default:
     492                e = UnknownError;
     493                break;
     494        }
     495        return false;
    496496    }
    497497successful:
    498498    fetchConnectionParameters();
    successful: 
    503503bool MSocketDevice::bind( const QHostAddress &address, quint16 port )
    504504{
    505505    if ( !isValid() )
    506         return false;
     506        return false;
    507507    int r;
    508508    struct sockaddr_in a4;
    509509#if !defined(QT_NO_IPV6)
    510510    qt_sockaddr_in6 a6;
    511511
    512512    if ( initialized >= 0x20 && address.protocol() == QAbstractSocket::IPv6Protocol ) {
    513         memset( &a6, 0, sizeof(a6) );
    514         a6.sin6_family = AF_INET6;
    515         a6.sin6_port = htons( port );
    516         Q_IPV6ADDR tmp = address.toIPv6Address();
    517         memcpy( &a6.sin6_addr.qt_s6_addr, &tmp, sizeof(tmp) );
     513        memset( &a6, 0, sizeof(a6) );
     514        a6.sin6_family = AF_INET6;
     515        a6.sin6_port = htons( port );
     516        Q_IPV6ADDR tmp = address.toIPv6Address();
     517        memcpy( &a6.sin6_addr.qt_s6_addr, &tmp, sizeof(tmp) );
    518518
    519         r = ::bind( fd, (struct sockaddr *)&a6, sizeof(struct qt_sockaddr_storage) );
     519        r = ::bind( fd, (struct sockaddr *)&a6, sizeof(struct qt_sockaddr_storage) );
    520520    } else
    521521#endif
    522522    if ( address.protocol() == QAbstractSocket::IPv4Protocol ) {
    523         memset( &a4, 0, sizeof(a4) );
    524         a4.sin_family = AF_INET;
    525         a4.sin_port = htons( port );
    526         a4.sin_addr.s_addr = htonl( address.toIPv4Address() );
     523        memset( &a4, 0, sizeof(a4) );
     524        a4.sin_family = AF_INET;
     525        a4.sin_port = htons( port );
     526        a4.sin_addr.s_addr = htonl( address.toIPv4Address() );
    527527
    528         r = ::bind( fd, (struct sockaddr*)&a4, sizeof(struct sockaddr_in) );
     528        r = ::bind( fd, (struct sockaddr*)&a4, sizeof(struct sockaddr_in) );
    529529    } else {
    530         e = Impossible;
    531         return false;
     530        e = Impossible;
     531        return false;
    532532    }
    533533
    534534    if ( r == SOCKET_ERROR ) {
    535         switch( WSAGetLastError() ) {
    536             case WSANOTINITIALISED:
    537                 e = Impossible;
    538                 break;
    539             case WSAENETDOWN:
    540                 e = NetworkFailure;
    541                 break;
    542             case WSAEACCES:
    543                 e = Inaccessible;
    544                 break;
    545             case WSAEADDRNOTAVAIL:
    546                 e = Inaccessible;
    547                 break;
    548             case WSAEFAULT:
    549                 e = InternalError;
    550                 break;
    551             case WSAEINPROGRESS:
    552             case WSAENOBUFS:
    553                 e = NoResources;
    554                 break;
    555             case WSAEADDRINUSE:
    556             case WSAEINVAL:
    557                 e = AlreadyBound;
    558                 break;
    559             case WSAENOTSOCK:
    560                 e = Impossible;
    561                 break;
    562             default:
    563                 e = UnknownError;
    564                 break;
    565         }
    566         return false;
     535        switch( WSAGetLastError() ) {
     536            case WSANOTINITIALISED:
     537                e = Impossible;
     538                break;
     539            case WSAENETDOWN:
     540                e = NetworkFailure;
     541                break;
     542            case WSAEACCES:
     543                e = Inaccessible;
     544                break;
     545            case WSAEADDRNOTAVAIL:
     546                e = Inaccessible;
     547                break;
     548            case WSAEFAULT:
     549                e = InternalError;
     550                break;
     551            case WSAEINPROGRESS:
     552            case WSAENOBUFS:
     553                e = NoResources;
     554                break;
     555            case WSAEADDRINUSE:
     556            case WSAEINVAL:
     557                e = AlreadyBound;
     558                break;
     559            case WSAENOTSOCK:
     560                e = Impossible;
     561                break;
     562            default:
     563                e = UnknownError;
     564                break;
     565        }
     566        return false;
    567567    }
    568568    fetchConnectionParameters();
    569569    return true;
    bool MSocketDevice::bind( const QHostAddress &address, quint16 port ) 
    573573bool MSocketDevice::listen( int backlog )
    574574{
    575575    if ( !isValid() )
    576         return false;
     576        return false;
    577577    if ( ::listen( fd, backlog ) >= 0 )
    578         return true;
     578        return true;
    579579    if ( !e )
    580         e = Impossible;
     580        e = Impossible;
    581581    return false;
    582582}
    583583
    bool MSocketDevice::listen( int backlog ) 
    585585int MSocketDevice::accept()
    586586{
    587587    if ( !isValid() )
    588         return -1;
     588        return -1;
    589589#if !defined(QT_NO_IPV6)
    590590    struct qt_sockaddr_storage a;
    591591#else
    int MSocketDevice::accept() 
    599599        // we'll blithely throw away the stuff accept() wrote to a
    600600        done = true;
    601601        if ( s == INVALID_SOCKET && e == NoError ) {
    602             switch( WSAGetLastError() ) {
     602            switch( WSAGetLastError() ) {
    603603                case WSAEINTR:
    604604                    done = false;
    605605                    break;
    606                 case WSANOTINITIALISED:
    607                     e = Impossible;
    608                     break;
    609                 case WSAENETDOWN:
    610                 case WSAEOPNOTSUPP:
    611                     // in all these cases, an error happened during connection
    612                     // setup.  we're not interested in what happened, so we
    613                     // just treat it like the client-closed-quickly case.
    614                     break;
    615                 case WSAEFAULT:
    616                     e = InternalError;
    617                     break;
    618                 case WSAEMFILE:
    619                 case WSAEINPROGRESS:
    620                 case WSAENOBUFS:
    621                     e = NoResources;
    622                     break;
    623                 case WSAEINVAL:
    624                 case WSAENOTSOCK:
    625                     e = Impossible;
    626                     break;
    627                 case WSAEWOULDBLOCK:
    628                     break;
    629                 default:
    630                     e = UnknownError;
    631                     break;
     606                case WSANOTINITIALISED:
     607                    e = Impossible;
     608                    break;
     609                case WSAENETDOWN:
     610                case WSAEOPNOTSUPP:
     611                    // in all these cases, an error happened during connection
     612                    // setup.  we're not interested in what happened, so we
     613                    // just treat it like the client-closed-quickly case.
     614                    break;
     615                case WSAEFAULT:
     616                    e = InternalError;
     617                    break;
     618                case WSAEMFILE:
     619                case WSAEINPROGRESS:
     620                case WSAENOBUFS:
     621                    e = NoResources;
     622                    break;
     623                case WSAEINVAL:
     624                case WSAENOTSOCK:
     625                    e = Impossible;
     626                    break;
     627                case WSAEWOULDBLOCK:
     628                    break;
     629                default:
     630                    e = UnknownError;
     631                    break;
    632632            }
    633         }
     633        }
    634634    } while (!done);
    635635    return s;
    636636}
    int MSocketDevice::accept() 
    639639qint64 MSocketDevice::bytesAvailable() const
    640640{
    641641    if ( !isValid() )
    642         return -1;
     642        return -1;
    643643    ulong nbytes = 0;
    644644    if ( ::ioctlsocket(fd, FIONREAD, &nbytes) < 0 )
    645         return -1;
     645        return -1;
    646646
    647647     // ioctlsocket sometimes reports 1 byte available for datagrams
    648648     // while the following recvfrom returns -1 and claims connection
    qint64 MSocketDevice::bytesAvailable() const 
    662662qint64 MSocketDevice::waitForMore( int msecs, bool *timeout ) const
    663663{
    664664    if ( !isValid() )
    665         return -1;
     665        return -1;
    666666
    667667    fd_set fds;
    668668    memset(&fds, 0, sizeof(fd_set));
    qint64 MSocketDevice::waitForMore( int msecs, bool *timeout ) const 
    677677    int rv = select( fd+1, &fds, 0, 0, msecs < 0 ? 0 : &tv );
    678678
    679679    if ( rv < 0 )
    680         return -1;
     680        return -1;
    681681
    682682    if ( timeout ) {
    683         if ( rv == 0 )
    684             *timeout = true;
    685         else
    686             *timeout = false;
     683        if ( rv == 0 )
     684            *timeout = true;
     685        else
     686            *timeout = false;
    687687    }
    688688
    689689    return bytesAvailable();
    qint64 MSocketDevice::readData( char *data, qint64 maxlen ) 
    694694{
    695695#if defined(QT_CHECK_NULL)
    696696    if ( data == 0 && maxlen != 0 ) {
    697         qWarning( "MSocketDevice::readBlock: Null pointer error" );
     697        qWarning( "MSocketDevice::readBlock: Null pointer error" );
    698698    }
    699699#endif
    700700#if defined(QT_CHECK_STATE)
    701701    if ( !isValid() ) {
    702         qWarning( "MSocketDevice::readBlock: Invalid socket" );
    703         return -1;
     702        qWarning( "MSocketDevice::readBlock: Invalid socket" );
     703        return -1;
    704704    }
    705705    if ( !isOpen() ) {
    706         qWarning( "MSocketDevice::readBlock: Device is not open" );
    707         return -1;
     706        qWarning( "MSocketDevice::readBlock: Device is not open" );
     707        return -1;
    708708    }
    709709    if ( !isReadable() ) {
    710         qWarning( "MSocketDevice::readBlock: Read operation not permitted" );
    711         return -1;
     710        qWarning( "MSocketDevice::readBlock: Read operation not permitted" );
     711        return -1;
    712712    }
    713713#endif
    714714    qint64 r = 0;
    715715    if ( t == Datagram ) {
    716716#if !defined(QT_NO_IPV6)
    717         // With IPv6 support, we must be prepared to receive both IPv4
    718         // and IPv6 packets. The generic SOCKADDR_STORAGE (struct
    719         // sockaddr_storage on unix) replaces struct sockaddr.
    720         struct qt_sockaddr_storage a;
     717        // With IPv6 support, we must be prepared to receive both IPv4
     718        // and IPv6 packets. The generic SOCKADDR_STORAGE (struct
     719        // sockaddr_storage on unix) replaces struct sockaddr.
     720        struct qt_sockaddr_storage a;
    721721#else
    722         struct sockaddr_in a;
     722        struct sockaddr_in a;
    723723#endif
    724         memset( &a, 0, sizeof(a) );
    725         SOCKLEN_T sz;
    726         sz = sizeof( a );
    727         r = ::recvfrom( fd, data, maxlen, 0, (struct sockaddr *)&a, &sz );
    728         qt_socket_getportaddr( (struct sockaddr *)(&a), &pp, &pa );
     724        memset( &a, 0, sizeof(a) );
     725        SOCKLEN_T sz;
     726        sz = sizeof( a );
     727        r = ::recvfrom( fd, data, maxlen, 0, (struct sockaddr *)&a, &sz );
     728        qt_socket_getportaddr( (struct sockaddr *)(&a), &pp, &pa );
    729729    } else {
    730         r = ::recv( fd, data, maxlen, 0 );
     730        r = ::recv( fd, data, maxlen, 0 );
    731731    }
    732732    if ( r == 0 && t == Stream && maxlen > 0 ) {
    733733        if ( WSAGetLastError() != WSAEWOULDBLOCK ) {
    qint64 MSocketDevice::readData( char *data, qint64 maxlen ) 
    735735            close();
    736736        }
    737737    } else if ( r == SOCKET_ERROR && e == NoError ) {
    738         switch( WSAGetLastError() ) {
    739             case WSANOTINITIALISED:
    740                 e = Impossible;
    741                 break;
    742             case WSAECONNABORTED:
    743                 close();
    744                 r = 0;
    745                 break;
    746             case WSAETIMEDOUT:
    747             case WSAECONNRESET:
    748                 /*
    749                 From msdn doc:
    750                 On a UDP datagram socket this error would indicate that a previous
    751                 send operation resulted in an ICMP "Port Unreachable" message.
    752 
    753                 So we should not close this socket just because one sendto failed.
    754                 */
    755                 if ( t != Datagram )
    756                     close(); // connection closed
    757                 r = 0;
    758                 break;
    759             case WSAENETDOWN:
    760             case WSAENETRESET:
    761                 e = NetworkFailure;
    762                 break;
    763             case WSAEFAULT:
    764             case WSAENOTCONN:
    765             case WSAESHUTDOWN:
    766             case WSAEINVAL:
    767                 e = Impossible;
    768                 break;
    769             case WSAEINTR:
    770                 // ### ?
    771                 r = 0;
    772                 break;
    773             case WSAEINPROGRESS:
    774                 e = NoResources;
    775                 break;
    776             case WSAENOTSOCK:
    777                 e = Impossible;
    778                 break;
    779             case WSAEOPNOTSUPP:
    780                 e = InternalError; // ### ?
    781                 break;
    782             case WSAEWOULDBLOCK:
    783                 break;
    784             case WSAEMSGSIZE:
    785                 e = NoResources; // ### ?
    786                 break;
    787             case WSAEISCONN:
    788                 // ### ?
    789                 r = 0;
    790                 break;
    791             default:
    792                 e = UnknownError;
    793                 break;
    794         }
     738        switch( WSAGetLastError() ) {
     739            case WSANOTINITIALISED:
     740                e = Impossible;
     741                break;
     742            case WSAECONNABORTED:
     743                    close();
     744                r = 0;
     745                break;
     746            case WSAETIMEDOUT:
     747            case WSAECONNRESET:
     748                /*
     749                From msdn doc:
     750                On a UDP datagram socket this error would indicate that a previous
     751                send operation resulted in an ICMP "Port Unreachable" message.
     752
     753                So we should not close this socket just because one sendto failed.
     754                */
     755                if ( t != Datagram )
     756                    close(); // connection closed
     757                r = 0;
     758                break;
     759            case WSAENETDOWN:
     760            case WSAENETRESET:
     761                e = NetworkFailure;
     762                break;
     763            case WSAEFAULT:
     764            case WSAENOTCONN:
     765            case WSAESHUTDOWN:
     766            case WSAEINVAL:
     767                e = Impossible;
     768                break;
     769            case WSAEINTR:
     770                // ### ?
     771                r = 0;
     772                break;
     773            case WSAEINPROGRESS:
     774                e = NoResources;
     775                break;
     776            case WSAENOTSOCK:
     777                e = Impossible;
     778                break;
     779            case WSAEOPNOTSUPP:
     780                e = InternalError; // ### ?
     781                break;
     782            case WSAEWOULDBLOCK:
     783                break;
     784            case WSAEMSGSIZE:
     785                e = NoResources; // ### ?
     786                break;
     787            case WSAEISCONN:
     788                // ### ?
     789                r = 0;
     790                break;
     791            default:
     792                e = UnknownError;
     793                break;
     794        }
    795795    }
    796796    return r;
    797797}
    qint64 MSocketDevice::writeData( const char *data, qint64 len ) 
    801801{
    802802    if ( data == 0 && len != 0 ) {
    803803#if defined(QT_CHECK_NULL) || defined(QSOCKETDEVICE_DEBUG)
    804         qWarning( "MSocketDevice::writeBlock: Null pointer error" );
     804        qWarning( "MSocketDevice::writeBlock: Null pointer error" );
    805805#endif
    806         return -1;
     806        return -1;
    807807    }
    808808    if ( !isValid() ) {
    809809#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    810         qWarning( "MSocketDevice::writeBlock: Invalid socket" );
     810        qWarning( "MSocketDevice::writeBlock: Invalid socket" );
    811811#endif
    812         return -1;
     812        return -1;
    813813    }
    814814    if ( !isOpen() ) {
    815815#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    816         qWarning( "MSocketDevice::writeBlock: Device is not open" );
     816        qWarning( "MSocketDevice::writeBlock: Device is not open" );
    817817#endif
    818         return -1;
     818        return -1;
    819819    }
    820820    if ( !isWritable() ) {
    821821#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    822         qWarning( "MSocketDevice::writeBlock: Write operation not permitted" );
     822        qWarning( "MSocketDevice::writeBlock: Write operation not permitted" );
    823823#endif
    824         return -1;
     824        return -1;
    825825    }
    826826    bool done = false;
    827827    qint64 r = 0;
    828828    while ( !done ) {
    829         // Don't write more than 64K (see Knowledge Base Q201213).
    830         r = ::send( fd, data, ( len>64*1024 ? 64*1024 : len ), 0 );
    831         done = true;
    832         if ( r == SOCKET_ERROR && e == NoError ) {//&& errno != WSAEAGAIN ) {
    833             switch( WSAGetLastError() ) {
    834                 case WSANOTINITIALISED:
    835                     e = Impossible;
    836                     break;
    837                 case WSAENETDOWN:
    838                 case WSAEACCES:
    839                 case WSAENETRESET:
    840                 case WSAESHUTDOWN:
    841                 case WSAEHOSTUNREACH:
    842                     e = NetworkFailure;
    843                     break;
    844                 case WSAECONNABORTED:
    845                 case WSAECONNRESET:
    846                     // connection closed
    847                     close();
    848                     r = 0;
    849                     break;
    850                 case WSAEINTR:
    851                     done = false;
    852                     break;
    853                 case WSAEINPROGRESS:
    854                     e = NoResources;
    855                     // ### perhaps try it later?
    856                     break;
    857                 case WSAEFAULT:
    858                 case WSAEOPNOTSUPP:
    859                     e = InternalError;
    860                     break;
    861                 case WSAENOBUFS:
    862                     // ### try later?
    863                     break;
    864                 case WSAEMSGSIZE:
    865                     e = NoResources;
    866                     break;
    867                 case WSAENOTCONN:
    868                 case WSAENOTSOCK:
    869                 case WSAEINVAL:
    870                     e = Impossible;
    871                     break;
    872                 case WSAEWOULDBLOCK:
    873                     r = 0;
    874                     break;
    875                 default:
    876                     e = UnknownError;
    877                     break;
    878             }
    879         }
     829        // Don't write more than 64K (see Knowledge Base Q201213).
     830        r = ::send( fd, data, ( len>64*1024 ? 64*1024 : len ), 0 );
     831        done = true;
     832        if ( r == SOCKET_ERROR && e == NoError ) {//&& errno != WSAEAGAIN ) {
     833            switch( WSAGetLastError() ) {
     834                case WSANOTINITIALISED:
     835                    e = Impossible;
     836                    break;
     837                case WSAENETDOWN:
     838                case WSAEACCES:
     839                case WSAENETRESET:
     840                case WSAESHUTDOWN:
     841                case WSAEHOSTUNREACH:
     842                    e = NetworkFailure;
     843                    break;
     844                case WSAECONNABORTED:
     845                case WSAECONNRESET:
     846                    // connection closed
     847                    close();
     848                    r = 0;
     849                    break;
     850                case WSAEINTR:
     851                    done = false;
     852                    break;
     853                case WSAEINPROGRESS:
     854                    e = NoResources;
     855                    // ### perhaps try it later?
     856                    break;
     857                case WSAEFAULT:
     858                case WSAEOPNOTSUPP:
     859                    e = InternalError;
     860                    break;
     861                case WSAENOBUFS:
     862                    // ### try later?
     863                    break;
     864                case WSAEMSGSIZE:
     865                    e = NoResources;
     866                    break;
     867                case WSAENOTCONN:
     868                case WSAENOTSOCK:
     869                case WSAEINVAL:
     870                    e = Impossible;
     871                    break;
     872                case WSAEWOULDBLOCK:
     873                    r = 0;
     874                    break;
     875                default:
     876                    e = UnknownError;
     877                    break;
     878            }
     879        }
    880880    }
    881881    return r;
    882882}
    883883
    884884
    885885qint64 MSocketDevice::writeBlock( const char * data, quint64 len,
    886                                const QHostAddress & host, quint16 port )
     886                                  const QHostAddress & host, quint16 port )
    887887{
    888888    if ( t != Datagram ) {
    889889#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    890         qWarning( "MSocketDevice::sendBlock: Not datagram" );
     890        qWarning( "MSocketDevice::sendBlock: Not datagram" );
    891891#endif
    892         return -1; // for now - later we can do t/tcp
     892        return -1; // for now - later we can do t/tcp
    893893    }
    894894
    895895    if ( data == 0 && len != 0 ) {
    896896#if defined(QT_CHECK_NULL) || defined(QSOCKETDEVICE_DEBUG)
    897         qWarning( "MSocketDevice::sendBlock: Null pointer error" );
     897        qWarning( "MSocketDevice::sendBlock: Null pointer error" );
    898898#endif
    899         return -1;
     899        return -1;
    900900    }
    901901    if ( !isValid() ) {
    902902#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    903         qWarning( "MSocketDevice::sendBlock: Invalid socket" );
     903        qWarning( "MSocketDevice::sendBlock: Invalid socket" );
    904904#endif
    905         return -1;
     905        return -1;
    906906    }
    907907    if ( !isOpen() ) {
    908908#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    909         qWarning( "MSocketDevice::sendBlock: Device is not open" );
     909        qWarning( "MSocketDevice::sendBlock: Device is not open" );
    910910#endif
    911         return -1;
     911        return -1;
    912912    }
    913913    if ( !isWritable() ) {
    914914#if defined(QT_CHECK_STATE) || defined(QSOCKETDEVICE_DEBUG)
    915         qWarning( "MSocketDevice::sendBlock: Write operation not permitted" );
     915        qWarning( "MSocketDevice::sendBlock: Write operation not permitted" );
    916916#endif
    917         return -1;
     917        return -1;
    918918    }
    919919    struct sockaddr_in a4;
    920920    struct sockaddr *aa;
    qint64 MSocketDevice::writeBlock( const char * data, quint64 len, 
    922922#if !defined(QT_NO_IPV6)
    923923    qt_sockaddr_in6 a6;
    924924    if ( initialized >= 0x20 && host.protocol() == QAbstractSocket::IPv6Protocol ) {
    925         memset( &a6, 0, sizeof(a6) );
    926         a6.sin6_family = AF_INET6;
    927         a6.sin6_port = htons( port );
    928 
    929         Q_IPV6ADDR tmp = host.toIPv6Address();
    930         memcpy( &a6.sin6_addr.qt_s6_addr, &tmp, sizeof(tmp) );
    931         slen = sizeof( a6 );
    932         aa = (struct sockaddr *)&a6;
     925        memset( &a6, 0, sizeof(a6) );
     926        a6.sin6_family = AF_INET6;
     927        a6.sin6_port = htons( port );
     928
     929        Q_IPV6ADDR tmp = host.toIPv6Address();
     930        memcpy( &a6.sin6_addr.qt_s6_addr, &tmp, sizeof(tmp) );
     931        slen = sizeof( a6 );
     932        aa = (struct sockaddr *)&a6;
    933933    } else
    934934#endif
    935935    if ( host.protocol() == QAbstractSocket::IPv4Protocol ) {
    936936
    937         memset( &a4, 0, sizeof(a4) );
    938         a4.sin_family = AF_INET;
    939         a4.sin_port = htons( port );
    940         a4.sin_addr.s_addr = htonl( host.toIPv4Address() );
    941         slen = sizeof(a4);
    942         aa = (struct sockaddr *)&a4;
     937        memset( &a4, 0, sizeof(a4) );
     938        a4.sin_family = AF_INET;
     939        a4.sin_port = htons( port );
     940        a4.sin_addr.s_addr = htonl( host.toIPv4Address() );
     941        slen = sizeof(a4);
     942        aa = (struct sockaddr *)&a4;
    943943    } else {
    944         e = Impossible;
    945         return -1;
     944        e = Impossible;
     945        return -1;
    946946    }
    947947
    948948    // we'd use MSG_DONTWAIT + MSG_NOSIGNAL if Stevens were right.
    qint64 MSocketDevice::writeBlock( const char * data, quint64 len, 
    950950    bool done = false;
    951951    qint64 r = 0;
    952952    while ( !done ) {
    953         r = ::sendto( fd, data, len, 0, aa, slen );
    954         done = true;
    955         if ( r == SOCKET_ERROR && e == NoError ) {//&& e != EAGAIN ) {
    956             switch( WSAGetLastError() ) {
    957                 case WSANOTINITIALISED:
    958                     e = Impossible;
    959                     break;
    960                 case WSAENETDOWN:
    961                 case WSAEACCES:
    962                 case WSAENETRESET:
    963                 case WSAESHUTDOWN:
    964                 case WSAEHOSTUNREACH:
    965                 case WSAECONNABORTED:
    966                 case WSAECONNRESET:
    967                 case WSAEADDRNOTAVAIL:
    968                 case WSAENETUNREACH:
    969                 case WSAETIMEDOUT:
    970                     e = NetworkFailure;
    971                     break;
    972                 case WSAEINTR:
    973                     done = false;
    974                     break;
    975                 case WSAEINPROGRESS:
    976                     e = NoResources;
    977                     // ### perhaps try it later?
    978                     break;
    979                 case WSAEFAULT:
    980                 case WSAEOPNOTSUPP:
    981                 case WSAEAFNOSUPPORT:
    982                     e = InternalError;
    983                     break;
    984                 case WSAENOBUFS:
    985                 case WSAEMSGSIZE:
    986                     e = NoResources;
    987                     break;
    988                 case WSAENOTCONN:
    989                 case WSAENOTSOCK:
    990                 case WSAEINVAL:
    991                 case WSAEDESTADDRREQ:
    992                     e = Impossible;
    993                     break;
    994                 case WSAEWOULDBLOCK:
    995                     r = 0;
    996                     break;
    997                 default:
    998                     e = UnknownError;
    999                     break;
    1000             }
    1001         }
     953        r = ::sendto( fd, data, len, 0, aa, slen );
     954        done = true;
     955        if ( r == SOCKET_ERROR && e == NoError ) {//&& e != EAGAIN ) {
     956            switch( WSAGetLastError() ) {
     957                case WSANOTINITIALISED:
     958                    e = Impossible;
     959                    break;
     960                case WSAENETDOWN:
     961                case WSAEACCES:
     962                case WSAENETRESET:
     963                case WSAESHUTDOWN:
     964                case WSAEHOSTUNREACH:
     965                case WSAECONNABORTED:
     966                case WSAECONNRESET:
     967                case WSAEADDRNOTAVAIL:
     968                case WSAENETUNREACH:
     969                case WSAETIMEDOUT:
     970                    e = NetworkFailure;
     971                    break;
     972                case WSAEINTR:
     973                    done = false;
     974                    break;
     975                case WSAEINPROGRESS:
     976                    e = NoResources;
     977                    // ### perhaps try it later?
     978                    break;
     979                case WSAEFAULT:
     980                case WSAEOPNOTSUPP:
     981                case WSAEAFNOSUPPORT:
     982                    e = InternalError;
     983                    break;
     984                case WSAENOBUFS:
     985                case WSAEMSGSIZE:
     986                    e = NoResources;
     987                    break;
     988                case WSAENOTCONN:
     989                case WSAENOTSOCK:
     990                case WSAEINVAL:
     991                case WSAEDESTADDRREQ:
     992                    e = Impossible;
     993                    break;
     994                case WSAEWOULDBLOCK:
     995                    r = 0;
     996                    break;
     997                default:
     998                    e = UnknownError;
     999                    break;
     1000            }
     1001        }
    10021002    }
    10031003    return r;
    10041004}
    qint64 MSocketDevice::writeBlock( const char * data, quint64 len, 
    10071007void MSocketDevice::fetchConnectionParameters()
    10081008{
    10091009    if ( !isValid() ) {
    1010         p = 0;
    1011         a = QHostAddress();
    1012         pp = 0;
    1013         pa = QHostAddress();
    1014         return;
     1010        p = 0;
     1011        a = QHostAddress();
     1012        pp = 0;
     1013        pa = QHostAddress();
     1014        return;
    10151015    }
    10161016#if !defined (QT_NO_IPV6)
    10171017    struct qt_sockaddr_storage sa;
    void MSocketDevice::fetchConnectionParameters() 
    10221022    SOCKLEN_T sz;
    10231023    sz = sizeof( sa );
    10241024    if ( !::getsockname( fd, (struct sockaddr *)(&sa), &sz ) )
    1025         qt_socket_getportaddr( (struct sockaddr *)(&sa), &p, &a );
     1025        qt_socket_getportaddr( (struct sockaddr *)(&sa), &p, &a );
    10261026    pp = 0;
    10271027    pa = QHostAddress();
    10281028}
    void MSocketDevice::fetchPeerConnectionParameters() 
    10411041    SOCKLEN_T sz;
    10421042    sz = sizeof( sa );
    10431043    if ( !::getpeername( fd, (struct sockaddr *)(&sa), &sz ) )
    1044         qt_socket_getportaddr( (struct sockaddr *)(&sa), &pp, &pa );
     1044        qt_socket_getportaddr( (struct sockaddr *)(&sa), &pp, &pa );
    10451045}
    10461046
    10471047quint16 MSocketDevice::peerPort() const
    10481048{
    10491049    if ( pp==0 && isValid() ) {
    1050         MSocketDevice *that = (MSocketDevice*)this; // mutable
    1051         that->fetchPeerConnectionParameters();
     1050        MSocketDevice *that = (MSocketDevice*)this; // mutable
     1051        that->fetchPeerConnectionParameters();
    10521052    }
    10531053    return pp;
    10541054}
    quint16 MSocketDevice::peerPort() const 
    10571057QHostAddress MSocketDevice::peerAddress() const
    10581058{
    10591059    if ( pp==0 && isValid() ) {
    1060         MSocketDevice *that = (MSocketDevice*)this; // mutable
    1061         that->fetchPeerConnectionParameters();
     1060        MSocketDevice *that = (MSocketDevice*)this; // mutable
     1061        that->fetchPeerConnectionParameters();
    10621062    }
    10631063    return pa;
    10641064}
  • mythtv/libs/libmythdb/mythdbcon.cpp

    diff --git a/mythtv/libs/libmythdb/mythdbcon.cpp b/mythtv/libs/libmythdb/mythdbcon.cpp
    index d053367..a06811b 100644
    a b bool MSqlDatabase::OpenDatabase() 
    6161    }
    6262
    6363    bool connected = true;
    64    
     64
    6565    if (!m_db.isOpen())
    6666    {
    6767        DatabaseParams dbparms = GetMythDB()->GetDatabaseParams();
    bool MSqlDatabase::OpenDatabase() 
    8787        if (!connected && dbparms.wolEnabled)
    8888        {
    8989            int trycount = 0;
    90                
     90
    9191            while (!connected && trycount++ < dbparms.wolRetry)
    9292            {
    9393                VERBOSE(VB_GENERAL, QString(
    bool MSqlDatabase::OpenDatabase() 
    9898                sleep(dbparms.wolReconnect);
    9999                connected = m_db.open();
    100100            }
    101    
     101
    102102            if (!connected)
    103103            {
    104104                VERBOSE(VB_IMPORTANT, "WOL failed, unable to connect to database!");
    bool MSqlDatabase::KickDatabase() 
    135135    // mdz, 2003/08/11
    136136
    137137
    138     if (m_lastDBKick.secsTo(QDateTime::currentDateTime()) < 30 && 
     138    if (m_lastDBKick.secsTo(QDateTime::currentDateTime()) < 30 &&
    139139        m_db.isOpen())
    140140    {
    141141        return true;
    MSqlQueryInfo MSqlQuery::SchedCon() 
    381381    if (db)
    382382    {
    383383        qi.db = db;
    384         qi.qsqldb = db->db(); 
     384        qi.qsqldb = db->db();
    385385
    386386        db->KickDatabase();
    387387    }
    MSqlQueryInfo MSqlQuery::DDCon() 
    400400    if (db)
    401401    {
    402402        qi.db = db;
    403         qi.qsqldb = db->db(); 
     403        qi.qsqldb = db->db();
    404404
    405405        db->KickDatabase();
    406     } 
     406    }
    407407
    408408    return qi;
    409409}
    bool MSqlQuery::prepare(const QString& query) 
    452452                .arg(m_testbindings.cap(1)) + query);
    453453        exit(1);
    454454    }
    455     return QSqlQuery::prepare(query); 
     455    return QSqlQuery::prepare(query);
    456456}
    457457
    458458bool MSqlQuery::testDBConnection()
    void MSqlEscapeAsAQuery(QString &query, MSqlBindings &bindings) 
    547547    QVector<Holder> holders;
    548548
    549549    int i = 0;
    550     while ((i = rx.indexIn(q, i)) != -1) 
     550    while ((i = rx.indexIn(q, i)) != -1)
    551551    {
    552552        if (!rx.cap(1).isEmpty())
    553553            holders.append(Holder(rx.cap(0), i));
  • mythtv/libs/libmythdb/mythdbcon.h

    diff --git a/mythtv/libs/libmythdb/mythdbcon.h b/mythtv/libs/libmythdb/mythdbcon.h
    index 0dd6b69..addaae3 100644
    a b MPUBLIC void MSqlEscapeAsAQuery(QString &query, MSqlBindings &bindings); 
    9292 *   Rule #3: Use MSqlQuery for all DB stuff.
    9393 *
    9494 *   MSqlQuery is tied to a connection pool in MythContext. DB connections are
    95  *   automatically set up by creating an MSqlQuery object. Use the helper 
    96  *   functions to create an MSqlQuery object e.g. 
     95 *   automatically set up by creating an MSqlQuery object. Use the helper
     96 *   functions to create an MSqlQuery object e.g.
    9797 *   MSqlQuery query(MSqlQuery::InitCon());
    98  *   The MSqlQuery object gets exclusive access to the connection for its 
    99  *   lifetime. The connection is automatically returned when the MSqlQuery 
     98 *   The MSqlQuery object gets exclusive access to the connection for its
     99 *   lifetime. The connection is automatically returned when the MSqlQuery
    100100 *   object is destroyed.
    101101 *
    102102 *   Note: Due to a bug in some Qt/MySql combinations, QSqlDatabase connections
    103103 *   will crash if closed and reopend - so we never close them and keep them in
    104  *   a pool. 
     104 *   a pool.
    105105 */
    106106class MPUBLIC MSqlQuery : public QSqlQuery
    107107{
    108108  public:
    109     /// \brief Get DB connection from pool 
     109    /// \brief Get DB connection from pool
    110110    MSqlQuery(const MSqlQueryInfo &qi);
    111111    /// \brief Returns conneciton to pool
    112112    ~MSqlQuery();
    class MPUBLIC MSqlQuery : public QSqlQuery 
    132132    void bindValues(MSqlBindings &bindings);
    133133
    134134    /** \brief Return the id of the last inserted row
    135      * 
     135     *
    136136     * Note: Currently, this function is only implemented in Qt4 (in QSqlQuery
    137137     * and QSqlResult), and is implemented here until the switch to Qt4.  Also,
    138138     * the current implementation will only work for a DBMS that supports
    class MPUBLIC MSqlQuery : public QSqlQuery 
    163163    QRegExp m_testbindings;
    164164};
    165165
    166 #endif   
     166#endif
  • mythtv/libs/libmythdb/mythevent.h

    diff --git a/mythtv/libs/libmythdb/mythevent.h b/mythtv/libs/libmythdb/mythevent.h
    index 85df1ea..ee98109 100644
    a b  
    88
    99/** \class MythEvent
    1010    \brief This class is used as a container for messages.
    11    
     11
    1212    Any subclass of this that adds data to the event should override
    13     the clone method. As example, see OutputEvent in output.h. 
     13    the clone method. As example, see OutputEvent in output.h.
    1414 */
    1515class MPUBLIC MythEvent : public QEvent
    1616{
    class MPUBLIC MythEvent : public QEvent 
    4040        extradata.append( lextradata );
    4141    }
    4242
    43    
     43
    4444    virtual ~MythEvent() {}
    4545
    4646    const QString& Message() const { return message; }
    47     const QString& ExtraData(int idx = 0) const { return extradata[idx]; } 
    48     const QStringList& ExtraDataList() const { return extradata; } 
     47    const QString& ExtraData(int idx = 0) const { return extradata[idx]; }
     48    const QStringList& ExtraDataList() const { return extradata; }
    4949    int ExtraDataCount() const { return extradata.size(); }
    5050
    5151    virtual MythEvent* clone() { return new MythEvent(message, extradata); }
  • mythtv/libs/libmythdb/mythobservable.h

    diff --git a/mythtv/libs/libmythdb/mythobservable.h b/mythtv/libs/libmythdb/mythobservable.h
    index 9dfa0f8..c8031c0 100644
    a b class QObject; 
    99
    1010/** \class MythObservable
    1111    \brief Superclass for making an object have a set of listeners
    12        
     12
    1313    This superclass provides the basic API for adding and removing
    1414    listeners and iterating across them. It is typically used to post
    1515    events to listening QObjects.
    class QObject; 
    2222           QObject *listener = firstListener();
    2323               while (listener) {
    2424                   QApplication::postEvent (listener, new QEvent(100));
    25                listener = nextListener(); 
     25               listener = nextListener();
    2626           }
    2727       }
    2828       \endcode
    class MPUBLIC MythObservable 
    4242  public:
    4343    MythObservable();
    4444    virtual ~MythObservable();
    45        
    46     /** \brief Add a listener to the observable 
     45
     46    /** \brief Add a listener to the observable
    4747
    4848        Adds the given QObject to the list of objects that observe
    4949        this observable.
    class MPUBLIC MythObservable 
    5252    */
    5353    void addListener(QObject *listener);
    5454
    55     /** \brief Remove a listener to the observable 
     55    /** \brief Remove a listener to the observable
    5656
    5757         Remove the given QObject from the list of objects that
    5858         observe this observable.
    class MPUBLIC MythObservable 
    6565
    6666        If you simply need to iterate across the listeners, use \p
    6767        firstListener and \p nextListener to iterate across the
    68         listeners. Ie. instead of 
     68        listeners. Ie. instead of
    6969
    7070        \code
    7171        {
    class MPUBLIC MythObservable 
    8787                // use listener...
    8888                listener = nextListener();
    8989            }
    90         } 
     90        }
    9191        \endcode
    9292
    9393        \returns pointer to the first listener, NULL if there are no listeners
    class MPUBLIC MythObservable 
    112112    */
    113113    QList<QObject*> getListeners(void);
    114114
    115     /** \brief Dispatch an event to all listeners 
    116                        
     115    /** \brief Dispatch an event to all listeners
     116
    117117        Makes a copy of the event on the heap by calling
    118118        MythEvent::clone and dispatches is by calling
    119119        QApplication::postEvent.
    120                
     120
    121121        \param event a MythEvent to dispatch.
    122122    */
    123123    void dispatch(MythEvent &event);
    124124
    125     /** \brief Dispatch an event to all listeners 
    126                        
     125    /** \brief Dispatch an event to all listeners
     126
    127127        See dispatch.
    128128
    129129        \note This uses QApplication::sendEvent, which is
  • mythtv/libs/libmythdb/mythsocket.cpp

    diff --git a/mythtv/libs/libmythdb/mythsocket.cpp b/mythtv/libs/libmythdb/mythsocket.cpp
    index 55555dc..1f2cec6 100644
    a b MythSocketThread::MythSocketThread() 
    4444MythSocket::MythSocket(int socket, MythSocketCBs *cb)
    4545    : MSocketDevice(MSocketDevice::Stream),            m_cb(cb),
    4646      m_state(Idle),         m_addr(),                 m_port(0),
    47       m_ref_count(0),        m_notifyread(0) 
     47      m_ref_count(0),        m_notifyread(0)
    4848{
    4949    VERBOSE(VB_SOCKET, LOC + "new socket");
    5050    if (socket > -1)
    bool MythSocket::DownRef(void) 
    8989    m_ref_lock.lock();
    9090    int ref = --m_ref_count;
    9191    m_ref_lock.unlock();
    92    
     92
    9393    VERBOSE(VB_SOCKET, LOC + QString("DownRef: %1").arg(m_ref_count));
    9494
    9595    if (m_cb && ref == 0)
    bool MythSocket::DownRef(void) 
    9898        m_readyread_thread.RemoveFromReadyRead(this);
    9999        // thread will downref & delete obj
    100100        return true;
    101     } 
    102     else if (ref < 0) 
     101    }
     102    else if (ref < 0)
    103103    {
    104104        delete this;
    105105        return true;
    106106    }
    107    
     107
    108108    return false;
    109109}
    110110
    void MythSocket::setState(const State state) 
    118118    if (state != m_state)
    119119    {
    120120        VERBOSE(VB_SOCKET, LOC + QString("state change %1 -> %2")
    121                 .arg(stateToString(m_state)).arg(stateToString(state))); 
     121                .arg(stateToString(m_state)).arg(stateToString(state)));
    122122
    123123        m_state = state;
    124124    }
    void MythSocket::setSocket(int socket, Type type) 
    181181
    182182    if (state() == Connected)
    183183    {
    184         VERBOSE(VB_SOCKET, LOC + 
     184        VERBOSE(VB_SOCKET, LOC +
    185185                "setSocket called while in Connected state, closing");
    186186        close();
    187187    }
    qint64 MythSocket::readBlock(char *data, quint64 len) 
    202202    // VERBOSE(VB_SOCKET, LOC + "readBlock called");
    203203    if (state() != Connected)
    204204    {
    205         VERBOSE(VB_SOCKET, LOC + "readBlock called while not in " 
     205        VERBOSE(VB_SOCKET, LOC + "readBlock called while not in "
    206206                "connected state");
    207207        return -1;
    208208    }
    qint64 MythSocket::writeBlock(const char *data, quint64 len) 
    231231    //VERBOSE(VB_SOCKET, LOC + "writeBlock called");
    232232    if (state() != Connected)
    233233    {
    234         VERBOSE(VB_SOCKET, LOC + "writeBlock called while not in " 
     234        VERBOSE(VB_SOCKET, LOC + "writeBlock called while not in "
    235235                "connected state");
    236236        return -1;
    237237    }
    bool MythSocket::writeStringList(QStringList &list) 
    256256{
    257257    if (list.size() <= 0)
    258258    {
    259         VERBOSE(VB_IMPORTANT, LOC + 
     259        VERBOSE(VB_IMPORTANT, LOC +
    260260                "writeStringList: Error, invalid string list.");
    261261        return false;
    262262    }
    bool MythSocket::writeStringList(QStringList &list) 
    322322                    QString("writeStringList: Error, writeBlock failed. (%1)")
    323323                    .arg(errorToString()));
    324324            return false;
    325         } 
     325        }
    326326        else if (temp <= 0)
    327327        {
    328328            errorcount++;
    329329            if (errorcount > 5000)
    330             {         
     330            {
    331331                VERBOSE(VB_GENERAL, LOC +
    332332                        "writeStringList: No data written on writeBlock");
    333333                return false;
    bool MythSocket::readStringList(QStringList &list, bool quickTimeout) 
    425425        }
    426426        else if (quickTimeout && elapsed >= 7000)
    427427        {
    428             VERBOSE(VB_GENERAL, LOC + 
     428            VERBOSE(VB_GENERAL, LOC +
    429429                    "readStringList: Error, timeout (quick).");
    430430            close();
    431431            if (m_cb)
    bool MythSocket::readStringList(QStringList &list, bool quickTimeout) 
    487487        QByteArray dump(pending + 1, 0);
    488488        readBlock(dump.data(), pending);
    489489        VERBOSE(VB_IMPORTANT, LOC +
    490                 QString("Protocol error: '%1' is not a valid size " 
     490                QString("Protocol error: '%1' is not a valid size "
    491491                        "prefix. %2 bytes pending.")
    492492                        .arg(sizestr.data()).arg(pending));
    493493        return false;
    bool MythSocket::readStringList(QStringList &list, bool quickTimeout) 
    498498    qint64 read = 0;
    499499    int errmsgtime = 0;
    500500    timer.start();
    501    
     501
    502502    while (btr > 0)
    503503    {
    504504        qint64 sret = readBlock(utf8.data() + read, btr);
    bool MythSocket::readStringList(QStringList &list, bool quickTimeout) 
    509509            if (btr > 0)
    510510            {
    511511                timer.start();
    512             }   
    513         } 
     512            }
     513        }
    514514        else if (sret < 0 && error() != MSocketDevice::NoError)
    515515        {
    516516            VERBOSE(VB_GENERAL, LOC +
    bool MythSocket::readStringList(QStringList &list, bool quickTimeout) 
    537537                    VERBOSE(VB_GENERAL, LOC +
    538538                            QString("readStringList: Waiting for data: %1 %2")
    539539                            .arg(read).arg(btr));
    540                 }                           
     540                }
    541541            }
    542            
     542
    543543            if (elapsed > 100000)
    544544            {
    545                 VERBOSE(VB_GENERAL, LOC + 
     545                VERBOSE(VB_GENERAL, LOC +
    546546                        "Error, readStringList timeout (readBlock)");
    547547                return false;
    548548            }
    549            
     549
    550550            usleep(500);
    551551        }
    552552    }
    bool MythSocket::readStringList(QStringList &list, bool quickTimeout) 
    558558    payload += "        ";
    559559    payload.truncate(8);
    560560    payload += str;
    561    
     561
    562562    if ((print_verbose_messages & VB_NETWORK) != 0)
    563563    {
    564564        QString msg = QString("read  <- %1 %2").arg(socket(), 2)
    bool MythSocket::connect(const QHostAddress &addr, quint16 port) 
    639639        setState(Idle);
    640640        return false;
    641641    }
    642        
     642
    643643    setReceiveBufferSize(kSocketBufferSize);
    644644    setAddressReusable(true);
    645645    if (state() == Connecting)
    void MythSocketThread::StartReadyReadThread(void) 
    703703
    704704            atexit(ShutdownRRT);
    705705        }
    706     }   
     706    }
    707707}
    708708
    709709void MythSocketThread::AddToReadyRead(MythSocket *sock)
    void MythSocketThread::RemoveFromReadyRead(MythSocket *sock) 
    735735void MythSocketThread::WakeReadyReadThread(void)
    736736{
    737737    if (!isRunning())
    738             return;
     738            return;
    739739
    740740#ifdef USING_MINGW
    741741    if (readyreadevent) ::SetEvent(readyreadevent);
    void MythSocketThread::run(void) 
    836836                else
    837837                {
    838838                    if (SOCKET_ERROR != ::WSAEventSelect(
    839                             sock->socket(), hEvent, 
     839                            sock->socket(), hEvent,
    840840                            FD_READ | FD_CLOSE))
    841841                    {
    842842                        hEvents[n] = hEvent;
  • mythtv/libs/libmythdb/mythsocket.h

    diff --git a/mythtv/libs/libmythdb/mythsocket.h b/mythtv/libs/libmythdb/mythsocket.h
    index 3ef8049..bc4e484 100644
    a b class MPUBLIC MythSocket : public MSocketDevice 
    7373
    7474    void close(void);
    7575    void deleteLater(void);
    76  
     76
    7777    void UpRef(void);
    7878    bool DownRef(void);
    7979
  • mythtv/libs/libmythdb/mythstorage.cpp

    diff --git a/mythtv/libs/libmythdb/mythstorage.cpp b/mythtv/libs/libmythdb/mythstorage.cpp
    index e4fccd2..c8ded4f 100644
    a b QString GenericDBStorage::GetSetClause(MSqlBindings &bindings) const 
    118118    bindings.insert(keycolumnTag, keyvalue);
    119119    bindings.insert(columnTag,    user->GetDBValue());
    120120
    121     return keycolumn + " = " + keycolumnTag + ", " + 
     121    return keycolumn + " = " + keycolumnTag + ", " +
    122122        GetColumnName() + " = " + columnTag;
    123123}
    124124
  • mythtv/libs/libmythdb/mythverbose.h

    diff --git a/mythtv/libs/libmythdb/mythverbose.h b/mythtv/libs/libmythdb/mythverbose.h
    index 3f82742..1793b13 100644
    a b enum VerboseMask 
    103103    VB_UNUSED_END // keep at end
    104104};
    105105
    106 /// This global variable is set at startup with the flags 
     106/// This global variable is set at startup with the flags
    107107/// of the verbose messages we want to see.
    108108extern MPUBLIC unsigned int print_verbose_messages;
    109109#ifdef __cplusplus
    extern MPUBLIC unsigned int print_verbose_messages; 
    162162
    163163    // The verbose_mutex lock is a recursive lock so it is possible (while
    164164    // not recommended) to use a VERBOSE macro within another VERBOSE macro.
    165     // But waiting for another thread to do something is not safe within a 
     165    // But waiting for another thread to do something is not safe within a
    166166    // VERBOSE macro, since those threads may wish to use the VERBOSE macro
    167167    // and this will cause a deadlock.
    168168
    extern MPUBLIC unsigned int print_verbose_messages; 
    211211    /// This can be appended to the VERBOSE args with either
    212212    /// "+" (with QStrings) or "<<" (with c strings). It uses
    213213    /// a thread safe version of strerror to produce the
    214     /// string representation of errno and puts it on the 
     214    /// string representation of errno and puts it on the
    215215    /// next line in the verbose output.
    216216    #define ENO QString("\n\t\t\teno: ") + safe_eno_to_string(errno)
    217217#endif
  • mythtv/libs/libmythdb/oldsettings.cpp

    diff --git a/mythtv/libs/libmythdb/oldsettings.cpp b/mythtv/libs/libmythdb/oldsettings.cpp
    index 905e37c..1652413 100644
    a b Settings::~Settings() 
    4444QString Settings::GetSetting(QString strSetting, QString defaultvalue)
    4545{
    4646    map<QString, QString>::iterator i;
    47     if ((!m_pSettings->empty()) && 
     47    if ((!m_pSettings->empty()) &&
    4848        ((i = m_pSettings->find(strSetting)) != m_pSettings->end()))
    4949    {
    5050        return (*i).second;
    int Settings::GetNumSetting(QString strSetting, int defaultvalue) 
    5757{
    5858    int retval = defaultvalue;
    5959    map<QString, QString>::iterator i;
    60     if ((!m_pSettings->empty()) && 
     60    if ((!m_pSettings->empty()) &&
    6161        ((i = m_pSettings->find(strSetting)) != m_pSettings->end()))
    6262    {
    6363        bool ok = false;
    float Settings::GetFloatSetting(QString strSetting, float defaultvalue) 
    7474    float retval = defaultvalue;
    7575
    7676    map<QString, QString>::iterator i;
    77     if ((!m_pSettings->empty()) && 
     77    if ((!m_pSettings->empty()) &&
    7878        ((i = m_pSettings->find(strSetting)) != m_pSettings->end()))
    7979    {
    8080        bool ok = false;
  • mythtv/libs/libmythdb/oldsettings.h

    diff --git a/mythtv/libs/libmythdb/oldsettings.h b/mythtv/libs/libmythdb/oldsettings.h
    index e8a6dc8..b1fc96b 100644
    a b  
    1717
    1818using namespace std;
    1919
    20 /**This class contains configuration information. 
     20/**This class contains configuration information.
    2121  *This object is threadsafe.
    2222  *@author Sean Ward
    2323  */
    2424
    2525class QPixmap;
    2626class MPUBLIC Settings {
    27 public: 
     27public:
    2828        Settings(QString strSettingFile = "settings.txt");
    2929        ~Settings();
    3030