workspace/kcontrol/kfontinst/kio/Socket.cpp

   1 /*
   2  * KFontInst - KDE Font Installer
   3  *
   4  * Copyright 2003-2007 Craig Drummond <craig@kde.org>
   5  *
   6  * ----
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; see the file COPYING.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 //
  25 // This file contains code taken from kdelibs/kdesu/client.cpp
  26 //
  27
  28 #include "Socket.h"
  29
  30 #include <stdio.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33 #include <errno.h>
  34 #include <string.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <sys/un.h>
  38 #include <sys/stat.h>
  39 #include <QtCore/QByteArray>
  40 #include <config-workspace.h>
  41 #include <KDE/KDebug>
  42 #include <kde_file.h>
  43
  44 #ifndef SUN_LEN
  45 #define SUN_LEN(ptr) ((socklen_t) (((struct sockaddr_un *) 0)->sun_path) \
  46                  + strlen ((ptr)->sun_path))
  47 #endif
  48
  49 namespace KFI
  50 {
  51
  52 CSocket::CSocket(int fd)
  53        :  itsFd(fd)
  54 {
  55 }
  56
  57 CSocket::~CSocket()
  58 {
  59     if (itsFd>=0)
  60         ::close(itsFd);
  61 }
  62
  63 bool CSocket::read(QVariant &var, int timeout)
  64 {
  65     if(itsFd<0)
  66         return false;
  67
  68     int type;
  69
  70     if(readBlock((char *)&type, sizeof(type), timeout))
  71     {
  72         switch(type)
  73         {
  74             case QVariant::Int:
  75             {
  76                 int val;
  77                 if(readBlock((char *)(&val), sizeof(int), timeout))
  78                 {
  79                     var=QVariant(val);
  80                     return true;
  81                 }
  82                 break;
  83             }
  84             case QVariant::ULongLong:
  85             {
  86                 qulonglong val;
  87                 if(readBlock((char *)(&val), sizeof(qulonglong), timeout))
  88                 {
  89                     var=QVariant(val);
  90                     return true;
  91                 }
  92                 break;
  93             }
  94             case QVariant::Bool:
  95             {
  96                 unsigned char val;
  97                 if(readBlock((char *)(&val), sizeof(unsigned char), timeout))
  98                 {
  99                     var=QVariant((bool)val);
 100                     return true;
 101                 }
 102                 break;
 103             }
 104             case QVariant::String:
 105             {
 106                 int len;
 107
 108                 if(readBlock((char *)&len, sizeof(unsigned int), timeout))
 109                 {
 110                     QByteArray data(len, '\0');
 111
 112                     if(readBlock(data.data(), len, timeout))
 113                     {
 114                         var=QVariant(QString::fromUtf8(data));
 115                         return true;
 116                     }
 117                 }
 118                 break;
 119             }
 120             default:
 121                 ;
 122         }
 123     }
 124     return false;
 125 }
 126
 127 bool CSocket::read(QString &str, int timeout)
 128 {
 129     QVariant var;
 130
 131     if(read(var, timeout) && QVariant::String==var.type())
 132     {
 133         str=var.toString();
 134         return true;
 135     }
 136
 137     return false;
 138 }
 139
 140 bool CSocket::read(int &i, int timeout)
 141 {
 142     QVariant var;
 143
 144     if(read(var, timeout) && QVariant::Int==var.type())
 145     {
 146         i=var.toInt();
 147         return true;
 148     }
 149
 150     return false;
 151 }
 152
 153 bool CSocket::read(qulonglong &i, int timeout)
 154 {
 155     QVariant var;
 156
 157     if(read(var, timeout) && QVariant::ULongLong==var.type())
 158     {
 159         i=var.toULongLong();
 160         return true;
 161     }
 162
 163     return false;
 164 }
 165
 166 bool CSocket::read(bool &b, int timeout)
 167 {
 168     QVariant var;
 169
 170     if(read(var, timeout) && QVariant::Bool==var.type())
 171     {
 172         b=var.toBool();
 173         return true;
 174     }
 175
 176     return false;
 177 }
 178
 179 bool CSocket::write(const QVariant &var, int timeout)
 180 {
 181     if(itsFd<0)
 182         return false;
 183
 184     int type(var.type());
 185
 186     switch(type)
 187     {
 188         case QVariant::Int:
 189         {
 190             int val(var.toInt());
 191             return writeBlock((const char *)(&type), sizeof(int), timeout) &&
 192                    writeBlock((const char *)(&val), sizeof(int), timeout);
 193         }
 194         case QVariant::ULongLong:
 195         {
 196             qulonglong val(var.toInt());
 197             return writeBlock((const char *)(&type), sizeof(int), timeout) &&
 198                    writeBlock((const char *)(&val), sizeof(qulonglong), timeout);
 199         }
 200         case QVariant::Bool:
 201         {
 202             unsigned char val(var.toBool());
 203
 204             return writeBlock((const char *)(&type), sizeof(int), timeout) &&
 205                    writeBlock((const char *)(&val), sizeof(unsigned char), timeout);
 206             break;
 207         }
 208         case QVariant::String:
 209         {
 210             QByteArray data(var.toString().toUtf8());
 211             int        len(data.size());
 212
 213             return writeBlock((const char *)(&type), sizeof(int), timeout) &&
 214                    writeBlock((const char *)(&len), sizeof(int), timeout) &&
 215                    writeBlock(data.constData(), len, timeout);
 216             break;
 217         }
 218         default:
 219             ;
 220     }
 221
 222     return false;
 223 }
 224
 225 bool CSocket::connectToServer(const QByteArray &sock, unsigned int socketUid)
 226 {
 227     if (itsFd >= 0)
 228         ::close(itsFd);
 229     itsFd=-1;
 230     if (access(sock, R_OK|W_OK))
 231         return false;
 232
 233     itsFd =::socket(PF_UNIX, SOCK_STREAM, 0);
 234     if (itsFd < 0)
 235     {
 236         kWarning() << k_lineinfo << "socket(): " << errno ;
 237         return false;
 238     }
 239     struct sockaddr_un addr;
 240     addr.sun_family = AF_UNIX;
 241     strcpy(addr.sun_path, sock);
 242
 243     if (::connect(itsFd, (struct sockaddr *) &addr, SUN_LEN(&addr)) < 0)
 244     {
 245         kWarning() << k_lineinfo << "connect():" << errno ;
 246         ::close(itsFd);
 247         itsFd = -1;
 248         return false;
 249     }
 250
 251 #if !defined(SO_PEERCRED) || !defined(HAVE_STRUCT_UCRED)
 252 # if defined(HAVE_GETPEEREID)
 253     uid_t euid;
 254     gid_t egid;
 255     // Security: if socket exists, we must own it
 256     if (getpeereid(itsFd, &euid, &egid) == 0)
 257     {
 258        if (euid != socketUid)
 259        {
 260             kWarning(900) << "socket not owned by me! socket uid = " << euid;
 261             ::close(itsFd);
 262             itsFd = -1;
 263             return -1;
 264        }
 265     }
 266 # else
 267 #  ifdef __GNUC__
 268 #   warning "Using sloppy security checks"
 269 #  endif
 270     // We check the owner of the socket after we have connected.
 271     // If the socket was somehow not ours an attacker will be able
 272     // to delete it after we connect but shouldn't be able to
 273     // create a socket that is owned by us.
 274     KDE_struct_stat s;
 275     if (KDE_lstat(sock, &s)!=0)
 276     {
 277         kWarning(900) << "stat failed (" << sock << ")";
 278         ::close(itsFd);
 279         itsFd = -1;
 280         return false;
 281     }
 282     if (s.st_uid != socketUid)
 283     {
 284         kWarning(900) << "socket not owned by me! socket uid = " << s.st_uid;
 285         ::close(itsFd);
 286         itsFd = -1;
 287         return false;
 288     }
 289     if (!S_ISSOCK(s.st_mode))
 290     {
 291         kWarning(900) << "socket is not a socket (" << sock << ")";
 292         ::close(itsFd);
 293         itsFd = -1;
 294         return false;
 295     }
 296 # endif
 297 #else
 298     struct ucred cred;
 299     socklen_t    siz = sizeof(cred);
 300
 301     // Security: if socket exists, we must own it
 302     if (getsockopt(itsFd, SOL_SOCKET, SO_PEERCRED, &cred, &siz) == 0)
 303     {
 304         if (cred.uid != socketUid)
 305         {
 306             kWarning(900) << "socket not owned by me! socket uid = " << cred.uid;
 307             ::close(itsFd);
 308             itsFd = -1;
 309             return false;
 310         }
 311     }
 312 #endif
 313
 314     return true;
 315 }
 316
 317 bool CSocket::readBlock(char *data, int size, int timeout)
 318 {
 319     int bytesToRead=size;
 320
 321     do
 322     {
 323         if(waitForReadyRead(timeout))
 324         {
 325             int bytesRead=::read(itsFd, &data[size-bytesToRead], bytesToRead);
 326
 327             if (bytesRead>0)
 328                 bytesToRead-=bytesRead;
 329             else
 330                 return false;
 331         }
 332         else
 333             return false;
 334     }
 335     while(bytesToRead>0);
 336
 337     return true;
 338 }
 339
 340 bool CSocket::writeBlock(const char *data, int size, int timeout)
 341 {
 342     int bytesToWrite=size;
 343
 344     do
 345     {
 346         if(waitForReadyWrite(timeout))
 347         {
 348             int bytesWritten=::write(itsFd, (char *)&data[size-bytesToWrite], bytesToWrite);
 349
 350             if (bytesWritten>0)
 351                 bytesToWrite-=bytesWritten;
 352             else
 353                 return false;
 354         }
 355         else
 356             return false;
 357     }
 358     while(bytesToWrite>0);
 359
 360     return true;
 361 }
 362
 363 bool CSocket::waitForReadyRead(int timeout)
 364 {
 365     fd_set         fdSet;
 366     struct timeval tv;
 367
 368     FD_ZERO(&fdSet);
 369     FD_SET(itsFd, &fdSet);
 370     tv.tv_sec = timeout;
 371     tv.tv_usec = 0;
 372
 373     for(;;)
 374         if(select(itsFd + 1, &fdSet, NULL, NULL, -1==timeout ? NULL : &tv)<0)
 375         {
 376             if(errno == EINTR)
 377                 continue;
 378             else
 379                 return false;
 380         }
 381         else
 382             return FD_ISSET(itsFd, &fdSet);
 383
 384     return false;
 385 }
 386
 387 bool CSocket::waitForReadyWrite(int timeout)
 388 {
 389     fd_set         fdSet;
 390     struct timeval tv;
 391
 392     FD_ZERO(&fdSet);
 393     FD_SET(itsFd, &fdSet);
 394     tv.tv_sec = timeout;
 395     tv.tv_usec = 0;
 396
 397     for(;;)
 398         if(select(itsFd + 1, NULL, &fdSet, NULL, -1==timeout ? NULL : &tv)<0)
 399         {
 400             if(errno == EINTR)
 401                 continue;
 402             else
 403                 return false;
 404         }
 405         else
 406             return FD_ISSET(itsFd, &fdSet);
 407
 408     return false;
 409 }
 410
 411 }