runtime/kioslave/smb/kio_smb_dir.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 //
   3 // Project:     SMB kioslave for KDE2
   4 //
   5 // File:        kio_smb_dir.cpp
   6 //
   7 // Abstract:    member function implementations for SMBSlave that deal with
   8 //              SMB directory access
   9 //
  10 // Author(s):   Matthew Peterson <mpeterson@caldera.com>
  11 //
  12 ////---------------------------------------------------------------------------
  13 //
  14 // Copyright (c) 2000  Caldera Systems, Inc.
  15 //
  16 // This program is free software; you can redistribute it and/or modify it
  17 // under the terms of the GNU General Public License as published by the
  18 // Free Software Foundation; either version 2.1 of the License, or
  19 // (at your option) any later version.
  20 //
  21 //     This program is distributed in the hope that it will be useful,
  22 //     but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 //     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 //     GNU Lesser General Public License for more details.
  25 //
  26 //     You should have received a copy of the GNU General Public License
  27 //     along with this program; see the file COPYING.  If not, please obtain
  28 //     a copy from http://www.gnu.org/copyleft/gpl.html
  29 //
  30 /////////////////////////////////////////////////////////////////////////////
  31
  32 #include "kio_smb.h"
  33 #include "kio_smb_internal.h"
  34
  35
  36 //===========================================================================
  37 // TODO: add when libsmbclient supports it
  38 void SMBSlave::copy( const KUrl& ksrc,
  39                      const KUrl& kdst,
  40                      int permissions,
  41                      KIO::JobFlags flags )
  42 {
  43
  44     SMBUrl          src;
  45     SMBUrl          dst;
  46     mode_t          initialmode;
  47     ssize_t         n;
  48     int             dstflags;
  49     int             srcfd = -1;
  50     int             dstfd = -1;
  51     int             errNum = 0;
  52     KIO::filesize_t processed_size = 0;
  53     unsigned char   buf[MAX_XFER_BUF_SIZE];
  54
  55     kDebug(KIO_SMB) << "SMBSlave::copy with src = " << ksrc << "and dest = " << kdst;
  56
  57     // setup urls
  58     src = ksrc;
  59     dst = kdst;
  60
  61     // Obtain information about source
  62     errNum = cache_stat(src, &st );
  63     if( errNum != 0 )
  64     {
  65         if ( errNum == EACCES )
  66         {
  67             error( KIO::ERR_ACCESS_DENIED, src.prettyUrl());
  68         }
  69         else
  70         {
  71              error( KIO::ERR_DOES_NOT_EXIST, src.prettyUrl());
  72         }
  73         return;
  74     }
  75     if ( S_ISDIR( st.st_mode ) )
  76     {
  77         error( KIO::ERR_IS_DIRECTORY, src.prettyUrl() );
  78         return;
  79     }
  80     totalSize(st.st_size);
  81
  82     // Check to se if the destination exists
  83     errNum = cache_stat(dst, &st);
  84     if( errNum == 0 )
  85     {
  86         if(S_ISDIR(st.st_mode))
  87         {
  88             error( KIO::ERR_DIR_ALREADY_EXIST, dst.prettyUrl());
  89             return;
  90         }
  91         if(!(flags & KIO::Overwrite))
  92         {
  93             error( KIO::ERR_FILE_ALREADY_EXIST, dst.prettyUrl());
  94             return;
  95         }
  96     }
  97
  98     // Open the source file
  99     srcfd = smbc_open(src.toSmbcUrl(), O_RDONLY, 0);
 100     if (srcfd < 0){
 101         errNum = errno;
 102     } else {
 103         errNum = 0;
 104     }
 105
 106     if(srcfd < 0)
 107     {
 108         if(errNum == EACCES)
 109         {
 110             error( KIO::ERR_ACCESS_DENIED, src.prettyUrl() );
 111         }
 112         else
 113         {
 114             error( KIO::ERR_DOES_NOT_EXIST, src.prettyUrl() );
 115         }
 116         return;
 117     }
 118
 119     // Determine initial creation mode
 120     if(permissions != -1)
 121     {
 122         initialmode = permissions | S_IWUSR;
 123     }
 124     else
 125     {
 126         initialmode = 0 | S_IWUSR;//0666;
 127     }
 128
 129
 130     // Open the destination file
 131     dstflags = O_CREAT | O_TRUNC | O_WRONLY;
 132     if(!(flags & KIO::Overwrite))
 133     {
 134         dstflags |= O_EXCL;
 135     }
 136     dstfd = smbc_open(dst.toSmbcUrl(), dstflags, initialmode);
 137     if (dstfd < 0){
 138         errNum = errno;
 139     } else {
 140         errNum = 0;
 141     }
 142
 143     if(dstfd < 0)
 144     {
 145         if(errNum == EACCES)
 146         {
 147             error(KIO::ERR_WRITE_ACCESS_DENIED, dst.prettyUrl());
 148         }
 149         else
 150         {
 151             error(KIO::ERR_CANNOT_OPEN_FOR_READING, dst.prettyUrl());
 152         }
 153
 154         if(srcfd >= 0 )
 155         {
 156             smbc_close(srcfd);
 157         }
 158         return;
 159     }
 160
 161
 162     // Perform copy
 163     while(1)
 164     {
 165         n = smbc_read(srcfd, buf, MAX_XFER_BUF_SIZE );
 166         if(n > 0)
 167         {
 168             n = smbc_write(dstfd, buf, n);
 169             if(n == -1)
 170             {
 171                 kDebug(KIO_SMB) << "SMBSlave::copy copy now KIO::ERR_COULD_NOT_WRITE";
 172                 error( KIO::ERR_COULD_NOT_WRITE, dst.prettyUrl());
 173                 break;
 174             }
 175
 176             processed_size += n;
 177             processedSize(processed_size);
 178         }
 179         else if(n == 0)
 180         {
 181               break; // finished
 182         }
 183         else
 184         {
 185             error( KIO::ERR_COULD_NOT_READ, src.prettyUrl());
 186             break;
 187         }
 188     }
 189
 190
 191     //    FINISHED:
 192
 193     if(srcfd >= 0 )
 194     {
 195         smbc_close(srcfd);
 196     }
 197
 198     if(dstfd >= 0)
 199     {
 200         if(smbc_close(dstfd) == 0)
 201         {
 202
 203             // TODO: set final permissions
 204         }
 205         else
 206         {
 207             error( KIO::ERR_COULD_NOT_WRITE, dst.prettyUrl());
 208             return;
 209         }
 210     }
 211
 212     finished();
 213 }
 214
 215 //===========================================================================
 216 void SMBSlave::del( const KUrl &kurl, bool isfile)
 217 {
 218     kDebug(KIO_SMB) << "SMBSlave::del on " << kurl;
 219     m_current_url = kurl;
 220     int errNum = 0;
 221     int retVal = 0;
 222
 223     if(isfile)
 224     {
 225         // Delete file
 226         kDebug(KIO_SMB) << "SMBSlave:: unlink " << kurl;
 227         retVal = smbc_unlink(m_current_url.toSmbcUrl());
 228         if ( retVal < 0 ){
 229             errNum = errno;
 230         } else {
 231             errNum = 0;
 232         }
 233
 234         if( retVal < 0 )
 235         {
 236             reportError(kurl, errNum);
 237         }
 238     }
 239     else
 240     {
 241         kDebug(KIO_SMB) << "SMBSlave:: rmdir " << kurl;
 242         // Delete directory
 243         retVal = smbc_rmdir(m_current_url.toSmbcUrl());
 244         if( retVal < 0 ) {
 245             errNum = errno;
 246         } else {
 247             errNum = 0;
 248         }
 249
 250         if( retVal < 0 )
 251         {
 252             reportError(kurl, errNum);
 253         }
 254     }
 255
 256     finished();
 257 }
 258
 259 //===========================================================================
 260 void SMBSlave::mkdir( const KUrl &kurl, int permissions )
 261 {
 262     kDebug(KIO_SMB) << "SMBSlave::mkdir on " << kurl;
 263     int errNum = 0;
 264     int retVal = 0;
 265     m_current_url = kurl;
 266
 267     retVal = smbc_mkdir(m_current_url.toSmbcUrl(), 0777);
 268     if( retVal < 0 ){
 269         errNum = errno;
 270     } else {
 271         errNum = 0;
 272     }
 273
 274     if( retVal < 0 )
 275     {
 276         if (errNum == EEXIST) {
 277             errNum = cache_stat(m_current_url, &st );
 278             if( errNum == 0 )
 279             {
 280                 if(S_ISDIR(st.st_mode ))
 281                 {
 282                     error( KIO::ERR_DIR_ALREADY_EXIST, m_current_url.prettyUrl());
 283                 }
 284             }
 285             else
 286             {
 287                 error( KIO::ERR_FILE_ALREADY_EXIST, m_current_url.prettyUrl());
 288             }
 289         } else
 290             reportError(kurl, errNum);
 291         kDebug(KIO_SMB) << "SMBSlave::mkdir exit with error " << kurl;
 292     }
 293     else
 294     {
 295         if(permissions != -1)
 296         {
 297             // TODO enable the following when complete
 298             //smbc_chmod( url.toSmbcUrl(), permissions );
 299         }
 300     }
 301
 302     finished();
 303 }
 304
 305
 306 //===========================================================================
 307 void SMBSlave::rename( const KUrl& ksrc, const KUrl& kdest, KIO::JobFlags flags )
 308 {
 309
 310     SMBUrl      src;
 311     SMBUrl      dst;
 312     int         errNum = 0;
 313     int         retVal = 0;
 314
 315     kDebug(KIO_SMB) << "SMBSlave::rename, old name = " << ksrc << ", new name = " << kdest;
 316
 317     src = ksrc;
 318     dst = kdest;
 319
 320     // Check to se if the destination exists
 321
 322     kDebug(KIO_SMB) << "SMBSlave::rename stat dst";
 323     errNum = cache_stat(dst, &st);
 324     if( errNum == 0 )
 325     {
 326         if(S_ISDIR(st.st_mode))
 327         {
 328             kDebug(KIO_SMB) << "SMBSlave::rename KIO::ERR_DIR_ALREADY_EXIST";
 329             error( KIO::ERR_DIR_ALREADY_EXIST, dst.prettyUrl());
 330             finished();
 331             return;
 332         }
 333         if(!(flags & KIO::Overwrite))
 334         {
 335             kDebug(KIO_SMB) << "SMBSlave::rename KIO::ERR_FILE_ALREADY_EXIST";
 336             error( KIO::ERR_FILE_ALREADY_EXIST, dst.prettyUrl());
 337             finished();
 338             return;
 339         }
 340     }
 341     kDebug(KIO_SMB ) << "smbc_rename " << src.toSmbcUrl() << " " << dst.toSmbcUrl();
 342     retVal = smbc_rename(src.toSmbcUrl(), dst.toSmbcUrl());
 343     if( retVal < 0 ){
 344         errNum = errno;
 345     } else {
 346         errNum = 0;
 347     }
 348
 349     if( retVal < 0 )
 350     {
 351       kDebug(KIO_SMB ) << "failed ";
 352       switch(errNum)
 353       {
 354         case ENOENT:
 355           errNum = cache_stat(src, &st);
 356           if( errNum != 0 )
 357           {
 358               if(errNum == EACCES)
 359               {
 360                 kDebug(KIO_SMB) << "SMBSlave::rename KIO::ERR_ACCESS_DENIED";
 361                 error(KIO::ERR_ACCESS_DENIED, src.prettyUrl());
 362               }
 363               else
 364               {
 365                 kDebug(KIO_SMB) << "SMBSlave::rename KIO::ERR_DOES_NOT_EXIST";
 366                 error(KIO::ERR_DOES_NOT_EXIST, src.prettyUrl());
 367               }
 368           }
 369           break;
 370
 371         case EACCES:
 372         case EPERM:
 373           kDebug(KIO_SMB) << "SMBSlave::rename KIO::ERR_ACCESS_DENIED";
 374           error( KIO::ERR_ACCESS_DENIED, dst.prettyUrl() );
 375           break;
 376
 377         default:
 378           kDebug(KIO_SMB) << "SMBSlave::rename KIO::ERR_CANNOT_RENAME";
 379           error( KIO::ERR_CANNOT_RENAME, src.prettyUrl() );
 380
 381       }
 382
 383       kDebug(KIO_SMB) << "SMBSlave::rename exit with error";
 384       return;
 385     }
 386
 387     kDebug(KIO_SMB ) << "everything fine\n";
 388     finished();
 389 }
 390
 391