Subversion Repositories HelenOS

Rev

Rev 4153 | Rev 4581 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3296 post 1
/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
2
 * All rights reserved.
3277 post 3
 *
3296 post 4
 * Redistribution and use in source and binary forms, with or without
5
 * modification, are permitted provided that the following conditions are met:
6
 *
7
 * Redistributions of source code must retain the above copyright notice, this
8
 * list of conditions and the following disclaimer.
9
 *
10
 * Redistributions in binary form must reproduce the above copyright notice,
11
 * this list of conditions and the following disclaimer in the documentation
12
 * and/or other materials provided with the distribution.
13
 *
14
 * Neither the name of the original program's authors nor the names of its
15
 * contributors may be used to endorse or promote products derived from this
16
 * software without specific prior written permission.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28
 * POSSIBILITY OF SUCH DAMAGE.
29
 */
3277 post 30
 
31
#include <stdio.h>
32
#include <stdlib.h>
3296 post 33
#include <unistd.h>
34
#include <fcntl.h>
35
#include <dirent.h>
3337 post 36
#include <getopt.h>
37
 
3296 post 38
#include "config.h"
39
#include "errors.h"
40
#include "util.h"
3277 post 41
#include "entry.h"
42
#include "rm.h"
43
#include "cmds.h"
44
 
45
static char *cmdname = "rm";
3337 post 46
#define RM_VERSION "0.0.1"
3277 post 47
 
3337 post 48
static rm_job_t rm;
49
 
3375 post 50
static struct option const long_options[] = {
3338 post 51
    { "help", no_argument, 0, 'h' },
52
    { "version", no_argument, 0, 'v' },
53
    { "recursive", no_argument, 0, 'r' },
54
    { "force", no_argument, 0, 'f' },
55
    { "safe", no_argument, 0, 's' },
3337 post 56
    { 0, 0, 0, 0 }
57
};
58
 
3364 post 59
static unsigned int rm_start(rm_job_t *rm)
3337 post 60
{
61
    rm->recursive = 0;
62
    rm->force = 0;
63
    rm->safe = 0;
64
 
65
    /* Make sure we can allocate enough memory to store
66
     * what is needed in the job structure */
67
    if (NULL == (rm->nwd = (char *) malloc(PATH_MAX)))
68
        return 0;
69
    memset(rm->nwd, 0, sizeof(rm->nwd));
70
 
71
    if (NULL == (rm->owd = (char *) malloc(PATH_MAX)))
72
        return 0;
73
    memset(rm->owd, 0, sizeof(rm->owd));
74
 
75
    if (NULL == (rm->cwd = (char *) malloc(PATH_MAX)))
76
        return 0;
77
    memset(rm->cwd, 0, sizeof(rm->cwd));
78
 
79
    chdir(".");
80
 
81
    if (NULL == (getcwd(rm->owd, PATH_MAX)))
82
        return 0;
83
 
84
    return 1;
85
}
86
 
3364 post 87
static void rm_end(rm_job_t *rm)
3337 post 88
{
89
    if (NULL != rm->nwd)
90
        free(rm->nwd);
91
 
92
    if (NULL != rm->owd)
93
        free(rm->owd);
94
 
95
    if (NULL != rm->cwd)
96
        free(rm->cwd);
97
 
98
    return;
99
}
100
 
3364 post 101
static unsigned int rm_recursive(const char *path)
3296 post 102
{
3337 post 103
    int rc;
104
 
105
    /* First see if it will just go away */
106
    rc = rmdir(path);
107
    if (rc == 0)
108
        return 0;
109
 
110
    /* Its not empty, recursively scan it */
111
    cli_error(CL_ENOTSUP,
112
        "Can not remove %s, directory not empty", path);
3296 post 113
    return 1;
114
}
115
 
3364 post 116
static unsigned int rm_single(const char *path)
3296 post 117
{
118
    if (unlink(path)) {
119
        cli_error(CL_EFAIL, "rm: could not remove file %s", path);
120
        return 1;
121
    }
122
    return 0;
123
}
124
 
3364 post 125
static unsigned int rm_scope(const char *path)
3296 post 126
{
127
    int fd;
128
    DIR *dirp;
129
 
130
    dirp = opendir(path);
131
    if (dirp) {
132
        closedir(dirp);
133
        return RM_DIR;
134
    }
135
 
136
    fd = open(path, O_RDONLY);
137
    if (fd > 0) {
138
        close(fd);
139
        return RM_FILE;
140
    }
141
 
142
    return RM_BOGUS;
143
}
144
 
3277 post 145
/* Dispays help for rm in various levels */
4153 mejdrech 146
void help_cmd_rm(unsigned int level)
3277 post 147
{
3296 post 148
    if (level == HELP_SHORT) {
149
        printf("`%s' removes files and directories.\n", cmdname);
150
    } else {
151
        help_cmd_rm(HELP_SHORT);
3337 post 152
        printf(
153
        "Usage:  %s [options] <path>\n"
154
        "Options:\n"
155
        "  -h, --help       A short option summary\n"
156
        "  -v, --version    Print version information and exit\n"
157
        "  -r, --recursive  Recursively remove sub directories\n"
158
        "  -f, --force      Do not prompt prior to removing files\n"
159
        "  -s, --safe       Stop if directories change during removal\n\n"
160
        "Currently, %s is under development, some options don't work.\n",
161
        cmdname, cmdname);
3296 post 162
    }
4153 mejdrech 163
    return;
3277 post 164
}
165
 
166
/* Main entry point for rm, accepts an array of arguments */
4153 mejdrech 167
int cmd_rm(char **argv)
3277 post 168
{
169
    unsigned int argc;
3296 post 170
    unsigned int i, scope, ret = 0;
3337 post 171
    int c, opt_ind;
172
    size_t len;
173
    char *buff = NULL;
3277 post 174
 
3376 post 175
    argc = cli_count_args(argv);
176
 
3277 post 177
    if (argc < 2) {
3296 post 178
        cli_error(CL_EFAIL,
3337 post 179
            "%s: insufficient arguments. Try %s --help", cmdname, cmdname);
3296 post 180
        return CMD_FAILURE;
3277 post 181
    }
182
 
3337 post 183
    if (!rm_start(&rm)) {
184
        cli_error(CL_ENOMEM, "%s: could not initialize", cmdname);
185
        rm_end(&rm);
186
        return CMD_FAILURE;
187
    }
188
 
189
    for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
190
        c = getopt_long(argc, argv, "hvrfs", long_options, &opt_ind);
191
        switch (c) {
192
        case 'h':
193
            help_cmd_rm(HELP_LONG);
194
            return CMD_SUCCESS;
195
        case 'v':
196
            printf("%s\n", RM_VERSION);
197
            return CMD_SUCCESS;
198
        case 'r':
199
            rm.recursive = 1;
200
            break;
201
        case 'f':
202
            rm.force = 1;
203
            break;
204
        case 's':
205
            rm.safe = 1;
206
            break;
207
        }
208
    }
209
 
210
    if (optind == argc) {
211
        cli_error(CL_EFAIL,
212
            "%s: insufficient arguments. Try %s --help", cmdname, cmdname);
213
        rm_end(&rm);
214
        return CMD_FAILURE;
215
    }
216
 
217
    i = optind;
218
    while (NULL != argv[i]) {
4327 mejdrech 219
        len = str_size(argv[i]) + 2;
3337 post 220
        buff = (char *) realloc(buff, len);
4153 mejdrech 221
        if (buff == NULL) {
222
            printf("rm: out of memory\n");
223
            ret = 1;
224
            break;
225
        }
3337 post 226
        memset(buff, 0, sizeof(buff));
227
        snprintf(buff, len, argv[i]);
228
 
3296 post 229
        scope = rm_scope(buff);
230
        switch (scope) {
3337 post 231
        case RM_BOGUS: /* FIXME */
3296 post 232
        case RM_FILE:
233
            ret += rm_single(buff);
234
            break;
235
        case RM_DIR:
3337 post 236
            if (! rm.recursive) {
237
                printf("%s is a directory, use -r to remove it.\n", buff);
238
                ret ++;
239
            } else {
240
                ret += rm_recursive(buff);
241
            }
3296 post 242
            break;
243
        }
3337 post 244
        i++;
3296 post 245
    }
3277 post 246
 
3337 post 247
    if (NULL != buff)
248
        free(buff);
249
 
250
    rm_end(&rm);
251
 
3296 post 252
    if (ret)
253
        return CMD_FAILURE;
254
    else
255
        return CMD_SUCCESS;
3277 post 256
}
257