Changeset 694ca93f in mainline for uspace/app/bdsh/cmds/modules
- Timestamp:
- 2011-05-01T19:34:26Z (15 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 0e26444
- Parents:
- 1ff896e (diff), 042fbe0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - Location:
- uspace/app/bdsh/cmds/modules
- Files:
-
- 1 deleted
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/app/bdsh/cmds/modules/cat/cat.c
r1ff896e r694ca93f 39 39 #include <io/color.h> 40 40 #include <io/style.h> 41 #include <io/keycode.h> 41 42 #include <errno.h> 42 43 #include <vfs/vfs.h> … … 62 63 static sysarg_t console_cols = 0; 63 64 static sysarg_t console_rows = 0; 65 static bool should_quit = false; 64 66 65 67 static struct option const long_options[] = { … … 102 104 console_set_pos(fphone(stdout), 0, console_rows-1); 103 105 console_set_color(fphone(stdout), COLOR_BLUE, COLOR_WHITE, 0); 104 printf("Press any key to continue"); 106 printf("ENTER/SPACE/PAGE DOWN - next page, " 107 "ESC/Q - quit, C - continue unpaged"); 105 108 fflush(stdout); 106 109 console_set_style(fphone(stdout), STYLE_NORMAL); … … 116 119 } 117 120 if (ev.type == KEY_PRESS) { 118 return; 121 if (ev.key == KC_ESCAPE || ev.key == KC_Q) { 122 should_quit = true; 123 return; 124 } 125 if (ev.key == KC_C) { 126 paging_enabled = false; 127 return; 128 } 129 if (ev.key == KC_ENTER || ev.key == KC_SPACE || 130 ev.key == KC_PAGE_DOWN) { 131 return; 132 } 119 133 } 120 134 } … … 150 164 { 151 165 int fd, bytes = 0, count = 0, reads = 0; 152 off64_t total = 0;153 166 char *buff = NULL; 154 167 int i; … … 160 173 return 1; 161 174 } 162 163 total = lseek(fd, 0, SEEK_END);164 lseek(fd, 0, SEEK_SET);165 175 166 176 if (NULL == (buff = (char *) malloc(blen + 1))) { … … 177 187 buff[bytes] = '\0'; 178 188 offset = 0; 179 for (i = 0; i < bytes ; i++) {189 for (i = 0; i < bytes && !should_quit; i++) { 180 190 if (hex) { 181 191 paged_char(hexchars[((uint8_t)buff[i])/16]); … … 185 195 wchar_t c = str_decode(buff, &offset, bytes); 186 196 if (c == 0) { 187 / / reached end of string197 /* Reached end of string */ 188 198 break; 189 199 } … … 194 204 reads++; 195 205 } 196 } while (bytes > 0 );206 } while (bytes > 0 && !should_quit); 197 207 198 208 close(fd); … … 218 228 int rc; 219 229 220 // reset global state 221 // TODO: move to structure? 230 /* 231 * reset global state 232 * TODO: move to structure? 233 */ 222 234 paging_enabled = false; 223 235 chars_remaining = 0; … … 225 237 console_cols = 0; 226 238 console_rows = 0; 239 should_quit = false; 227 240 228 241 argc = cli_count_args(argv); … … 278 291 } 279 292 280 for (i = optind; argv[i] != NULL ; i++)293 for (i = optind; argv[i] != NULL && !should_quit; i++) 281 294 ret += cat_file(argv[i], buffer, hex); 282 295 -
uspace/app/bdsh/cmds/modules/cp/cp.c
r1ff896e r694ca93f 108 108 for (;;) { 109 109 ssize_t res; 110 size_t written = 0; 110 111 111 112 bytes = read(fd1, buff, blen); … … 120 121 * returned less data than requested. 121 122 */ 122 bytes = write(fd2, buff , res);123 bytes = write(fd2, buff + written, res); 123 124 if (bytes < 0) 124 125 goto err; 126 written += bytes; 125 127 res -= bytes; 126 128 } while (res > 0); -
uspace/app/bdsh/cmds/modules/ls/ls.c
r1ff896e r694ca93f 38 38 #include <dirent.h> 39 39 #include <fcntl.h> 40 #include <getopt.h> 40 41 #include <sys/types.h> 41 42 #include <sys/stat.h> 42 43 #include <str.h> 44 #include <sort.h> 43 45 44 46 #include "errors.h" … … 46 48 #include "util.h" 47 49 #include "entry.h" 48 #include "ls.h"49 50 #include "cmds.h" 50 51 52 /* Various values that can be returned by ls_scope() */ 53 #define LS_BOGUS 0 54 #define LS_FILE 1 55 #define LS_DIR 2 56 57 /** Structure to represent a directory entry. 58 * 59 * Useful to keep together important information 60 * for sorting directory entries. 61 */ 62 struct dir_elem_t { 63 char *name; 64 struct stat s; 65 }; 66 51 67 static const char *cmdname = "ls"; 52 68 53 static void ls_scan_dir(const char *d, DIR *dirp) 54 { 69 static struct option const long_options[] = { 70 { "help", no_argument, 0, 'h' }, 71 { "unsort", no_argument, 0, 'u' }, 72 { 0, 0, 0, 0 } 73 }; 74 75 /** Print an entry. 76 * 77 * ls_print currently does nothing more than print the entry. 78 * In the future, we will likely pass the absolute path, and 79 * some sort of ls_options structure that controls how each 80 * entry is printed and what is printed about it. 81 * 82 * Now we just print basic DOS style lists. 83 * 84 * @param de Directory element. 85 */ 86 static void ls_print(struct dir_elem_t *de) 87 { 88 if (de->s.is_file) 89 printf("%-40s\t%llu\n", de->name, (long long) de->s.size); 90 else if (de->s.is_directory) 91 printf("%-40s\t<dir>\n", de->name); 92 else 93 printf("%-40s\n", de->name); 94 } 95 96 97 /** Compare 2 directory elements. 98 * 99 * It compares 2 elements of a directory : a file is considered 100 * as bigger than a directory, and if they have the same type, 101 * they are compared alphabetically. 102 * 103 * @param a Pointer to the structure of the first element. 104 * @param b Pointer to the structure of the second element. 105 * @param arg Pointer for an other and optionnal argument. 106 * 107 * @return -1 if a < b, 1 otherwise. 108 */ 109 static int ls_cmp(void *a, void *b, void *arg) 110 { 111 struct dir_elem_t *da = a; 112 struct dir_elem_t *db = b; 113 114 if ((da->s.is_directory && db->s.is_file) || 115 ((da->s.is_directory == db->s.is_directory) && 116 str_cmp(da->name, db->name) < 0)) 117 return -1; 118 else 119 return 1; 120 } 121 122 /** Scan a directory. 123 * 124 * Scan the content of a directory and print it. 125 * 126 * @param d Name of the directory. 127 * @param dirp Directory stream. 128 * @param sort 1 if the output must be sorted, 129 * 0 otherwise. 130 */ 131 static void ls_scan_dir(const char *d, DIR *dirp, int sort) 132 { 133 int alloc_blocks = 20; 134 int i; 135 int nbdirs = 0; 136 int rc; 137 int len; 138 char *buff; 139 struct dir_elem_t *tmp; 140 struct dir_elem_t *tosort; 55 141 struct dirent *dp; 56 char *buff; 57 58 if (! dirp) 142 143 if (!dirp) 59 144 return; 60 145 61 buff = (char *) malloc(PATH_MAX);62 if ( NULL ==buff) {146 buff = (char *) malloc(PATH_MAX); 147 if (!buff) { 63 148 cli_error(CL_ENOMEM, "ls: failed to scan %s", d); 64 149 return; 65 150 } 66 151 152 tosort = (struct dir_elem_t *) malloc(alloc_blocks * sizeof(*tosort)); 153 if (!tosort) { 154 cli_error(CL_ENOMEM, "ls: failed to scan %s", d); 155 free(buff); 156 return; 157 } 158 67 159 while ((dp = readdir(dirp))) { 68 memset(buff, 0, sizeof(buff)); 69 /* Don't worry if inserting a double slash, this will be fixed by 70 * absolutize() later with subsequent calls to open() or readdir() */ 71 snprintf(buff, PATH_MAX - 1, "%s/%s", d, dp->d_name); 72 ls_print(dp->d_name, buff); 73 } 74 160 if (nbdirs + 1 > alloc_blocks) { 161 alloc_blocks += alloc_blocks; 162 163 tmp = (struct dir_elem_t *) realloc(tosort, 164 alloc_blocks * sizeof(struct dir_elem_t)); 165 if (!tmp) { 166 cli_error(CL_ENOMEM, "ls: failed to scan %s", d); 167 goto out; 168 } 169 tosort = tmp; 170 } 171 172 /* fill the name field */ 173 tosort[nbdirs].name = (char *) malloc(str_length(dp->d_name) + 1); 174 if (!tosort[nbdirs].name) { 175 cli_error(CL_ENOMEM, "ls: failed to scan %s", d); 176 goto out; 177 } 178 179 str_cpy(tosort[nbdirs].name, str_length(dp->d_name) + 1, dp->d_name); 180 len = snprintf(buff, PATH_MAX - 1, "%s/%s", d, tosort[nbdirs].name); 181 buff[len] = '\0'; 182 183 rc = stat(buff, &tosort[nbdirs++].s); 184 if (rc != 0) { 185 printf("ls: skipping bogus node %s\n", buff); 186 printf("rc=%d\n", rc); 187 goto out; 188 } 189 } 190 191 if (sort) { 192 if (!qsort(&tosort[0], nbdirs, sizeof(struct dir_elem_t), 193 ls_cmp, NULL)) { 194 printf("Sorting error.\n"); 195 } 196 } 197 198 for (i = 0; i < nbdirs; i++) 199 ls_print(&tosort[i]); 200 201 out: 202 for(i = 0; i < nbdirs; i++) 203 free(tosort[i].name); 204 free(tosort); 75 205 free(buff); 76 77 return;78 }79 80 /* ls_print currently does nothing more than print the entry.81 * in the future, we will likely pass the absolute path, and82 * some sort of ls_options structure that controls how each83 * entry is printed and what is printed about it.84 *85 * Now we just print basic DOS style lists */86 87 static void ls_print(const char *name, const char *pathname)88 {89 struct stat s;90 int rc;91 92 rc = stat(pathname, &s);93 if (rc != 0) {94 /* Odd chance it was deleted from the time readdir() found it */95 printf("ls: skipping bogus node %s\n", pathname);96 printf("rc=%d\n", rc);97 return;98 }99 100 if (s.is_file)101 printf("%-40s\t%llu\n", name, (long long) s.size);102 else if (s.is_directory)103 printf("%-40s\t<dir>\n", name);104 else105 printf("%-40s\n", name);106 107 return;108 206 } 109 207 … … 114 212 } else { 115 213 help_cmd_ls(HELP_SHORT); 116 printf(" `%s' [path], if no path is given the current " 117 "working directory is used.\n", cmdname); 214 printf( 215 "Usage: %s [options] [path]\n" 216 "If not path is given, the current working directory is used.\n" 217 "Options:\n" 218 " -h, --help A short option summary\n" 219 " -u, --unsort Do not sort directory entries\n", 220 cmdname); 118 221 } 119 222 … … 124 227 { 125 228 unsigned int argc; 126 struct stat s; 127 char *buff; 229 struct dir_elem_t de; 128 230 DIR *dirp; 231 int c, opt_ind; 232 int sort = 1; 129 233 130 234 argc = cli_count_args(argv); 131 132 buff = (char *) malloc(PATH_MAX); 133 if (NULL == buff) { 235 236 for (c = 0, optind = 0, opt_ind = 0; c != -1;) { 237 c = getopt_long(argc, argv, "hu", long_options, &opt_ind); 238 switch (c) { 239 case 'h': 240 help_cmd_ls(HELP_LONG); 241 return CMD_SUCCESS; 242 case 'u': 243 sort = 0; 244 break; 245 } 246 } 247 248 argc -= optind; 249 250 de.name = (char *) malloc(PATH_MAX); 251 if (!de.name) { 134 252 cli_error(CL_ENOMEM, "%s: ", cmdname); 135 253 return CMD_FAILURE; 136 254 } 137 memset( buff, 0, sizeof(buff));138 139 if (argc == 1)140 getcwd( buff, PATH_MAX);255 memset(de.name, 0, sizeof(PATH_MAX)); 256 257 if (argc == 0) 258 getcwd(de.name, PATH_MAX); 141 259 else 142 str_cpy( buff, PATH_MAX, argv[1]);143 144 if (stat( buff, &s)) {145 cli_error(CL_ENOENT, buff);146 free( buff);260 str_cpy(de.name, PATH_MAX, argv[optind]); 261 262 if (stat(de.name, &de.s)) { 263 cli_error(CL_ENOENT, de.name); 264 free(de.name); 147 265 return CMD_FAILURE; 148 266 } 149 267 150 if ( s.is_file) {151 ls_print( buff, buff);268 if (de.s.is_file) { 269 ls_print(&de); 152 270 } else { 153 dirp = opendir( buff);271 dirp = opendir(de.name); 154 272 if (!dirp) { 155 273 /* May have been deleted between scoping it and opening it */ 156 cli_error(CL_EFAIL, "Could not stat %s", buff);157 free( buff);274 cli_error(CL_EFAIL, "Could not stat %s", de.name); 275 free(de.name); 158 276 return CMD_FAILURE; 159 277 } 160 ls_scan_dir( buff, dirp);278 ls_scan_dir(de.name, dirp, sort); 161 279 closedir(dirp); 162 280 } 163 281 164 free( buff);282 free(de.name); 165 283 166 284 return CMD_SUCCESS; -
uspace/app/bdsh/cmds/modules/rm/rm.c
r1ff896e r694ca93f 101 101 } 102 102 103 static unsigned int rm_recursive_not_empty_dirs(const char *path) 104 { 105 DIR *dirp; 106 struct dirent *dp; 107 char buff[PATH_MAX]; 108 unsigned int scope; 109 unsigned int ret = 0; 110 111 dirp = opendir(path); 112 if (!dirp) { 113 /* May have been deleted between scoping it and opening it */ 114 cli_error(CL_EFAIL, "Could not open %s", path); 115 return ret; 116 } 117 118 memset(buff, 0, sizeof(buff)); 119 while ((dp = readdir(dirp))) { 120 snprintf(buff, PATH_MAX - 1, "%s/%s", path, dp->d_name); 121 scope = rm_scope(buff); 122 switch (scope) { 123 case RM_BOGUS: 124 break; 125 case RM_FILE: 126 ret += rm_single(buff); 127 break; 128 case RM_DIR: 129 ret += rm_recursive(buff); 130 break; 131 } 132 } 133 134 return ret; 135 } 136 103 137 static unsigned int rm_recursive(const char *path) 104 138 { 105 139 int rc; 140 unsigned int ret = 0; 106 141 107 142 /* First see if it will just go away */ … … 111 146 112 147 /* Its not empty, recursively scan it */ 113 cli_error(CL_ENOTSUP, 114 "Can not remove %s, directory not empty", path); 115 return 1; 148 ret = rm_recursive_not_empty_dirs(path); 149 150 /* Delete directory */ 151 rc = rmdir(path); 152 if (rc == 0) 153 return ret; 154 155 cli_error(CL_ENOTSUP, "Can not remove %s", path); 156 157 return ret + 1; 116 158 } 117 159
Note:
See TracChangeset
for help on using the changeset viewer.
