Changes in / [84c86819:4b82445] in mainline
- Files:
-
- 9 added
- 20 edited
Legend:
- Unmodified
- Added
- Removed
-
tools/checkers/clang.py
r84c86819 r4b82445 114 114 for job in jobs: 115 115 if (not clang(rootdir, job)): 116 print 116 print() 117 117 print("Failed job: %s" % job) 118 118 return -
tools/checkers/stanse.py
r84c86819 r4b82445 127 127 for job in jobs: 128 128 if (not stanse(rootdir, job)): 129 print 129 print() 130 130 print("Failed job: %s" % job) 131 131 return -
tools/checkers/vcc.py
r84c86819 r4b82445 204 204 for job in jobs: 205 205 if (not vcc(vcc_path, rootdir, job)): 206 print 206 print() 207 207 print("Failed job: %s" % job) 208 208 return 209 209 210 print 210 print() 211 211 print("All jobs passed") 212 212 -
tools/filldir.py
r84c86819 r4b82445 37 37 38 38 if len(sys.argv) < 3: 39 print 'Usage: filldir <parent-dir> <count>'39 print('Usage: filldir <parent-dir> <count>') 40 40 exit(2) 41 41 -
tools/gentestfile.py
r84c86819 r4b82445 36 36 37 37 if len(sys.argv) < 2: 38 print "Usage: gentestfile.py <count of 64-bit numbers to output>"38 print("Usage: gentestfile.py <count of 64-bit numbers to output>") 39 39 exit() 40 40 41 m = long(sys.argv[1])41 m = int(sys.argv[1]) 42 42 i = 0 43 43 pow_2_64 = 2 ** 64 -
tools/mkuimage.py
r84c86819 r4b82445 124 124 header.img_type = 2 # Kernel 125 125 header.compression = 0 # None 126 header.img_name = image_name 126 header.img_name = image_name.encode('ascii') 127 127 128 128 header_crc = calc_crc32(header.pack()) … … 140 140 signed_crc = zlib.crc32(byteseq, 0) 141 141 if signed_crc < 0: 142 return (long(signed_crc) + (long(2) ** long(32))) # 2^32L142 return signed_crc + (1 << 32) 143 143 else: 144 144 return signed_crc … … 148 148 def print_syntax(cmd): 149 149 print("syntax: " + cmd + " [<options>] <raw_image> <uImage>") 150 print 150 print() 151 151 print("\traw_image\tInput image name (raw binary data)") 152 152 print("\tuImage\t\tOutput uImage name (U-Boot image)") 153 print 153 print() 154 154 print("options:") 155 155 print("\t-name <name>\tImage name (default: 'Noname')") -
tools/xstruct.py
r84c86819 r4b82445 32 32 33 33 import struct 34 import sys 34 35 import types 35 36 37 integer_types = (int, long) if sys.version < '3' else (int,) 38 36 39 ranges = { 37 'B': ( (int, long), 0x00, 0xff),38 'H': ( (int, long), 0x0000, 0xffff),39 'L': ( (int, long), 0x00000000, 0xffffffff),40 'Q': ( (int, long), 0x0000000000000000, 0xffffffffffffffff),41 'b': ( (int, long), -0x80, 0x7f),42 'h': ( (int, long), -0x8000, 0x7fff),43 'l': ( (int, long), -0x80000000, 0x7fffffff) ,44 'q': ( (int, long), -0x8000000000000000, 0x7fffffffffffffff),40 'B': (integer_types, 0x00, 0xff), 41 'H': (integer_types, 0x0000, 0xffff), 42 'L': (integer_types, 0x00000000, 0xffffffff), 43 'Q': (integer_types, 0x0000000000000000, 0xffffffffffffffff), 44 'b': (integer_types, -0x80, 0x7f), 45 'h': (integer_types, -0x8000, 0x7fff), 46 'l': (integer_types, -0x80000000, 0x7fffffff) , 47 'q': (integer_types, -0x8000000000000000, 0x7fffffffffffffff), 45 48 } 46 49 -
uspace/app/bdsh/Makefile
r84c86819 r4b82445 48 48 cmds/modules/cp/cp.c \ 49 49 cmds/modules/mv/mv.c \ 50 cmds/modules/printf/printf.c \ 51 cmds/modules/echo/echo.c \ 50 52 cmds/modules/mount/mount.c \ 51 53 cmds/modules/unmount/unmount.c \ -
uspace/app/bdsh/TODO
r84c86819 r4b82445 30 30 * Add wrappers for signal, sigaction to make ports to modules easier 31 31 32 * Add 'echo' and 'printf' modules.33 34 32 Regarding POSIX: 35 33 ---------------- -
uspace/app/bdsh/cmds/builtins/cd/cd.c
r84c86819 r4b82445 41 41 static const char *cmdname = "cd"; 42 42 43 /* Previous directory variables. 44 * 45 * Declaring them static to avoid many "== NULL" checks. 46 * PATH_MAX is not that big to cause any problems with memory overhead. 47 */ 48 static char previous_directory[PATH_MAX] = ""; 49 static char previous_directory_tmp[PATH_MAX]; 50 static bool previous_directory_valid = true; 51 static bool previous_directory_set = false; 52 53 static int chdir_and_remember(const char *new_dir) { 54 55 char *ok = getcwd(previous_directory_tmp, PATH_MAX); 56 previous_directory_valid = ok != NULL; 57 previous_directory_set = true; 58 59 int rc = chdir(new_dir); 60 if (rc != EOK) { 61 return rc; 62 } 63 64 str_cpy(previous_directory, PATH_MAX, previous_directory_tmp); 65 return EOK; 66 } 67 43 68 void help_cmd_cd(unsigned int level) 44 69 { … … 55 80 } 56 81 82 57 83 /* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */ 58 84 … … 62 88 63 89 argc = cli_count_args(argv); 90 91 /* Handle cd -- -. Override to switch to a directory named '-' */ 92 bool hyphen_override = false; 93 char *target_directory = argv[1]; 94 if (argc == 3) { 95 if (!str_cmp(argv[1], "--")) { 96 hyphen_override = true; 97 argc--; 98 target_directory = argv[2]; 99 } 100 } 64 101 65 102 /* We don't yet play nice with whitespace, a getopt implementation should … … 79 116 } 80 117 81 /* We have the correct # of arguments 82 *TODO: handle tidle (~) expansion? */118 /* We have the correct # of arguments */ 119 // TODO: handle tidle (~) expansion? */ 83 120 84 rc = chdir(argv[1]); 121 /* Handle 'cd -' first. */ 122 if (!str_cmp(target_directory, "-") && !hyphen_override) { 123 if (!previous_directory_valid) { 124 cli_error(CL_EFAIL, "Cannot switch to previous directory"); 125 return CMD_FAILURE; 126 } 127 if (!previous_directory_set) { 128 cli_error(CL_EFAIL, "No previous directory to switch to"); 129 return CMD_FAILURE; 130 } 131 char *prev_dup = str_dup(previous_directory); 132 if (prev_dup == NULL) { 133 cli_error(CL_ENOMEM, "Cannot switch to previous directory"); 134 return CMD_FAILURE; 135 } 136 rc = chdir_and_remember(prev_dup); 137 free(prev_dup); 138 } else { 139 rc = chdir_and_remember(target_directory); 140 } 85 141 86 142 if (rc == 0) { … … 93 149 break; 94 150 case ENOENT: 95 cli_error(CL_ENOENT, "Invalid directory `%s'", argv[1]);151 cli_error(CL_ENOENT, "Invalid directory `%s'", target_directory); 96 152 break; 97 153 default: 98 cli_error(CL_EFAIL, "Unable to change to `%s'", argv[1]);154 cli_error(CL_EFAIL, "Unable to change to `%s'", target_directory); 99 155 break; 100 156 } -
uspace/app/bdsh/cmds/modules/cat/cat.h
r84c86819 r4b82445 4 4 /* Prototypes for the cat command, excluding entry points */ 5 5 6 static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);7 8 6 #endif /* CAT_H */ 9 7 -
uspace/app/bdsh/cmds/modules/cp/cp.c
r84c86819 r4b82445 30 30 #include <stdlib.h> 31 31 #include <unistd.h> 32 #include <io/console.h> 33 #include <io/keycode.h> 32 34 #include <getopt.h> 33 35 #include <str.h> … … 46 48 47 49 static const char *cmdname = "cp"; 50 static console_ctrl_t *con; 48 51 49 52 static struct option const long_options[] = { 50 53 { "buffer", required_argument, 0, 'b' }, 51 54 { "force", no_argument, 0, 'f' }, 55 { "interactive", no_argument, 0, 'i'}, 52 56 { "recursive", no_argument, 0, 'r' }, 53 57 { "help", no_argument, 0, 'h' }, … … 139 143 } 140 144 145 static bool get_user_decision(bool bdefault, const char *message, ...) 146 { 147 va_list args; 148 149 va_start(args, message); 150 vprintf(message, args); 151 va_end(args); 152 153 while (true) { 154 kbd_event_t ev; 155 console_flush(con); 156 console_get_kbd_event(con, &ev); 157 if ((ev.type != KEY_PRESS) 158 || (ev.mods & (KM_CTRL | KM_ALT)) != 0) { 159 continue; 160 } 161 162 switch(ev.key) { 163 case KC_Y: 164 printf("y\n"); 165 return true; 166 case KC_N: 167 printf("n\n"); 168 return false; 169 case KC_ENTER: 170 printf("%c\n", bdefault ? 'Y' : 'N'); 171 return bdefault; 172 default: 173 break; 174 } 175 } 176 } 177 141 178 static int64_t do_copy(const char *src, const char *dest, 142 size_t blen, int vb, int recursive, int force )179 size_t blen, int vb, int recursive, int force, int interactive) 143 180 { 144 181 int r = -1; … … 192 229 /* e.g. cp file_name existing_file */ 193 230 194 /* dest already exists, if force is set we will 195 * try to remove it. 231 /* dest already exists, 232 * if force is set we will try to remove it. 233 * if interactive is set user input is required. 196 234 */ 197 if (force ) {235 if (force && !interactive) { 198 236 if (unlink(dest_path)) { 199 237 printf("Unable to remove %s\n", … … 201 239 goto exit; 202 240 } 241 } else if (!force && interactive) { 242 bool overwrite = get_user_decision(false, 243 "File already exists: %s. Overwrite? [y/N]: ", 244 dest_path); 245 if (overwrite) { 246 printf("Overwriting file: %s\n", dest_path); 247 if (unlink(dest_path)) { 248 printf("Unable to remove %s\n", dest_path); 249 goto exit; 250 } 251 } else { 252 printf("Not overwriting file: %s\n", dest_path); 253 r = 0; 254 goto exit; 255 } 203 256 } else { 204 printf(" file already exists: %s\n", dest_path);257 printf("File already exists: %s\n", dest_path); 205 258 goto exit; 206 259 } … … 302 355 /* Recursively call do_copy() */ 303 356 r = do_copy(src_dent, dest_dent, blen, vb, recursive, 304 force );357 force, interactive); 305 358 if (r) 306 359 goto exit; … … 315 368 return r; 316 369 } 317 318 370 319 371 static int64_t copy_file(const char *src, const char *dest, … … 380 432 " -v, --version Print version information and exit\n" 381 433 " -V, --verbose Be annoyingly noisy about what's being done\n" 382 " -f, --force Do not complain when <dest> exists\n" 434 " -f, --force Do not complain when <dest> exists (overrides a previous -i)\n" 435 " -i, --interactive Ask what to do when <dest> exists (overrides a previous -f)\n" 383 436 " -r, --recursive Copy entire directories\n" 384 437 " -b, --buffer ## Set the read buffer size to ##\n"; … … 397 450 unsigned int argc, verbose = 0; 398 451 int buffer = 0, recursive = 0; 399 int force = 0 ;452 int force = 0, interactive = 0; 400 453 int c, opt_ind; 401 454 int64_t ret; 402 455 456 con = console_init(stdin, stdout); 403 457 argc = cli_count_args(argv); 404 458 405 459 for (c = 0, optind = 0, opt_ind = 0; c != -1;) { 406 c = getopt_long(argc, argv, "hvVf rb:", long_options, &opt_ind);460 c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind); 407 461 switch (c) { 408 462 case 'h': … … 416 470 break; 417 471 case 'f': 472 interactive = 0; 418 473 force = 1; 474 break; 475 case 'i': 476 force = 0; 477 interactive = 1; 419 478 break; 420 479 case 'r': … … 426 485 "(should be a number greater than zero)\n", 427 486 cmdname); 487 console_done(con); 428 488 return CMD_FAILURE; 429 489 } … … 442 502 printf("%s: invalid number of arguments. Try %s --help\n", 443 503 cmdname, cmdname); 504 console_done(con); 444 505 return CMD_FAILURE; 445 506 } 446 507 447 508 ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose, 448 recursive, force); 509 recursive, force, interactive); 510 511 console_done(con); 449 512 450 513 if (ret == 0) -
uspace/app/bdsh/cmds/modules/help/help.h
r84c86819 r4b82445 3 3 4 4 /* Prototypes for the help command (excluding entry points) */ 5 static int is_mod_or_builtin(char *);6 5 7 6 #endif -
uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
r84c86819 r4b82445 36 36 #include <stdarg.h> 37 37 #include <str.h> 38 #include <errno.h> 39 #include <str_error.h> 40 #include <vfs/vfs.h> 38 41 39 42 #include "config.h" … … 83 86 /* This is kind of clunky, but effective for now */ 84 87 static unsigned int 85 create_directory(const char * path, unsigned int p)88 create_directory(const char *user_path, bool create_parents) 86 89 { 87 DIR *dirp; 88 char *tmp = NULL, *buff = NULL, *wdp = NULL; 89 char *dirs[255]; 90 unsigned int absolute = 0, i = 0, ret = 0; 91 92 /* Its a good idea to allocate path, plus we (may) need a copy of 93 * path to tokenize if parents are specified */ 94 if (NULL == (tmp = str_dup(path))) { 90 /* Ensure we would always work with absolute and canonified path. */ 91 char *path = absolutize(user_path, NULL); 92 if (path == NULL) { 95 93 cli_error(CL_ENOMEM, "%s: path too big?", cmdname); 96 94 return 1; 97 95 } 98 96 99 if (NULL == (wdp = (char *) malloc(PATH_MAX))) { 100 cli_error(CL_ENOMEM, "%s: could not alloc cwd", cmdname); 101 free(tmp); 102 return 1; 103 } 104 105 /* The only reason for wdp is to be (optionally) verbose */ 106 getcwd(wdp, PATH_MAX); 107 108 /* Typical use without specifying the creation of parents */ 109 if (p == 0) { 110 dirp = opendir(tmp); 111 if (dirp) { 112 cli_error(CL_EEXISTS, "%s: can not create %s, try -p", cmdname, path); 113 closedir(dirp); 114 goto finit; 115 } 116 if (-1 == (mkdir(tmp, 0))) { 117 cli_error(CL_EFAIL, "%s: could not create %s", cmdname, path); 118 goto finit; 119 } 120 } 121 122 /* Parents need to be created, path has to be broken up */ 123 124 /* See if path[0] is a slash, if so we have to remember to append it */ 125 if (tmp[0] == '/') 126 absolute = 1; 127 128 /* TODO: Canonify the path prior to tokenizing it, see below */ 129 dirs[i] = strtok(tmp, "/"); 130 while (dirs[i] && i < 255) 131 dirs[++i] = strtok(NULL, "/"); 132 133 if (NULL == dirs[0]) 134 return 1; 135 136 if (absolute == 1) { 137 asprintf(&buff, "/%s", dirs[0]); 138 mkdir(buff, 0); 139 chdir(buff); 140 free(buff); 141 getcwd(wdp, PATH_MAX); 142 i = 1; 97 int rc; 98 int ret = 0; 99 100 if (!create_parents) { 101 rc = mkdir(path, 0); 102 if (rc != EOK) { 103 cli_error(CL_EFAIL, "%s: could not create %s (%s)", 104 cmdname, path, str_error(rc)); 105 ret = 1; 106 } 143 107 } else { 144 i = 0; 145 } 146 147 while (dirs[i] != NULL) { 148 /* Sometimes make or scripts conjoin odd paths. Account for something 149 * like this: ../../foo/bar/../foo/foofoo/./bar */ 150 if (!str_cmp(dirs[i], "..") || !str_cmp(dirs[i], ".")) { 151 if (0 != (chdir(dirs[i]))) { 152 cli_error(CL_EFAIL, "%s: impossible path: %s", 153 cmdname, path); 154 ret ++; 155 goto finit; 156 } 157 getcwd(wdp, PATH_MAX); 158 } else { 159 if (-1 == (mkdir(dirs[i], 0))) { 160 cli_error(CL_EFAIL, 161 "%s: failed at %s/%s", wdp, dirs[i]); 162 ret ++; 163 goto finit; 164 } 165 if (0 != (chdir(dirs[i]))) { 166 cli_error(CL_EFAIL, "%s: failed creating %s\n", 167 cmdname, dirs[i]); 168 ret ++; 108 /* Create the parent directories as well. */ 109 size_t off = 0; 110 while (1) { 111 size_t prev_off = off; 112 wchar_t cur_char = str_decode(path, &off, STR_NO_LIMIT); 113 if ((cur_char == 0) || (cur_char == U_SPECIAL)) { 169 114 break; 170 115 } 171 } 172 i++; 173 } 174 goto finit; 175 176 finit: 177 free(wdp); 178 free(tmp); 116 if (cur_char != '/') { 117 continue; 118 } 119 if (prev_off == 0) { 120 continue; 121 } 122 /* 123 * If we are here, it means that: 124 * - we found / 125 * - it is not the first / (no need to create root 126 * directory) 127 * 128 * We would now overwrite the / with 0 to terminate the 129 * string (that shall be okay because we are 130 * overwriting at the beginning of UTF sequence). 131 * That would allow us to create the directories 132 * in correct nesting order. 133 * 134 * Notice that we ignore EEXIST errors as some of 135 * the parent directories may already exist. 136 */ 137 char slash_char = path[prev_off]; 138 path[prev_off] = 0; 139 rc = mkdir(path, 0); 140 if (rc == EEXIST) { 141 rc = EOK; 142 } 143 144 if (rc != EOK) { 145 cli_error(CL_EFAIL, "%s: could not create %s (%s)", 146 cmdname, path, str_error(rc)); 147 ret = 1; 148 goto leave; 149 } 150 151 path[prev_off] = slash_char; 152 } 153 /* Create the final directory. */ 154 rc = mkdir(path, 0); 155 if (rc != EOK) { 156 cli_error(CL_EFAIL, "%s: could not create %s (%s)", 157 cmdname, path, str_error(rc)); 158 ret = 1; 159 } 160 } 161 162 leave: 163 free(path); 179 164 return ret; 180 165 } … … 182 167 int cmd_mkdir(char **argv) 183 168 { 184 unsigned int argc, create_parents = 0, i, ret = 0, follow= 0;185 unsigned int verbose = 0;169 unsigned int argc, i, ret = 0; 170 bool create_parents = false, follow = false, verbose = false; 186 171 int c, opt_ind; 187 char *cwd;188 172 189 173 argc = cli_count_args(argv); … … 193 177 switch (c) { 194 178 case 'p': 195 create_parents = 1;179 create_parents = true; 196 180 break; 197 181 case 'v': 198 verbose = 1;182 verbose = true; 199 183 break; 200 184 case 'h': … … 205 189 return CMD_SUCCESS; 206 190 case 'f': 207 follow = 1;191 follow = true; 208 192 break; 209 193 case 'm': … … 221 205 } 222 206 223 if (NULL == (cwd = (char *) malloc(PATH_MAX))) {224 cli_error(CL_ENOMEM, "%s: could not allocate cwd", cmdname);225 return CMD_FAILURE;226 }227 228 memset(cwd, 0, sizeof(cwd));229 getcwd(cwd, PATH_MAX);230 231 207 for (i = optind; argv[i] != NULL; i++) { 232 if (verbose == 1)208 if (verbose) 233 209 printf("%s: creating %s%s\n", 234 210 cmdname, argv[i], … … 237 213 } 238 214 239 if (follow == 0) 240 chdir(cwd); 241 242 free(cwd); 215 if (follow && (argv[optind] != NULL)) { 216 chdir(argv[optind]); 217 } 243 218 244 219 if (ret) -
uspace/app/bdsh/cmds/modules/mkdir/mkdir.h
r84c86819 r4b82445 4 4 /* Prototypes for the mkdir command, excluding entry points */ 5 5 6 static unsigned int create_directory(const char *, unsigned int);7 6 #endif /* MKDIR_H */ 8 7 -
uspace/app/bdsh/cmds/modules/modules.h
r84c86819 r4b82445 61 61 #include "unmount/entry.h" 62 62 #include "kcon/entry.h" 63 #include "printf/entry.h" 64 #include "echo/entry.h" 63 65 64 66 /* Each .def function fills the module_t struct with the individual name, entry … … 82 84 #include "unmount/unmount_def.h" 83 85 #include "kcon/kcon_def.h" 86 #include "printf/printf_def.h" 87 #include "echo/echo_def.h" 84 88 85 89 {NULL, NULL, NULL, NULL} -
uspace/app/bdsh/cmds/modules/rm/rm.c
r84c86819 r4b82445 46 46 #define RM_VERSION "0.0.1" 47 47 48 static rm_job_t rm;49 50 48 static struct option const long_options[] = { 51 49 { "help", no_argument, 0, 'h' }, … … 57 55 }; 58 56 57 /* Return values for rm_scope() */ 58 #define RM_BOGUS 0 59 #define RM_FILE 1 60 #define RM_DIR 2 61 62 /* Flags for rm_update() */ 63 #define _RM_ENTRY 0 64 #define _RM_ADVANCE 1 65 #define _RM_REWIND 2 66 #define _RM_EXIT 3 67 68 /* A simple job structure */ 69 typedef struct { 70 /* Options set at run time */ 71 unsigned int force; /* -f option */ 72 unsigned int recursive; /* -r option */ 73 unsigned int safe; /* -s option */ 74 75 /* Keeps track of the job in progress */ 76 int advance; /* How far deep we've gone since entering */ 77 DIR *entry; /* Entry point to the tree being removed */ 78 char *owd; /* Where we were when we invoked rm */ 79 char *cwd; /* Current directory being transversed */ 80 char *nwd; /* Next directory to be transversed */ 81 82 /* Counters */ 83 int f_removed; /* Number of files unlinked */ 84 int d_removed; /* Number of directories unlinked */ 85 } rm_job_t; 86 87 static rm_job_t rm; 88 89 static unsigned int rm_recursive(const char *); 90 59 91 static unsigned int rm_start(rm_job_t *rm) 60 92 { … … 95 127 if (NULL != rm->cwd) 96 128 free(rm->cwd); 129 } 130 131 static unsigned int rm_single(const char *path) 132 { 133 if (unlink(path)) { 134 cli_error(CL_EFAIL, "rm: could not remove file %s", path); 135 return 1; 136 } 137 return 0; 138 } 139 140 static unsigned int rm_scope(const char *path) 141 { 142 int fd; 143 DIR *dirp; 144 145 dirp = opendir(path); 146 if (dirp) { 147 closedir(dirp); 148 return RM_DIR; 149 } 150 151 fd = open(path, O_RDONLY); 152 if (fd > 0) { 153 close(fd); 154 return RM_FILE; 155 } 156 157 return RM_BOGUS; 97 158 } 98 159 … … 154 215 155 216 return ret + 1; 156 }157 158 static unsigned int rm_single(const char *path)159 {160 if (unlink(path)) {161 cli_error(CL_EFAIL, "rm: could not remove file %s", path);162 return 1;163 }164 return 0;165 }166 167 static unsigned int rm_scope(const char *path)168 {169 int fd;170 DIR *dirp;171 172 dirp = opendir(path);173 if (dirp) {174 closedir(dirp);175 return RM_DIR;176 }177 178 fd = open(path, O_RDONLY);179 if (fd > 0) {180 close(fd);181 return RM_FILE;182 }183 184 return RM_BOGUS;185 217 } 186 218 -
uspace/app/bdsh/cmds/modules/rm/rm.h
r84c86819 r4b82445 2 2 #define RM_H 3 3 4 /* Return values for rm_scope() */5 #define RM_BOGUS 06 #define RM_FILE 17 #define RM_DIR 28 9 /* Flags for rm_update() */10 #define _RM_ENTRY 011 #define _RM_ADVANCE 112 #define _RM_REWIND 213 #define _RM_EXIT 314 15 /* A simple job structure */16 typedef struct {17 /* Options set at run time */18 unsigned int force; /* -f option */19 unsigned int recursive; /* -r option */20 unsigned int safe; /* -s option */21 22 /* Keeps track of the job in progress */23 int advance; /* How far deep we've gone since entering */24 DIR *entry; /* Entry point to the tree being removed */25 char *owd; /* Where we were when we invoked rm */26 char *cwd; /* Current directory being transversed */27 char *nwd; /* Next directory to be transversed */28 29 /* Counters */30 int f_removed; /* Number of files unlinked */31 int d_removed; /* Number of directories unlinked */32 } rm_job_t;33 34 35 4 /* Prototypes for the rm command, excluding entry points */ 36 static unsigned int rm_start(rm_job_t *);37 static void rm_end(rm_job_t *rm);38 static unsigned int rm_recursive(const char *);39 static unsigned int rm_single(const char *);40 static unsigned int rm_scope(const char *);41 5 42 6 #endif /* RM_H */ -
uspace/app/bdsh/cmds/modules/sleep/sleep.c
r84c86819 r4b82445 27 27 */ 28 28 29 #include <errno.h> 29 30 #include <stdio.h> 30 31 #include <stdlib.h> 32 #include <unistd.h> 31 33 #include "config.h" 32 34 #include "util.h" … … 41 43 void help_cmd_sleep(unsigned int level) 42 44 { 43 printf("This is the %s help for '%s'.\n", 44 level ? EXT_HELP : SHORT_HELP, cmdname); 45 if (level == HELP_SHORT) { 46 printf("`%s' pauses for a given time interval\n", cmdname); 47 } else { 48 help_cmd_sleep(HELP_SHORT); 49 printf( 50 "Usage: %s <duration>\n" 51 "The duration is a decimal number of seconds.\n", 52 cmdname); 53 } 54 45 55 return; 56 } 57 58 /** Convert string containing decimal seconds to useconds_t. 59 * 60 * @param nptr Pointer to string. 61 * @param result Result of the conversion. 62 * @return EOK if conversion was successful. 63 */ 64 static int decimal_to_useconds(const char *nptr, useconds_t *result) 65 { 66 int ret; 67 uint64_t whole_seconds; 68 uint64_t frac_seconds; 69 char *endptr; 70 71 /* Check for whole seconds */ 72 if (*nptr == '.') { 73 whole_seconds = 0; 74 endptr = (char *)nptr; 75 } else { 76 ret = str_uint64_t(nptr, &endptr, 10, false, &whole_seconds); 77 if (ret != EOK) 78 return ret; 79 } 80 81 /* Check for fractional seconds */ 82 if (*endptr == '\0') { 83 frac_seconds = 0; 84 } else if (*endptr == '.' && endptr[1] == '\0') { 85 frac_seconds = 0; 86 } else if (*endptr == '.') { 87 nptr = endptr + 1; 88 ret = str_uint64_t(nptr, &endptr, 10, true, &frac_seconds); 89 if (ret != EOK) 90 return ret; 91 92 int ndigits = endptr - nptr; 93 for (; ndigits < 6; ndigits++) 94 frac_seconds *= 10; 95 for (; ndigits > 6; ndigits--) 96 frac_seconds /= 10; 97 } else { 98 return EINVAL; 99 } 100 101 /* Check for overflow */ 102 useconds_t total = whole_seconds * 1000000 + frac_seconds; 103 if (total / 1000000 != whole_seconds) 104 return EOVERFLOW; 105 106 *result = total; 107 108 return EOK; 46 109 } 47 110 … … 49 112 int cmd_sleep(char **argv) 50 113 { 114 int ret; 51 115 unsigned int argc; 52 u nsigned int i;116 useconds_t duration; 53 117 54 118 /* Count the arguments */ 55 for (argc = 0; argv[argc] != NULL; argc ++);119 argc = cli_count_args(argv); 56 120 57 printf("%s %s\n", TEST_ANNOUNCE, cmdname); 58 printf("%d arguments passed to %s", argc - 1, cmdname); 59 60 if (argc < 2) { 61 printf("\n"); 62 return CMD_SUCCESS; 121 if (argc != 2) { 122 printf("%s - incorrect number of arguments. Try `help %s'\n", 123 cmdname, cmdname); 124 return CMD_FAILURE; 63 125 } 64 126 65 printf(":\n"); 66 for (i = 1; i < argc; i++) 67 printf("[%d] -> %s\n", i, argv[i]); 127 ret = decimal_to_useconds(argv[1], &duration); 128 if (ret != EOK) { 129 printf("%s - invalid duration.\n", cmdname); 130 return CMD_FAILURE; 131 } 132 133 (void) usleep(duration); 68 134 69 135 return CMD_SUCCESS; -
uspace/lib/c/include/unistd.h
r84c86819 r4b82445 58 58 #define getpagesize() (PAGE_SIZE) 59 59 60 extern int dup2(int oldfd, int newfd);60 extern int dup2(int, int); 61 61 62 62 extern ssize_t write(int, const void *, size_t); … … 73 73 extern int unlink(const char *); 74 74 75 extern char *getcwd(char * buf, size_t);75 extern char *getcwd(char *, size_t); 76 76 extern int rmdir(const char *); 77 77 extern int chdir(const char *);
Note:
See TracChangeset
for help on using the changeset viewer.