1
0

msh_file.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2015-09-25 Bernard the first verion for FinSH
  9. */
  10. #include <rtthread.h>
  11. #if defined(FINSH_USING_MSH) && defined(RT_USING_DFS)
  12. #include <finsh.h>
  13. #include "msh.h"
  14. #include <dfs_posix.h>
  15. static int msh_readline(int fd, char *line_buf, int size)
  16. {
  17. char ch;
  18. int index = 0;
  19. do
  20. {
  21. if (read(fd, &ch, 1) != 1)
  22. {
  23. /* nothing in this file */
  24. return 0;
  25. }
  26. }
  27. while (ch == '\n' || ch == '\r');
  28. /* set the first character */
  29. line_buf[index ++] = ch;
  30. while (index < size)
  31. {
  32. if (read(fd, &ch, 1) == 1)
  33. {
  34. if (ch == '\n' || ch == '\r')
  35. {
  36. line_buf[index] = '\0';
  37. break;
  38. }
  39. line_buf[index++] = ch;
  40. }
  41. else
  42. {
  43. line_buf[index] = '\0';
  44. break;
  45. }
  46. }
  47. return index;
  48. }
  49. int msh_exec_script(const char *cmd_line, int size)
  50. {
  51. int ret;
  52. int fd = -1;
  53. char *pg_name;
  54. int length, cmd_length = 0;
  55. if (size == 0) return -RT_ERROR;
  56. /* get the length of command0 */
  57. while ((cmd_line[cmd_length] != ' ' && cmd_line[cmd_length] != '\t') && cmd_length < size)
  58. cmd_length ++;
  59. /* get name length */
  60. length = cmd_length + 32;
  61. /* allocate program name memory */
  62. pg_name = (char *) rt_malloc(length);
  63. if (pg_name == RT_NULL) return -RT_ENOMEM;
  64. /* copy command0 */
  65. memcpy(pg_name, cmd_line, cmd_length);
  66. pg_name[cmd_length] = '\0';
  67. if (strstr(pg_name, ".sh") != RT_NULL || strstr(pg_name, ".SH") != RT_NULL)
  68. {
  69. /* try to open program */
  70. fd = open(pg_name, O_RDONLY, 0);
  71. /* search in /bin path */
  72. if (fd < 0)
  73. {
  74. rt_snprintf(pg_name, length - 1, "/bin/%.*s", cmd_length, cmd_line);
  75. fd = open(pg_name, O_RDONLY, 0);
  76. }
  77. }
  78. rt_free(pg_name);
  79. if (fd >= 0)
  80. {
  81. /* found script */
  82. char *line_buf;
  83. int length;
  84. line_buf = (char *) rt_malloc(RT_CONSOLEBUF_SIZE);
  85. if (line_buf == RT_NULL)
  86. {
  87. close(fd);
  88. return -RT_ENOMEM;
  89. }
  90. /* read line by line and then exec it */
  91. do
  92. {
  93. length = msh_readline(fd, line_buf, RT_CONSOLEBUF_SIZE);
  94. if (length > 0)
  95. {
  96. char ch = '\0';
  97. int index;
  98. for (index = 0; index < length; index ++)
  99. {
  100. ch = line_buf[index];
  101. if (ch == ' ' || ch == '\t') continue;
  102. else break;
  103. }
  104. if (ch != '#') /* not a comment */
  105. msh_exec(line_buf, length);
  106. }
  107. }
  108. while (length > 0);
  109. close(fd);
  110. rt_free(line_buf);
  111. ret = 0;
  112. }
  113. else
  114. {
  115. ret = -1;
  116. }
  117. return ret;
  118. }
  119. #ifdef DFS_USING_WORKDIR
  120. extern char working_directory[];
  121. #endif
  122. int cmd_ls(int argc, char **argv)
  123. {
  124. extern void ls(const char *pathname);
  125. if (argc == 1)
  126. {
  127. #ifdef DFS_USING_WORKDIR
  128. ls(working_directory);
  129. #else
  130. ls("/");
  131. #endif
  132. }
  133. else
  134. {
  135. ls(argv[1]);
  136. }
  137. return 0;
  138. }
  139. FINSH_FUNCTION_EXPORT_ALIAS(cmd_ls, __cmd_ls, List information about the FILEs.);
  140. int cmd_cp(int argc, char **argv)
  141. {
  142. void copy(const char *src, const char *dst);
  143. if (argc != 3)
  144. {
  145. rt_kprintf("Usage: cp SOURCE DEST\n");
  146. rt_kprintf("Copy SOURCE to DEST.\n");
  147. }
  148. else
  149. {
  150. copy(argv[1], argv[2]);
  151. }
  152. return 0;
  153. }
  154. FINSH_FUNCTION_EXPORT_ALIAS(cmd_cp, __cmd_cp, Copy SOURCE to DEST.);
  155. int cmd_mv(int argc, char **argv)
  156. {
  157. if (argc != 3)
  158. {
  159. rt_kprintf("Usage: mv SOURCE DEST\n");
  160. rt_kprintf("Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n");
  161. }
  162. else
  163. {
  164. int fd;
  165. char *dest = RT_NULL;
  166. rt_kprintf("%s => %s\n", argv[1], argv[2]);
  167. fd = open(argv[2], O_DIRECTORY, 0);
  168. if (fd >= 0)
  169. {
  170. char *src;
  171. close(fd);
  172. /* it's a directory */
  173. dest = (char *)rt_malloc(DFS_PATH_MAX);
  174. if (dest == RT_NULL)
  175. {
  176. rt_kprintf("out of memory\n");
  177. return -RT_ENOMEM;
  178. }
  179. src = argv[1] + rt_strlen(argv[1]);
  180. while (src != argv[1])
  181. {
  182. if (*src == '/') break;
  183. src --;
  184. }
  185. rt_snprintf(dest, DFS_PATH_MAX - 1, "%s/%s", argv[2], src);
  186. }
  187. else
  188. {
  189. fd = open(argv[2], O_RDONLY, 0);
  190. if (fd >= 0)
  191. {
  192. close(fd);
  193. unlink(argv[2]);
  194. }
  195. dest = argv[2];
  196. }
  197. rename(argv[1], dest);
  198. if (dest != RT_NULL && dest != argv[2]) rt_free(dest);
  199. }
  200. return 0;
  201. }
  202. FINSH_FUNCTION_EXPORT_ALIAS(cmd_mv, __cmd_mv, Rename SOURCE to DEST.);
  203. int cmd_cat(int argc, char **argv)
  204. {
  205. int index;
  206. extern void cat(const char *filename);
  207. if (argc == 1)
  208. {
  209. rt_kprintf("Usage: cat [FILE]...\n");
  210. rt_kprintf("Concatenate FILE(s)\n");
  211. return 0;
  212. }
  213. for (index = 1; index < argc; index ++)
  214. {
  215. cat(argv[index]);
  216. }
  217. return 0;
  218. }
  219. FINSH_FUNCTION_EXPORT_ALIAS(cmd_cat, __cmd_cat, Concatenate FILE(s));
  220. int cmd_rm(int argc, char **argv)
  221. {
  222. int index;
  223. if (argc == 1)
  224. {
  225. rt_kprintf("Usage: rm FILE...\n");
  226. rt_kprintf("Remove (unlink) the FILE(s).\n");
  227. return 0;
  228. }
  229. for (index = 1; index < argc; index ++)
  230. {
  231. unlink(argv[index]);
  232. }
  233. return 0;
  234. }
  235. FINSH_FUNCTION_EXPORT_ALIAS(cmd_rm, __cmd_rm, Remove(unlink) the FILE(s).);
  236. #ifdef DFS_USING_WORKDIR
  237. int cmd_cd(int argc, char **argv)
  238. {
  239. if (argc == 1)
  240. {
  241. rt_kprintf("%s\n", working_directory);
  242. }
  243. else if (argc == 2)
  244. {
  245. if (chdir(argv[1]) != 0)
  246. {
  247. rt_kprintf("No such directory: %s\n", argv[1]);
  248. }
  249. }
  250. return 0;
  251. }
  252. FINSH_FUNCTION_EXPORT_ALIAS(cmd_cd, __cmd_cd, Change the shell working directory.);
  253. int cmd_pwd(int argc, char **argv)
  254. {
  255. rt_kprintf("%s\n", working_directory);
  256. return 0;
  257. }
  258. FINSH_FUNCTION_EXPORT_ALIAS(cmd_pwd, __cmd_pwd, Print the name of the current working directory.);
  259. #endif
  260. int cmd_mkdir(int argc, char **argv)
  261. {
  262. if (argc == 1)
  263. {
  264. rt_kprintf("Usage: mkdir [OPTION] DIRECTORY\n");
  265. rt_kprintf("Create the DIRECTORY, if they do not already exist.\n");
  266. }
  267. else
  268. {
  269. mkdir(argv[1], 0);
  270. }
  271. return 0;
  272. }
  273. FINSH_FUNCTION_EXPORT_ALIAS(cmd_mkdir, __cmd_mkdir, Create the DIRECTORY.);
  274. int cmd_mkfs(int argc, char **argv)
  275. {
  276. int result = 0;
  277. char *type = "elm"; /* use the default file system type as 'fatfs' */
  278. if (argc == 2)
  279. {
  280. result = dfs_mkfs(type, argv[1]);
  281. }
  282. else if (argc == 4)
  283. {
  284. if (strcmp(argv[1], "-t") == 0)
  285. {
  286. type = argv[2];
  287. result = dfs_mkfs(type, argv[3]);
  288. }
  289. }
  290. else
  291. {
  292. rt_kprintf("Usage: mkfs [-t type] device\n");
  293. return 0;
  294. }
  295. if (result != RT_EOK)
  296. {
  297. rt_kprintf("mkfs failed, result=%d\n", result);
  298. }
  299. return 0;
  300. }
  301. FINSH_FUNCTION_EXPORT_ALIAS(cmd_mkfs, __cmd_mkfs, format disk with file system);
  302. extern int df(const char *path);
  303. int cmd_df(int argc, char** argv)
  304. {
  305. if (argc != 2)
  306. {
  307. df("/");
  308. }
  309. else
  310. {
  311. if ((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") == 0))
  312. {
  313. rt_kprintf("df [path]\n");
  314. }
  315. else
  316. {
  317. df(argv[1]);
  318. }
  319. }
  320. return 0;
  321. }
  322. FINSH_FUNCTION_EXPORT_ALIAS(cmd_df, __cmd_df, disk free);
  323. int cmd_echo(int argc, char** argv)
  324. {
  325. if (argc == 2)
  326. {
  327. rt_kprintf("%s\n", argv[1]);
  328. }
  329. else if (argc == 3)
  330. {
  331. int fd;
  332. fd = open(argv[2], O_RDWR | O_APPEND | O_CREAT, 0);
  333. if (fd >= 0)
  334. {
  335. write (fd, argv[1], strlen(argv[1]));
  336. close(fd);
  337. }
  338. else
  339. {
  340. rt_kprintf("open file:%s failed!\n", argv[2]);
  341. }
  342. }
  343. else
  344. {
  345. rt_kprintf("Usage: echo \"string\" [filename]\n");
  346. }
  347. return 0;
  348. }
  349. FINSH_FUNCTION_EXPORT_ALIAS(cmd_echo, __cmd_echo, echo string to file);
  350. #endif /* defined(FINSH_USING_MSH) && defined(RT_USING_DFS) */