Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/bdsh/cmds/modules/cp/cp.c

    r1569a9b r582a0b8  
    2828
    2929#include <errno.h>
    30 #include <str_error.h>
    3130#include <stdio.h>
    3231#include <stdlib.h>
     
    6766} dentry_type_t;
    6867
    69 static int copy_file(const char *src, const char *dest,
     68static int64_t copy_file(const char *src, const char *dest,
    7069    size_t blen, int vb);
    7170
     
    176175}
    177176
    178 static int do_copy(const char *src, const char *dest,
     177static int64_t do_copy(const char *src, const char *dest,
    179178    size_t blen, int vb, int recursive, int force, int interactive)
    180179{
    181         int rc = EOK;
     180        int r = -1;
    182181        char dest_path[PATH_MAX];
    183182        char src_path[PATH_MAX];
     
    218217                                printf("The dest directory %s does not exists",
    219218                                    dest_path);
    220                                 rc = ENOENT;
    221219                                goto exit;
    222220                        }
     
    226224                        printf("Cannot overwrite existing directory %s\n",
    227225                            dest_path);
    228                         rc = EEXIST;
    229226                        goto exit;
    230227                } else if (dest_type == TYPE_FILE) {
     
    236233                         */
    237234                        if (force && !interactive) {
    238                                 rc = vfs_unlink_path(dest_path);
    239                                 if (rc != EOK) {
     235                                if (vfs_unlink_path(dest_path) != EOK) {
    240236                                        printf("Unable to remove %s\n",
    241237                                            dest_path);
     
    248244                                if (overwrite) {
    249245                                        printf("Overwriting file: %s\n", dest_path);
    250                                         rc = vfs_unlink_path(dest_path);
    251                                         if (rc != EOK) {
     246                                        if (vfs_unlink_path(dest_path) != EOK) {
    252247                                                printf("Unable to remove %s\n", dest_path);
    253248                                                goto exit;
     
    255250                                } else {
    256251                                        printf("Not overwriting file: %s\n", dest_path);
    257                                         rc = EOK;
     252                                        r = 0;
    258253                                        goto exit;
    259254                                }
    260255                        } else {
    261256                                printf("File already exists: %s\n", dest_path);
    262                                 rc = EEXIST;
    263257                                goto exit;
    264258                        }
     
    266260
    267261                /* call copy_file and exit */
    268                 if (copy_file(src, dest_path, blen, vb) < 0) {
    269                         rc = EIO;
    270                 }
     262                r = (copy_file(src, dest_path, blen, vb) < 0);
    271263
    272264        } else if (src_type == TYPE_DIR) {
     
    276268                        printf("Cannot copy the %s directory without the "
    277269                            "-r option\n", src);
    278                         rc = EINVAL;
    279270                        goto exit;
    280271                } else if (dest_type == TYPE_FILE) {
    281272                        printf("Cannot overwrite a file with a directory\n");
    282                         rc = EEXIST;
    283273                        goto exit;
    284274                }
     
    303293                                merge_paths(dest_path, PATH_MAX, src_dirname);
    304294
    305                                 rc = vfs_link_path(dest_path, KIND_DIRECTORY,
    306                                     NULL);
    307                                 if (rc != EOK) {
     295                                if (vfs_link_path(dest_path, KIND_DIRECTORY,
     296                                    NULL) != EOK) {
    308297                                        printf("Unable to create "
    309298                                            "dest directory %s\n", dest_path);
     
    319308                         * e.g. cp -r /src /data/new_dir_src
    320309                         */
    321                         rc = vfs_link_path(dest_path, KIND_DIRECTORY, NULL);
    322                         if (rc != EOK) {
     310                        if (vfs_link_path(dest_path, KIND_DIRECTORY,
     311                            NULL) != EOK) {
    323312                                printf("Unable to create "
    324313                                    "dest directory %s\n", dest_path);
     
    332321                        /* Something strange is happening... */
    333322                        printf("Unable to open src %s directory\n", src);
    334                         rc = ENOENT;
    335323                        goto exit;
    336324                }
     
    360348                                printf("Cannot copy a directory "
    361349                                    "into itself\n");
    362                                 rc = EEXIST;
    363350                                goto exit;
    364351                        }
     
    368355
    369356                        /* Recursively call do_copy() */
    370                         rc = do_copy(src_dent, dest_dent, blen, vb, recursive,
     357                        r = do_copy(src_dent, dest_dent, blen, vb, recursive,
    371358                            force, interactive);
    372                         if (rc != EOK)
     359                        if (r)
    373360                                goto exit;
    374361
     
    380367        if (dir)
    381368                closedir(dir);
    382         return rc;
    383 }
    384 
    385 static int copy_file(const char *src, const char *dest,
     369        return r;
     370}
     371
     372static int64_t copy_file(const char *src, const char *dest,
    386373        size_t blen, int vb)
    387374{
    388         int fd1, fd2;
    389         size_t rbytes, wbytes;
    390         int rc;
     375        int fd1, fd2, bytes;
    391376        off64_t total;
     377        int64_t copied = 0;
    392378        char *buff = NULL;
    393379        aoff64_t posr = 0, posw = 0;
     
    397383                printf("Copying %s to %s\n", src, dest);
    398384
    399         rc = vfs_lookup_open(src, WALK_REGULAR, MODE_READ, &fd1);
    400         if (rc != EOK) {
     385        fd1 = vfs_lookup_open(src, WALK_REGULAR, MODE_READ);
     386        if (fd1 < 0) {
    401387                printf("Unable to open source file %s\n", src);
    402388                return -1;
    403389        }
    404390
    405         rc = vfs_lookup_open(dest, WALK_REGULAR | WALK_MAY_CREATE, MODE_WRITE, &fd2);
    406         if (rc != EOK) {
     391        fd2 = vfs_lookup_open(dest, WALK_REGULAR | WALK_MAY_CREATE, MODE_WRITE);
     392        if (fd2 < 0) {
    407393                printf("Unable to open destination file %s\n", dest);
    408394                vfs_put(fd1);
     
    424410                printf("Unable to allocate enough memory to read %s\n",
    425411                    src);
    426                 rc = ENOMEM;
     412                copied = -1;
    427413                goto out;
    428414        }
    429415
    430         while ((rc = vfs_read(fd1, &posr, buff, blen, &rbytes)) == EOK &&
    431             rbytes > 0) {
    432                 if ((rc = vfs_write(fd2, &posw, buff, rbytes, &wbytes)) != EOK)
    433                         break;
    434         }
    435 
    436         if (rc != EOK) {
    437                 printf("\nError copying %s: %s\n", src, str_error(rc));
    438                 return -1;
     416        while ((bytes = vfs_read(fd1, &posr, buff, blen)) > 0) {
     417                if ((bytes = vfs_write(fd2, &posw, buff, bytes)) < 0)
     418                        break;
     419                copied += bytes;
     420        }
     421
     422        if (bytes < 0) {
     423                printf("\nError copying %s, (%d)\n", src, bytes);
     424                copied = bytes;
    439425        }
    440426
     
    444430        if (buff)
    445431                free(buff);
    446         if (rc != EOK) {
    447                 return -1;
    448         } else {
    449                 return 0;
    450         }
     432        return copied;
    451433}
    452434
     
    479461        int force = 0, interactive = 0;
    480462        int c, opt_ind;
    481         int ret;
     463        int64_t ret;
    482464
    483465        con = console_init(stdin, stdout);
Note: See TracChangeset for help on using the changeset viewer.