Changeset View
Changeset View
Standalone View
Standalone View
smb/kio_smb_dir.cpp
Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Line(s) | 58 | { | |||
---|---|---|---|---|---|
63 | ssize_t n; | 63 | ssize_t n; | ||
64 | int dstflags; | 64 | int dstflags; | ||
65 | int srcfd = -1; | 65 | int srcfd = -1; | ||
66 | int dstfd = -1; | 66 | int dstfd = -1; | ||
67 | int errNum = 0; | 67 | int errNum = 0; | ||
68 | KIO::filesize_t processed_size = 0; | 68 | KIO::filesize_t processed_size = 0; | ||
69 | unsigned char buf[MAX_XFER_BUF_SIZE]; | 69 | unsigned char buf[MAX_XFER_BUF_SIZE]; | ||
70 | 70 | | |||
71 | qCDebug(KIO_SMB) << "SMBSlave::copy with src = " << ksrc << "and dest = " << kdst; | 71 | qCDebug(KIO_SMB_LOG) << "SMBSlave::copy with src = " << ksrc << "and dest = " << kdst; | ||
72 | 72 | | |||
73 | // setup urls | 73 | // setup urls | ||
74 | src = ksrc; | 74 | src = ksrc; | ||
75 | dst = kdst; | 75 | dst = kdst; | ||
76 | 76 | | |||
77 | // Obtain information about source | 77 | // Obtain information about source | ||
78 | errNum = cache_stat(src, &st ); | 78 | errNum = cache_stat(src, &st ); | ||
79 | if( errNum != 0 ) | 79 | if( errNum != 0 ) | ||
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Line(s) | 132 | return; | |||
179 | while(1) | 179 | while(1) | ||
180 | { | 180 | { | ||
181 | n = smbc_read(srcfd, buf, MAX_XFER_BUF_SIZE ); | 181 | n = smbc_read(srcfd, buf, MAX_XFER_BUF_SIZE ); | ||
182 | if(n > 0) | 182 | if(n > 0) | ||
183 | { | 183 | { | ||
184 | n = smbc_write(dstfd, buf, n); | 184 | n = smbc_write(dstfd, buf, n); | ||
185 | if(n == -1) | 185 | if(n == -1) | ||
186 | { | 186 | { | ||
187 | qCDebug(KIO_SMB) << "SMBSlave::copy copy now KIO::ERR_CANNOT_WRITE"; | 187 | qCDebug(KIO_SMB_LOG) << "SMBSlave::copy copy now KIO::ERR_CANNOT_WRITE"; | ||
188 | error( KIO::ERR_CANNOT_WRITE, dst.toDisplayString()); | 188 | error( KIO::ERR_CANNOT_WRITE, dst.toDisplayString()); | ||
189 | break; | 189 | break; | ||
190 | } | 190 | } | ||
191 | 191 | | |||
192 | processed_size += n; | 192 | processed_size += n; | ||
193 | processedSize(processed_size); | 193 | processedSize(processed_size); | ||
194 | } | 194 | } | ||
195 | else if(n == 0) | 195 | else if(n == 0) | ||
Show All 29 Lines | 224 | return; | |||
225 | } | 225 | } | ||
226 | } | 226 | } | ||
227 | 227 | | |||
228 | finished(); | 228 | finished(); | ||
229 | } | 229 | } | ||
230 | 230 | | |||
231 | void SMBSlave::smbCopyGet(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags) | 231 | void SMBSlave::smbCopyGet(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags) | ||
232 | { | 232 | { | ||
233 | qCDebug(KIO_SMB) << "src = " << ksrc << ", dest = " << kdst; | 233 | qCDebug(KIO_SMB_LOG) << "src = " << ksrc << ", dest = " << kdst; | ||
234 | 234 | | |||
235 | // check if destination is ok ... | 235 | // check if destination is ok ... | ||
236 | const QString dstFile = kdst.toLocalFile(); | 236 | const QString dstFile = kdst.toLocalFile(); | ||
237 | const QFileInfo dstInfo (dstFile); | 237 | const QFileInfo dstInfo (dstFile); | ||
238 | 238 | | |||
239 | if(dstInfo.exists()) { | 239 | if(dstInfo.exists()) { | ||
240 | if(dstInfo.isDir()) { | 240 | if(dstInfo.isDir()) { | ||
241 | error (ERR_IS_DIRECTORY, kdst.toDisplayString()); | 241 | error (ERR_IS_DIRECTORY, kdst.toDisplayString()); | ||
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Line(s) | 282 | if (permissions == -1) { | |||
283 | perms = QFile::ReadOwner | QFile::WriteOwner; | 283 | perms = QFile::ReadOwner | QFile::WriteOwner; | ||
284 | } else { | 284 | } else { | ||
285 | perms = KIO::convertPermissions(permissions | QFile::WriteOwner); | 285 | perms = KIO::convertPermissions(permissions | QFile::WriteOwner); | ||
286 | } | 286 | } | ||
287 | file.setPermissions(perms); | 287 | file.setPermissions(perms); | ||
288 | } | 288 | } | ||
289 | 289 | | |||
290 | if (!file.open(mode)) { | 290 | if (!file.open(mode)) { | ||
291 | qCDebug(KIO_SMB) << "could not write to" << dstFile; | 291 | qCDebug(KIO_SMB_LOG) << "could not write to" << dstFile; | ||
292 | switch (file.error()) { | 292 | switch (file.error()) { | ||
293 | case QFile::OpenError: | 293 | case QFile::OpenError: | ||
294 | if (bResume) { | 294 | if (bResume) { | ||
295 | error (ERR_CANNOT_RESUME, kdst.toDisplayString()); | 295 | error (ERR_CANNOT_RESUME, kdst.toDisplayString()); | ||
296 | } else { | 296 | } else { | ||
297 | error(ERR_CANNOT_OPEN_FOR_WRITING, kdst.toDisplayString()); | 297 | error(ERR_CANNOT_OPEN_FOR_WRITING, kdst.toDisplayString()); | ||
298 | } | 298 | } | ||
299 | break; | 299 | break; | ||
Show All 30 Lines | |||||
330 | // Open the source file | 330 | // Open the source file | ||
331 | KIO::filesize_t processed_size = 0; | 331 | KIO::filesize_t processed_size = 0; | ||
332 | int srcfd = smbc_open(src.toSmbcUrl(), O_RDONLY, 0); | 332 | int srcfd = smbc_open(src.toSmbcUrl(), O_RDONLY, 0); | ||
333 | if (srcfd < 0){ | 333 | if (srcfd < 0){ | ||
334 | errNum = errno; | 334 | errNum = errno; | ||
335 | } else { | 335 | } else { | ||
336 | errNum = 0; | 336 | errNum = 0; | ||
337 | if (bResume) { | 337 | if (bResume) { | ||
338 | qCDebug(KIO_SMB) << "seeking to size" << partInfo.size(); | 338 | qCDebug(KIO_SMB_LOG) << "seeking to size" << partInfo.size(); | ||
339 | off_t offset = smbc_lseek(srcfd, partInfo.size(), SEEK_SET); | 339 | off_t offset = smbc_lseek(srcfd, partInfo.size(), SEEK_SET); | ||
340 | if (offset == -1) { | 340 | if (offset == -1) { | ||
341 | error(KIO::ERR_CANNOT_SEEK, src.toDisplayString()); | 341 | error(KIO::ERR_CANNOT_SEEK, src.toDisplayString()); | ||
342 | smbc_close(srcfd); | 342 | smbc_close(srcfd); | ||
343 | return; | 343 | return; | ||
344 | } else { | 344 | } else { | ||
345 | processed_size += offset; | 345 | processed_size += offset; | ||
346 | } | 346 | } | ||
Show All 20 Lines | 366 | if (bytesRead < 0) { | |||
367 | error( KIO::ERR_CANNOT_READ, src.toDisplayString()); | 367 | error( KIO::ERR_CANNOT_READ, src.toDisplayString()); | ||
368 | isErr = true; | 368 | isErr = true; | ||
369 | } | 369 | } | ||
370 | break; | 370 | break; | ||
371 | } | 371 | } | ||
372 | 372 | | |||
373 | const qint64 bytesWritten = file.write(buf, bytesRead); | 373 | const qint64 bytesWritten = file.write(buf, bytesRead); | ||
374 | if (bytesWritten == -1) { | 374 | if (bytesWritten == -1) { | ||
375 | qCDebug(KIO_SMB) << "copy now KIO::ERR_CANNOT_WRITE"; | 375 | qCDebug(KIO_SMB_LOG) << "copy now KIO::ERR_CANNOT_WRITE"; | ||
376 | error( KIO::ERR_CANNOT_WRITE, kdst.toDisplayString()); | 376 | error( KIO::ERR_CANNOT_WRITE, kdst.toDisplayString()); | ||
377 | isErr = true; | 377 | isErr = true; | ||
378 | break; | 378 | break; | ||
379 | } | 379 | } | ||
380 | 380 | | |||
381 | processed_size += bytesWritten; | 381 | processed_size += bytesWritten; | ||
382 | processedSize(processed_size); | 382 | processedSize(processed_size); | ||
383 | } | 383 | } | ||
Show All 16 Lines | |||||
400 | // Rename partial file to its original name. | 400 | // Rename partial file to its original name. | ||
401 | if (bMarkPartial) { | 401 | if (bMarkPartial) { | ||
402 | const QString sPart = partInfo.absoluteFilePath(); | 402 | const QString sPart = partInfo.absoluteFilePath(); | ||
403 | // Remove old dest file if it exists.. | 403 | // Remove old dest file if it exists.. | ||
404 | if (dstInfo.exists()) { | 404 | if (dstInfo.exists()) { | ||
405 | QFile::remove(dstFile); | 405 | QFile::remove(dstFile); | ||
406 | } | 406 | } | ||
407 | if (!QFile::rename(sPart, dstFile)) { | 407 | if (!QFile::rename(sPart, dstFile)) { | ||
408 | qCDebug(KIO_SMB) << "failed to rename" << sPart << "to" << dstFile; | 408 | qCDebug(KIO_SMB_LOG) << "failed to rename" << sPart << "to" << dstFile; | ||
409 | error(ERR_CANNOT_RENAME_PARTIAL, sPart); | 409 | error(ERR_CANNOT_RENAME_PARTIAL, sPart); | ||
410 | return; | 410 | return; | ||
411 | } | 411 | } | ||
412 | } | 412 | } | ||
413 | 413 | | |||
414 | // Restore the mtime on the file. | 414 | // Restore the mtime on the file. | ||
415 | const QString mtimeStr = metaData("modified"); | 415 | const QString mtimeStr = metaData("modified"); | ||
416 | qCDebug(KIO_SMB) << "modified:" << mtimeStr; | 416 | qCDebug(KIO_SMB_LOG) << "modified:" << mtimeStr; | ||
417 | if (!mtimeStr.isEmpty()) { | 417 | if (!mtimeStr.isEmpty()) { | ||
418 | QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate); | 418 | QDateTime dt = QDateTime::fromString(mtimeStr, Qt::ISODate); | ||
419 | if (dt.isValid()) { | 419 | if (dt.isValid()) { | ||
420 | struct utimbuf utbuf; | 420 | struct utimbuf utbuf; | ||
421 | utbuf.actime = QFileInfo(file).lastRead().toSecsSinceEpoch(); // access time, unchanged | 421 | utbuf.actime = QFileInfo(file).lastRead().toSecsSinceEpoch(); // access time, unchanged | ||
422 | utbuf.modtime = dt.toSecsSinceEpoch(); // modification time | 422 | utbuf.modtime = dt.toSecsSinceEpoch(); // modification time | ||
423 | utime(QFile::encodeName(dstFile).constData(), &utbuf); | 423 | utime(QFile::encodeName(dstFile).constData(), &utbuf); | ||
424 | } | 424 | } | ||
425 | } | 425 | } | ||
426 | 426 | | |||
427 | finished(); | 427 | finished(); | ||
428 | } | 428 | } | ||
429 | 429 | | |||
430 | void SMBSlave::smbCopyPut(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags) | 430 | void SMBSlave::smbCopyPut(const QUrl& ksrc, const QUrl& kdst, int permissions, KIO::JobFlags flags) | ||
431 | { | 431 | { | ||
432 | qCDebug(KIO_SMB) << "src = " << ksrc << ", dest = " << kdst; | 432 | qCDebug(KIO_SMB_LOG) << "src = " << ksrc << ", dest = " << kdst; | ||
433 | 433 | | |||
434 | QFile srcFile (ksrc.toLocalFile()); | 434 | QFile srcFile (ksrc.toLocalFile()); | ||
435 | const QFileInfo srcInfo (srcFile); | 435 | const QFileInfo srcInfo (srcFile); | ||
436 | 436 | | |||
437 | if (srcInfo.exists()) { | 437 | if (srcInfo.exists()) { | ||
438 | if (srcInfo.isDir()) { | 438 | if (srcInfo.isDir()) { | ||
439 | error(KIO::ERR_IS_DIRECTORY, ksrc.toDisplayString()); | 439 | error(KIO::ERR_IS_DIRECTORY, ksrc.toDisplayString()); | ||
440 | return; | 440 | return; | ||
441 | } | 441 | } | ||
442 | } else { | 442 | } else { | ||
443 | error(KIO::ERR_DOES_NOT_EXIST, ksrc.toDisplayString()); | 443 | error(KIO::ERR_DOES_NOT_EXIST, ksrc.toDisplayString()); | ||
444 | return; | 444 | return; | ||
445 | } | 445 | } | ||
446 | 446 | | |||
447 | if (!srcFile.open(QFile::ReadOnly)) { | 447 | if (!srcFile.open(QFile::ReadOnly)) { | ||
448 | qCDebug(KIO_SMB) << "could not read from" << ksrc; | 448 | qCDebug(KIO_SMB_LOG) << "could not read from" << ksrc; | ||
449 | switch (srcFile.error()) { | 449 | switch (srcFile.error()) { | ||
450 | case QFile::PermissionsError: | 450 | case QFile::PermissionsError: | ||
451 | error(KIO::ERR_WRITE_ACCESS_DENIED, ksrc.toDisplayString()); | 451 | error(KIO::ERR_WRITE_ACCESS_DENIED, ksrc.toDisplayString()); | ||
452 | break; | 452 | break; | ||
453 | case QFile::OpenError: | 453 | case QFile::OpenError: | ||
454 | default: | 454 | default: | ||
455 | error(KIO::ERR_CANNOT_OPEN_FOR_READING, ksrc.toDisplayString()); | 455 | error(KIO::ERR_CANNOT_OPEN_FOR_READING, ksrc.toDisplayString()); | ||
456 | break; | 456 | break; | ||
Show All 32 Lines | 483 | if (errNum == 0 && !(flags & KIO::Overwrite) && !(flags & KIO::Resume)) { | |||
489 | return; | 489 | return; | ||
490 | } | 490 | } | ||
491 | 491 | | |||
492 | KIO::filesize_t processed_size = 0; | 492 | KIO::filesize_t processed_size = 0; | ||
493 | const SMBUrl dstUrl(bMarkPartial ? dstOrigUrl.partUrl() : dstOrigUrl); | 493 | const SMBUrl dstUrl(bMarkPartial ? dstOrigUrl.partUrl() : dstOrigUrl); | ||
494 | 494 | | |||
495 | if (bResume) { | 495 | if (bResume) { | ||
496 | // append if resuming | 496 | // append if resuming | ||
497 | qCDebug(KIO_SMB) << "resume" << dstUrl; | 497 | qCDebug(KIO_SMB_LOG) << "resume" << dstUrl; | ||
498 | dstfd = smbc_open(dstUrl.toSmbcUrl(), O_RDWR, 0 ); | 498 | dstfd = smbc_open(dstUrl.toSmbcUrl(), O_RDWR, 0 ); | ||
499 | if (dstfd < 0) { | 499 | if (dstfd < 0) { | ||
500 | errNum = errno; | 500 | errNum = errno; | ||
501 | } else { | 501 | } else { | ||
502 | const off_t offset = smbc_lseek(dstfd, 0, SEEK_END); | 502 | const off_t offset = smbc_lseek(dstfd, 0, SEEK_END); | ||
503 | if (offset == (off_t)-1) { | 503 | if (offset == (off_t)-1) { | ||
504 | error(KIO::ERR_CANNOT_SEEK, dstUrl.toDisplayString()); | 504 | error(KIO::ERR_CANNOT_SEEK, dstUrl.toDisplayString()); | ||
505 | smbc_close(dstfd); | 505 | smbc_close(dstfd); | ||
506 | return; | 506 | return; | ||
507 | } else { | 507 | } else { | ||
508 | processed_size = offset; | 508 | processed_size = offset; | ||
509 | } | 509 | } | ||
510 | } | 510 | } | ||
511 | } else { | 511 | } else { | ||
512 | mode_t mode; | 512 | mode_t mode; | ||
513 | if (permissions == -1) { | 513 | if (permissions == -1) { | ||
514 | mode = 600; | 514 | mode = 600; | ||
515 | } else { | 515 | } else { | ||
516 | mode = permissions | S_IRUSR | S_IWUSR; | 516 | mode = permissions | S_IRUSR | S_IWUSR; | ||
517 | } | 517 | } | ||
518 | 518 | | |||
519 | qCDebug(KIO_SMB) << "NO resume" << dstUrl; | 519 | qCDebug(KIO_SMB_LOG) << "NO resume" << dstUrl; | ||
520 | dstfd = smbc_open(dstUrl.toSmbcUrl(), O_CREAT | O_TRUNC | O_WRONLY, mode); | 520 | dstfd = smbc_open(dstUrl.toSmbcUrl(), O_CREAT | O_TRUNC | O_WRONLY, mode); | ||
521 | if (dstfd < 0) { | 521 | if (dstfd < 0) { | ||
522 | errNum = errno; | 522 | errNum = errno; | ||
523 | } | 523 | } | ||
524 | } | 524 | } | ||
525 | 525 | | |||
526 | if (dstfd < 0) { | 526 | if (dstfd < 0) { | ||
527 | if (errNum == EACCES) { | 527 | if (errNum == EACCES) { | ||
528 | qCDebug(KIO_SMB) << "access denied"; | 528 | qCDebug(KIO_SMB_LOG) << "access denied"; | ||
529 | error( KIO::ERR_WRITE_ACCESS_DENIED, dstUrl.toDisplayString()); | 529 | error( KIO::ERR_WRITE_ACCESS_DENIED, dstUrl.toDisplayString()); | ||
530 | } | 530 | } | ||
531 | else { | 531 | else { | ||
532 | qCDebug(KIO_SMB) << "can not open for writing"; | 532 | qCDebug(KIO_SMB_LOG) << "can not open for writing"; | ||
533 | error( KIO::ERR_CANNOT_OPEN_FOR_WRITING, dstUrl.toDisplayString()); | 533 | error( KIO::ERR_CANNOT_OPEN_FOR_WRITING, dstUrl.toDisplayString()); | ||
534 | } | 534 | } | ||
535 | return; | 535 | return; | ||
536 | } | 536 | } | ||
537 | 537 | | |||
538 | bool isErr = false; | 538 | bool isErr = false; | ||
539 | 539 | | |||
540 | if (processed_size == 0 || srcFile.seek(processed_size)) { | 540 | if (processed_size == 0 || srcFile.seek(processed_size)) { | ||
Show All 22 Lines | |||||
563 | } | 563 | } | ||
564 | } else { | 564 | } else { | ||
565 | isErr = true; | 565 | isErr = true; | ||
566 | error(KIO::ERR_CANNOT_SEEK, ksrc.toDisplayString()); | 566 | error(KIO::ERR_CANNOT_SEEK, ksrc.toDisplayString()); | ||
567 | } | 567 | } | ||
568 | 568 | | |||
569 | // FINISHED | 569 | // FINISHED | ||
570 | if (smbc_close(dstfd) < 0) { | 570 | if (smbc_close(dstfd) < 0) { | ||
571 | qCDebug(KIO_SMB) << dstUrl << "could not write"; | 571 | qCDebug(KIO_SMB_LOG) << dstUrl << "could not write"; | ||
572 | error( KIO::ERR_CANNOT_WRITE, dstUrl.toDisplayString()); | 572 | error( KIO::ERR_CANNOT_WRITE, dstUrl.toDisplayString()); | ||
573 | return; | 573 | return; | ||
574 | } | 574 | } | ||
575 | 575 | | |||
576 | // Handle error condition. | 576 | // Handle error condition. | ||
577 | if (isErr) { | 577 | if (isErr) { | ||
578 | if (bMarkPartial) { | 578 | if (bMarkPartial) { | ||
579 | const int size = configValue(QStringLiteral("MinimumKeepSize"), DEFAULT_MINIMUM_KEEP_SIZE); | 579 | const int size = configValue(QStringLiteral("MinimumKeepSize"), DEFAULT_MINIMUM_KEEP_SIZE); | ||
580 | const int errNum = cache_stat(dstUrl, &st); | 580 | const int errNum = cache_stat(dstUrl, &st); | ||
581 | if (errNum == 0 && st.st_size < size) { | 581 | if (errNum == 0 && st.st_size < size) { | ||
582 | smbc_unlink(dstUrl.toSmbcUrl()); | 582 | smbc_unlink(dstUrl.toSmbcUrl()); | ||
583 | } | 583 | } | ||
584 | } | 584 | } | ||
585 | return; | 585 | return; | ||
586 | } | 586 | } | ||
587 | 587 | | |||
588 | // Rename partial file to its original name. | 588 | // Rename partial file to its original name. | ||
589 | if (bMarkPartial) { | 589 | if (bMarkPartial) { | ||
590 | smbc_unlink(dstOrigUrl.toSmbcUrl()); | 590 | smbc_unlink(dstOrigUrl.toSmbcUrl()); | ||
591 | if (smbc_rename(dstUrl.toSmbcUrl(), dstOrigUrl.toSmbcUrl()) < 0) { | 591 | if (smbc_rename(dstUrl.toSmbcUrl(), dstOrigUrl.toSmbcUrl()) < 0) { | ||
592 | qCDebug(KIO_SMB) << "failed to rename" << dstUrl << "to" << dstOrigUrl << "->" << strerror(errno); | 592 | qCDebug(KIO_SMB_LOG) << "failed to rename" << dstUrl << "to" << dstOrigUrl << "->" << strerror(errno); | ||
593 | error(ERR_CANNOT_RENAME_PARTIAL, dstUrl.toDisplayString()); | 593 | error(ERR_CANNOT_RENAME_PARTIAL, dstUrl.toDisplayString()); | ||
594 | return; | 594 | return; | ||
595 | } | 595 | } | ||
596 | } | 596 | } | ||
597 | 597 | | |||
598 | #ifdef HAVE_UTIME_H | 598 | #ifdef HAVE_UTIME_H | ||
599 | // set modification time | 599 | // set modification time | ||
600 | const QString mtimeStr = metaData( "modified" ); | 600 | const QString mtimeStr = metaData( "modified" ); | ||
Show All 10 Lines | 610 | #endif | |||
611 | 611 | | |||
612 | // We have done our job => finish | 612 | // We have done our job => finish | ||
613 | finished(); | 613 | finished(); | ||
614 | } | 614 | } | ||
615 | 615 | | |||
616 | //=========================================================================== | 616 | //=========================================================================== | ||
617 | void SMBSlave::del( const QUrl &kurl, bool isfile) | 617 | void SMBSlave::del( const QUrl &kurl, bool isfile) | ||
618 | { | 618 | { | ||
619 | qCDebug(KIO_SMB) << kurl; | 619 | qCDebug(KIO_SMB_LOG) << kurl; | ||
620 | m_current_url = kurl; | 620 | m_current_url = kurl; | ||
621 | int errNum = 0; | 621 | int errNum = 0; | ||
622 | int retVal = 0; | 622 | int retVal = 0; | ||
623 | 623 | | |||
624 | if(isfile) | 624 | if(isfile) | ||
625 | { | 625 | { | ||
626 | // Delete file | 626 | // Delete file | ||
627 | qCDebug(KIO_SMB) << "Deleting file" << kurl; | 627 | qCDebug(KIO_SMB_LOG) << "Deleting file" << kurl; | ||
628 | retVal = smbc_unlink(m_current_url.toSmbcUrl()); | 628 | retVal = smbc_unlink(m_current_url.toSmbcUrl()); | ||
629 | if ( retVal < 0 ){ | 629 | if ( retVal < 0 ){ | ||
630 | errNum = errno; | 630 | errNum = errno; | ||
631 | } else { | 631 | } else { | ||
632 | errNum = 0; | 632 | errNum = 0; | ||
633 | } | 633 | } | ||
634 | } | 634 | } | ||
635 | else | 635 | else | ||
636 | { | 636 | { | ||
637 | qCDebug(KIO_SMB) << "Deleting directory" << kurl; | 637 | qCDebug(KIO_SMB_LOG) << "Deleting directory" << kurl; | ||
638 | // Delete directory | 638 | // Delete directory | ||
639 | retVal = smbc_rmdir(m_current_url.toSmbcUrl()); | 639 | retVal = smbc_rmdir(m_current_url.toSmbcUrl()); | ||
640 | if( retVal < 0 ) { | 640 | if( retVal < 0 ) { | ||
641 | errNum = errno; | 641 | errNum = errno; | ||
642 | } else { | 642 | } else { | ||
643 | errNum = 0; | 643 | errNum = 0; | ||
644 | } | 644 | } | ||
645 | } | 645 | } | ||
646 | 646 | | |||
647 | if( errNum != 0 ) | 647 | if( errNum != 0 ) | ||
648 | { | 648 | { | ||
649 | reportError(kurl, errNum); | 649 | reportError(kurl, errNum); | ||
650 | } | 650 | } | ||
651 | else | 651 | else | ||
652 | { | 652 | { | ||
653 | finished(); | 653 | finished(); | ||
654 | } | 654 | } | ||
655 | } | 655 | } | ||
656 | 656 | | |||
657 | //=========================================================================== | 657 | //=========================================================================== | ||
658 | void SMBSlave::mkdir( const QUrl &kurl, int permissions ) | 658 | void SMBSlave::mkdir( const QUrl &kurl, int permissions ) | ||
659 | { | 659 | { | ||
660 | qCDebug(KIO_SMB) << kurl; | 660 | qCDebug(KIO_SMB_LOG) << kurl; | ||
661 | int errNum = 0; | 661 | int errNum = 0; | ||
662 | int retVal = 0; | 662 | int retVal = 0; | ||
663 | m_current_url = kurl; | 663 | m_current_url = kurl; | ||
664 | 664 | | |||
665 | retVal = smbc_mkdir(m_current_url.toSmbcUrl(), 0777); | 665 | retVal = smbc_mkdir(m_current_url.toSmbcUrl(), 0777); | ||
666 | if( retVal < 0 ){ | 666 | if( retVal < 0 ){ | ||
667 | errNum = errno; | 667 | errNum = errno; | ||
668 | } else { | 668 | } else { | ||
Show All 12 Lines | 674 | if (errNum == EEXIST) { | |||
681 | { | 681 | { | ||
682 | error( KIO::ERR_FILE_ALREADY_EXIST, m_current_url.toDisplayString()); | 682 | error( KIO::ERR_FILE_ALREADY_EXIST, m_current_url.toDisplayString()); | ||
683 | } | 683 | } | ||
684 | } | 684 | } | ||
685 | else | 685 | else | ||
686 | { | 686 | { | ||
687 | reportError(kurl, errNum); | 687 | reportError(kurl, errNum); | ||
688 | } | 688 | } | ||
689 | qCDebug(KIO_SMB) << "exit with error " << kurl; | 689 | qCDebug(KIO_SMB_LOG) << "exit with error " << kurl; | ||
690 | } | 690 | } | ||
691 | else // success | 691 | else // success | ||
692 | { | 692 | { | ||
693 | if(permissions != -1) | 693 | if(permissions != -1) | ||
694 | { | 694 | { | ||
695 | // TODO enable the following when complete | 695 | // TODO enable the following when complete | ||
696 | //smbc_chmod( url.toSmbcUrl(), permissions ); | 696 | //smbc_chmod( url.toSmbcUrl(), permissions ); | ||
697 | } | 697 | } | ||
698 | finished(); | 698 | finished(); | ||
699 | } | 699 | } | ||
700 | } | 700 | } | ||
701 | 701 | | |||
702 | 702 | | |||
703 | //=========================================================================== | 703 | //=========================================================================== | ||
704 | void SMBSlave::rename( const QUrl& ksrc, const QUrl& kdest, KIO::JobFlags flags ) | 704 | void SMBSlave::rename( const QUrl& ksrc, const QUrl& kdest, KIO::JobFlags flags ) | ||
705 | { | 705 | { | ||
706 | 706 | | |||
707 | SMBUrl src; | 707 | SMBUrl src; | ||
708 | SMBUrl dst; | 708 | SMBUrl dst; | ||
709 | int errNum = 0; | 709 | int errNum = 0; | ||
710 | int retVal = 0; | 710 | int retVal = 0; | ||
711 | 711 | | |||
712 | qCDebug(KIO_SMB) << "old name = " << ksrc << ", new name = " << kdest; | 712 | qCDebug(KIO_SMB_LOG) << "old name = " << ksrc << ", new name = " << kdest; | ||
713 | 713 | | |||
714 | src = ksrc; | 714 | src = ksrc; | ||
715 | dst = kdest; | 715 | dst = kdest; | ||
716 | 716 | | |||
717 | // Check to se if the destination exists | 717 | // Check to se if the destination exists | ||
718 | 718 | | |||
719 | qCDebug(KIO_SMB) << "stat dst"; | 719 | qCDebug(KIO_SMB_LOG) << "stat dst"; | ||
720 | errNum = cache_stat(dst, &st); | 720 | errNum = cache_stat(dst, &st); | ||
721 | if( errNum == 0 ) | 721 | if( errNum == 0 ) | ||
722 | { | 722 | { | ||
723 | if(S_ISDIR(st.st_mode)) | 723 | if(S_ISDIR(st.st_mode)) | ||
724 | { | 724 | { | ||
725 | qCDebug(KIO_SMB) << "KIO::ERR_DIR_ALREADY_EXIST"; | 725 | qCDebug(KIO_SMB_LOG) << "KIO::ERR_DIR_ALREADY_EXIST"; | ||
726 | error( KIO::ERR_DIR_ALREADY_EXIST, dst.toDisplayString()); | 726 | error( KIO::ERR_DIR_ALREADY_EXIST, dst.toDisplayString()); | ||
727 | return; | 727 | return; | ||
728 | } | 728 | } | ||
729 | if(!(flags & KIO::Overwrite)) | 729 | if(!(flags & KIO::Overwrite)) | ||
730 | { | 730 | { | ||
731 | qCDebug(KIO_SMB) << "KIO::ERR_FILE_ALREADY_EXIST"; | 731 | qCDebug(KIO_SMB_LOG) << "KIO::ERR_FILE_ALREADY_EXIST"; | ||
732 | error( KIO::ERR_FILE_ALREADY_EXIST, dst.toDisplayString()); | 732 | error( KIO::ERR_FILE_ALREADY_EXIST, dst.toDisplayString()); | ||
733 | return; | 733 | return; | ||
734 | } | 734 | } | ||
735 | } | 735 | } | ||
736 | qCDebug(KIO_SMB ) << "smbc_rename " << src.toSmbcUrl() << " " << dst.toSmbcUrl(); | 736 | qCDebug(KIO_SMB_LOG) << "smbc_rename " << src.toSmbcUrl() << " " << dst.toSmbcUrl(); | ||
737 | retVal = smbc_rename(src.toSmbcUrl(), dst.toSmbcUrl()); | 737 | retVal = smbc_rename(src.toSmbcUrl(), dst.toSmbcUrl()); | ||
738 | if( retVal < 0 ){ | 738 | if( retVal < 0 ){ | ||
739 | errNum = errno; | 739 | errNum = errno; | ||
740 | } else { | 740 | } else { | ||
741 | errNum = 0; | 741 | errNum = 0; | ||
742 | } | 742 | } | ||
743 | 743 | | |||
744 | if( retVal < 0 ) | 744 | if( retVal < 0 ) | ||
745 | { | 745 | { | ||
746 | qCDebug(KIO_SMB ) << "failed "; | 746 | qCDebug(KIO_SMB_LOG) << "failed "; | ||
747 | switch(errNum) | 747 | switch(errNum) | ||
748 | { | 748 | { | ||
749 | case ENOENT: | 749 | case ENOENT: | ||
750 | errNum = cache_stat(src, &st); | 750 | errNum = cache_stat(src, &st); | ||
751 | if( errNum != 0 ) | 751 | if( errNum != 0 ) | ||
752 | { | 752 | { | ||
753 | if(errNum == EACCES) | 753 | if(errNum == EACCES) | ||
754 | { | 754 | { | ||
755 | qCDebug(KIO_SMB) << "KIO::ERR_ACCESS_DENIED"; | 755 | qCDebug(KIO_SMB_LOG) << "KIO::ERR_ACCESS_DENIED"; | ||
756 | error(KIO::ERR_ACCESS_DENIED, src.toDisplayString()); | 756 | error(KIO::ERR_ACCESS_DENIED, src.toDisplayString()); | ||
757 | } | 757 | } | ||
758 | else | 758 | else | ||
759 | { | 759 | { | ||
760 | qCDebug(KIO_SMB) << "KIO::ERR_DOES_NOT_EXIST"; | 760 | qCDebug(KIO_SMB_LOG) << "KIO::ERR_DOES_NOT_EXIST"; | ||
761 | error(KIO::ERR_DOES_NOT_EXIST, src.toDisplayString()); | 761 | error(KIO::ERR_DOES_NOT_EXIST, src.toDisplayString()); | ||
762 | } | 762 | } | ||
763 | } | 763 | } | ||
764 | break; | 764 | break; | ||
765 | 765 | | |||
766 | case EACCES: | 766 | case EACCES: | ||
767 | case EPERM: | 767 | case EPERM: | ||
768 | qCDebug(KIO_SMB) << "KIO::ERR_ACCESS_DENIED"; | 768 | qCDebug(KIO_SMB_LOG) << "KIO::ERR_ACCESS_DENIED"; | ||
769 | error( KIO::ERR_ACCESS_DENIED, dst.toDisplayString() ); | 769 | error( KIO::ERR_ACCESS_DENIED, dst.toDisplayString() ); | ||
770 | break; | 770 | break; | ||
771 | 771 | | |||
772 | default: | 772 | default: | ||
773 | qCDebug(KIO_SMB) << "KIO::ERR_CANNOT_RENAME"; | 773 | qCDebug(KIO_SMB_LOG) << "KIO::ERR_CANNOT_RENAME"; | ||
774 | error( KIO::ERR_CANNOT_RENAME, src.toDisplayString() ); | 774 | error( KIO::ERR_CANNOT_RENAME, src.toDisplayString() ); | ||
775 | 775 | | |||
776 | } | 776 | } | ||
777 | 777 | | |||
778 | qCDebug(KIO_SMB) << "exit with error"; | 778 | qCDebug(KIO_SMB_LOG) << "exit with error"; | ||
779 | return; | 779 | return; | ||
780 | } | 780 | } | ||
781 | 781 | | |||
782 | qCDebug(KIO_SMB ) << "everything fine\n"; | 782 | qCDebug(KIO_SMB_LOG) << "everything fine\n"; | ||
783 | finished(); | 783 | finished(); | ||
784 | } | 784 | } |