Changeset 59ed424e in mainline


Ignore:
Timestamp:
2026-02-11T12:02:03Z (28 hours ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
f9c30b9a
Parents:
857fba8
git-author:
Jiri Svoboda <jiri@…> (2026-02-10 20:01:03)
git-committer:
Jiri Svoboda <jiri@…> (2026-02-11 12:02:03)
Message:

Do not print error when user requests abort because file exists.

Location:
uspace
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/copy/copy.c

    r857fba8 r59ed424e  
    210210
    211211        if (nonint)
    212                 return fmgt_exr_abort;
     212                return fmgt_exr_fail;
    213213
    214214        if (prog_upd)

  • uspace/lib/fmgt/include/types/fmgt.h

    r857fba8 r59ed424e  
    103103        fmgt_exr_skip,
    104104        /** Abort */
    105         fmgt_exr_abort
     105        fmgt_exr_abort,
     106        /** Fail */
     107        fmgt_exr_fail
    106108} fmgt_exists_action_t;
    107109
    … …  
    159161} fmgt_flist_entry_t;
    160162
     163/** File system tree walk. */
     164typedef struct {
     165        /** Parameters */
     166        struct fmgt_walk_params *params;
     167        /** Stop walk. */
     168        bool stop;
     169} fmgt_walk_t;
     170
    161171/** File system tree walk callbacks */
    162172typedef struct {
    163         errno_t (*dir_enter)(void *, const char *, const char *);
    164         errno_t (*dir_leave)(void *, const char *, const char *);
    165         errno_t (*file)(void *, const char *, const char *);
     173        errno_t (*dir_enter)(fmgt_walk_t *, const char *, const char *);
     174        errno_t (*dir_leave)(fmgt_walk_t *, const char *, const char *);
     175        errno_t (*file)(fmgt_walk_t *, const char *, const char *);
    166176} fmgt_walk_cb_t;
    167177
    168178/** File system tree walk parameters */
    169 typedef struct {
     179typedef struct fmgt_walk_params {
    170180        /** List of files or directories (walk roots) */
    171181        fmgt_flist_t *flist;

  • uspace/lib/fmgt/private/fsops.h

    r857fba8 r59ed424e  
    4444
    4545errno_t fmgt_open(fmgt_t *, const char *, int *);
    46 errno_t fmgt_create_file(fmgt_t *, const char *, int *, bool *);
     46errno_t fmgt_create_file(fmgt_t *, const char *, int *, fmgt_exists_action_t *);
    4747errno_t fmgt_create_dir(fmgt_t *, const char *);
    4848errno_t fmgt_read(fmgt_t *, int, const char *, aoff64_t *, void *, size_t,

  • uspace/lib/fmgt/src/copy.c

    r857fba8 r59ed424e  
    4343#include "../private/fsops.h"
    4444
    45 static errno_t fmgt_copy_dir_enter(void *, const char *, const char *);
    46 static errno_t fmgt_copy_file(void *, const char *, const char *);
     45static errno_t fmgt_copy_dir_enter(fmgt_walk_t *, const char *, const char *);
     46static errno_t fmgt_copy_file(fmgt_walk_t *, const char *, const char *);
    4747
    4848static fmgt_walk_cb_t fmgt_copy_cb = {
    … …  
    5353/** Copy operation - enter directory.
    5454 *
    55  * @param arg Argument (fmgt_t *)
     55 * @param walk Walk
    5656 * @param fname Source directory name
    5757 * @param dest Destination directory name
    5858 * @return EOK on success or an error code
    5959 */
    60 static errno_t fmgt_copy_dir_enter(void *arg, const char *src, const char *dest)
     60static errno_t fmgt_copy_dir_enter(fmgt_walk_t *walk, const char *src,
     61    const char *dest)
    6162{
    62         fmgt_t *fmgt = (fmgt_t *)arg;
     63        fmgt_t *fmgt = (fmgt_t *)walk->params->arg;
    6364
    6465        (void)dest;
    … …  
    6869/** Copy single file.
    6970 *
    70  * @param arg Argument (fmgt_t *)
     71 * @param walk Walk
    7172 * @param fname Source file name
    7273 * @param dest Destination file name
    7374 * @return EOK on success or an error code
    7475 */
    75 static errno_t fmgt_copy_file(void *arg, const char *src, const char *dest)
     76static errno_t fmgt_copy_file(fmgt_walk_t *walk, const char *src,
     77    const char *dest)
    7678{
    77         fmgt_t *fmgt = (fmgt_t *)arg;
     79        fmgt_t *fmgt = (fmgt_t *)walk->params->arg;
     80        fmgt_exists_action_t exaction;
    7881        int rfd;
    7982        int wfd;
    … …  
    8285        aoff64_t wpos = 0;
    8386        char *buffer;
    84         bool skip;
    8587        errno_t rc;
    8688
    … …  
    9597        }
    9698
    97         rc = fmgt_create_file(fmgt, dest, &wfd, &skip);
     99        rc = fmgt_create_file(fmgt, dest, &wfd, &exaction);
    98100        if (rc != EOK) {
    99101                free(buffer);
    100102                vfs_put(rfd);
    101103
    102                 /* User decided to skip and continue. */
    103                 if (rc == EEXIST && skip)
     104                if (rc == EEXIST && exaction != fmgt_exr_fail) {
     105                        if (exaction == fmgt_exr_abort)
     106                                walk->stop = true;
    104107                        return EOK;
     108                }
     109
    105110                return rc;
    106111        }

  • uspace/lib/fmgt/src/fsops.c

    r857fba8 r59ed424e  
    8181 * @param fname Destination file name
    8282 * @param rfd Place to store file descriptor
    83  * @param rskip If @c true, skip existing file and continue
    84  * @return EOK on success or an error code
    85  */
    86 errno_t fmgt_create_file(fmgt_t *fmgt, const char *fname, int *rfd, bool *rskip)
     83 * @param raction If return value is EEXIST, fills in the action to take.
     84 * @return EOK on success or an error code
     85 */
     86errno_t fmgt_create_file(fmgt_t *fmgt, const char *fname, int *rfd,
     87    fmgt_exists_action_t *raction)
    8788{
    8889        fmgt_io_error_t err;
    … …  
    9394        unsigned flags;
    9495        errno_t rc;
    95 
    96         *rskip = false;
    9796
    9897        do {
    … …  
    110109                        fmgt_timer_start(fmgt);
    111110
    112                         if (exaction == fmgt_exr_skip)
    113                                 *rskip = true;
     111                        *raction = exaction;
    114112                        if (exaction != fmgt_exr_overwrite)
    115113                                break;

  • uspace/lib/fmgt/src/verify.c

    r857fba8 r59ed424e  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
     2 * Copyright (c) 2026 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4242#include "../private/fmgt.h"
    4343
    44 static errno_t fmgt_verify_file(void *, const char *, const char *);
     44static errno_t fmgt_verify_file(fmgt_walk_t *, const char *, const char *);
    4545
    4646static fmgt_walk_cb_t fmgt_verify_cb = {
    … …  
    5050/** Verify a single file.
    5151 *
    52  * @param arg Argument (fmgt_t *)
     52 * @param walk Walk
    5353 * @param fname File name
    5454 * @param unused Unused
    5555 * @return EOK on success or an error code
    5656 */
    57 static errno_t fmgt_verify_file(void *arg, const char *fname,
     57static errno_t fmgt_verify_file(fmgt_walk_t *walk, const char *fname,
    5858    const char *unused)
    5959{
    60         fmgt_t *fmgt = (fmgt_t *)arg;
     60        fmgt_t *fmgt = (fmgt_t *)walk->params->arg;
    6161        int fd;
    6262        size_t nr;

  • uspace/lib/fmgt/src/walk.c

    r857fba8 r59ed424e  
    11/*
    2  * Copyright (c) 2025 Jiri Svoboda
     2 * Copyright (c) 2026 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4646#include "fmgt/walk.h"
    4747
    48 static errno_t fmgt_walk_subtree(fmgt_walk_params_t *, const char *,
    49     const char *);
     48static errno_t fmgt_walk_subtree(fmgt_walk_t *, const char *, const char *);
    5049
    5150/** Initialize walk parameters.
    … …  
    6362/** Walk file (invoke file callback).
    6463 *
    65  * @param params Walk parameters
     64 * @param walk Walk
    6665 * @param fname Source path
    6766 * @param dest Destination path
    … …  
    6968 * @return EOK on success or an error code
    7069 */
    71 static errno_t fmgt_walk_file(fmgt_walk_params_t *params, const char *fname,
    72     const char *dest)
    73 {
    74         if (params->cb->file != NULL)
    75                 return params->cb->file(params->arg, fname, dest);
     70static errno_t fmgt_walk_file(fmgt_walk_t *walk, const char *fname,
     71    const char *dest)
     72{
     73        if (walk->params->cb->file != NULL)
     74                return walk->params->cb->file(walk, fname, dest);
    7675        else
    7776                return EOK;
    … …  
    8079/** Enter directory (invoke directory entry callback).
    8180 *
    82  * @param params Walk parameters
     81 * @param walk Walk
    8382 * @param dname Source directory
    8483 * @param dest Destination path
    8584 * @return EOK on success or an error code
    8685 */
    87 static errno_t fmgt_walk_dir_enter(fmgt_walk_params_t *params,
    88     const char *dname, const char *dest)
    89 {
    90         if (params->cb->dir_enter != NULL)
    91                 return params->cb->dir_enter(params->arg, dname, dest);
     86static errno_t fmgt_walk_dir_enter(fmgt_walk_t *walk, const char *dname,
     87    const char *dest)
     88{
     89        if (walk->params->cb->dir_enter != NULL)
     90                return walk->params->cb->dir_enter(walk, dname, dest);
    9291        else
    9392                return EOK;
    … …  
    9695/** Leave directory (invoke directory exit callback).
    9796 *
    98  * @param params Walk parameters
     97 * @param walk Walk
    9998 * @param dname Directory path
    10099 * @param dest Destination path
    101100 * @return EOK on success or an error code
    102101 */
    103 static errno_t fmgt_walk_dir_leave(fmgt_walk_params_t *params,
    104     const char *dname, const char *dest)
    105 {
    106         if (params->cb->dir_leave != NULL)
    107                 return params->cb->dir_leave(params->arg, dname, dest);
     102static errno_t fmgt_walk_dir_leave(fmgt_walk_t *walk, const char *dname,
     103    const char *dest)
     104{
     105        if (walk->params->cb->dir_leave != NULL)
     106                return walk->params->cb->dir_leave(walk, dname, dest);
    108107        else
    109108                return EOK;
    … …  
    112111/** Walk directory.
    113112 *
    114  * @param params Walk parameters
     113 * @param walk Walk
    115114 * @param dname Directory name
    116115 * @param dest Destination path or @c NULL
    117116 * @return EOK on success or an error code
    118117 */
    119 static errno_t fmgt_walk_dir(fmgt_walk_params_t *params, const char *dname,
     118static errno_t fmgt_walk_dir(fmgt_walk_t *walk, const char *dname,
    120119    const char *dest)
    121120{
    … …  
    127126        int rv;
    128127
    129         rc = fmgt_walk_dir_enter(params, dname, dest);
     128        rc = fmgt_walk_dir_enter(walk, dname, dest);
    130129        if (rc != EOK)
    131130                goto error;
    … …  
    138137
    139138        de = readdir(dir);
    140         while (de != NULL) {
     139        while (!walk->stop && de != NULL) {
    141140                rv = asprintf(&srcpath, "%s/%s", dname, de->d_name);
    142141                if (rv < 0) {
    … …  
    154153                }
    155154
    156                 rc = fmgt_walk_subtree(params, srcpath, destpath);
     155                rc = fmgt_walk_subtree(walk, srcpath, destpath);
    157156                if (rc != EOK) {
    158157                        free(srcpath);
    … …  
    168167        }
    169168
    170         rc = fmgt_walk_dir_leave(params, dname, dest);
     169        rc = fmgt_walk_dir_leave(walk, dname, dest);
    171170        if (rc != EOK)
    172171                return rc;
    … …  
    182181/** Walk subtree.
    183182 *
    184  * @param params Walk parameters.
    185  * @param fname Subtree path.
     183 * @param walk Walk
     184 * @param fname Subtree path
    186185 * @param dest Destination path
    187186 *
    188187 * @return EOK on success or an error code.
    189188 */
    190 static errno_t fmgt_walk_subtree(fmgt_walk_params_t *params, const char *fname,
     189static errno_t fmgt_walk_subtree(fmgt_walk_t *walk, const char *fname,
    191190    const char *dest)
    192191{
    … …  
    200199        if (stat.is_directory) {
    201200                /* Directory */
    202                 rc = fmgt_walk_dir(params, fname, dest);
     201                rc = fmgt_walk_dir(walk, fname, dest);
    203202                if (rc != EOK)
    204203                        return rc;
    205204        } else {
    206205                /* Not a directory */
    207                 rc = fmgt_walk_file(params, fname, dest);
     206                rc = fmgt_walk_file(walk, fname, dest);
    208207                if (rc != EOK)
    209208                        return rc;
    … …  
    225224{
    226225        fmgt_flist_entry_t *entry;
     226        fmgt_walk_t walk;
    227227        char *destname;
    228228        errno_t rc;
    229229        int rv;
    230230
     231        walk.params = params;
     232        walk.stop = false;
     233
    231234        entry = fmgt_flist_first(params->flist);
    232         while (entry != NULL) {
     235        while (!walk.stop && entry != NULL) {
    233236                if (params->into_dest) {
    234237                        rv = asprintf(&destname, "%s/%s",
    … …  
    240243                }
    241244
    242                 rc = fmgt_walk_subtree(params, entry->fname,
     245                rc = fmgt_walk_subtree(&walk, entry->fname,
    243246                    destname != NULL ? destname : params->dest);
    244247                if (rc != EOK)

  • uspace/lib/fmgt/test/fsops.c

    r857fba8 r59ed424e  
    8686        int fd;
    8787        int rv;
    88         bool skip;
    89         errno_t rc;
    90 
    91         /* Create name for temporary file */
    92         p = tmpnam(buf);
    93         PCUT_ASSERT_NOT_NULL(p);
    94 
    95         rc = fmgt_create(&fmgt);
    96         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    97 
    98         rc = fmgt_create_file(fmgt, p, &fd, &skip);
    99         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    100         PCUT_ASSERT_FALSE(skip);
     88        fmgt_exists_action_t exaction;
     89        errno_t rc;
     90
     91        /* Create name for temporary file */
     92        p = tmpnam(buf);
     93        PCUT_ASSERT_NOT_NULL(p);
     94
     95        rc = fmgt_create(&fmgt);
     96        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     97
     98        rc = fmgt_create_file(fmgt, p, &fd, &exaction);
     99        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    101100
    102101        fmgt_destroy(fmgt);

  • uspace/lib/fmgt/test/walk.c

    r857fba8 r59ed424e  
    3939PCUT_TEST_SUITE(walk);
    4040
    41 static errno_t test_walk_dir_enter(void *, const char *, const char *);
    42 static errno_t test_walk_dir_leave(void *, const char *, const char *);
    43 static errno_t test_walk_file(void *, const char *, const char *);
     41static errno_t test_walk_dir_enter(fmgt_walk_t *, const char *, const char *);
     42static errno_t test_walk_dir_leave(fmgt_walk_t *, const char *, const char *);
     43static errno_t test_walk_file(fmgt_walk_t *, const char *, const char *);
    4444
    4545static fmgt_walk_cb_t test_walk_cb = {
    … …  
    207207}
    208208
    209 errno_t test_walk_dir_enter(void *arg, const char *fname, const char *dest)
    210 {
    211         test_resp_t *resp = (test_resp_t *)arg;
     209errno_t test_walk_dir_enter(fmgt_walk_t *walk, const char *fname,
     210    const char *dest)
     211{
     212        test_resp_t *resp = (test_resp_t *)walk->params->arg;
    212213        resp->dir_enter = true;
    213214        resp->dirname = str_dup(fname);
    … …  
    216217}
    217218
    218 errno_t test_walk_dir_leave(void *arg, const char *fname, const char *dest)
    219 {
    220         test_resp_t *resp = (test_resp_t *)arg;
     219errno_t test_walk_dir_leave(fmgt_walk_t *walk, const char *fname,
     220    const char *dest)
     221{
     222        test_resp_t *resp = (test_resp_t *)walk->params->arg;
    221223        resp->dir_leave = true;
    222224        resp->dl_dest = (dest != NULL) ? str_dup(dest) : NULL;
    … …  
    224226}
    225227
    226 errno_t test_walk_file(void *arg, const char *fname, const char *dest)
    227 {
    228         test_resp_t *resp = (test_resp_t *)arg;
     228errno_t test_walk_file(fmgt_walk_t *walk, const char *fname, const char *dest)
     229{
     230        test_resp_t *resp = (test_resp_t *)walk->params->arg;
    229231        resp->file_proc = true;
    230232        resp->fname = str_dup(fname);
Note: See TracChangeset for help on using the changeset viewer.