finsh: replace str/mem functions with rt-prefixed versions

illustriousness · illustriousness · commit 8fc210347a50 · 2025-11-20T11:40:14.000+08:00
Replace standard string and memory functions with RT-Thread's rt-prefixed
equivalents where available:

- strcpy -&gt; rt_strcpy
- strncpy -&gt; rt_strncpy
- strcmp -&gt; rt_strcmp
- strncmp -&gt; rt_strncmp
- strlen -&gt; rt_strlen
- strstr -&gt; rt_strstr
- memcpy -&gt; rt_memcpy
- memcmp -&gt; rt_memcmp

Functions like strcat, strchr remain unchanged as RT-Thread does not provide
rt-prefixed versions.
diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c
@@ -940,64 +940,64 @@ static int cmd_list(int argc, char **argv)
 {
     if(argc == 2)
     {
-        if(strcmp(argv[1], "thread") == 0)
+        if(rt_strcmp(argv[1], "thread") == 0)
         {
             list_thread();
         }
-        else if(strcmp(argv[1], "timer") == 0)
+        else if(rt_strcmp(argv[1], "timer") == 0)
         {
             list_timer();
         }
 #ifdef RT_USING_SEMAPHORE
-        else if(strcmp(argv[1], "sem") == 0)
+        else if(rt_strcmp(argv[1], "sem") == 0)
         {
             list_sem();
         }
 #endif /* RT_USING_SEMAPHORE */
 #ifdef RT_USING_EVENT
-        else if(strcmp(argv[1], "event") == 0)
+        else if(rt_strcmp(argv[1], "event") == 0)
         {
             list_event();
         }
 #endif /* RT_USING_EVENT */
 #ifdef RT_USING_MUTEX
-        else if(strcmp(argv[1], "mutex") == 0)
+        else if(rt_strcmp(argv[1], "mutex") == 0)
         {
             list_mutex();
         }
 #endif /* RT_USING_MUTEX */
 #ifdef RT_USING_MAILBOX
-        else if(strcmp(argv[1], "mailbox") == 0)
+        else if(rt_strcmp(argv[1], "mailbox") == 0)
         {
             list_mailbox();
         }
 #endif  /* RT_USING_MAILBOX */
 #ifdef RT_USING_MESSAGEQUEUE
-        else if(strcmp(argv[1], "msgqueue") == 0)
+        else if(rt_strcmp(argv[1], "msgqueue") == 0)
         {
             list_msgqueue();
         }
 #endif /* RT_USING_MESSAGEQUEUE */
 #ifdef RT_USING_MEMHEAP
-        else if(strcmp(argv[1], "memheap") == 0)
+        else if(rt_strcmp(argv[1], "memheap") == 0)
         {
             list_memheap();
         }
 #endif /* RT_USING_MEMHEAP */
 #ifdef RT_USING_MEMPOOL
-        else if(strcmp(argv[1], "mempool") == 0)
+        else if(rt_strcmp(argv[1], "mempool") == 0)
         {
             list_mempool();
         }
 #endif /* RT_USING_MEMPOOL */
 #ifdef RT_USING_DEVICE
-        else if(strcmp(argv[1], "device") == 0)
+        else if(rt_strcmp(argv[1], "device") == 0)
         {
             list_device();
         }
 #endif /* RT_USING_DEVICE */
 #ifdef RT_USING_DFS
-        else if(strcmp(argv[1], "fd") == 0)
+        else if(rt_strcmp(argv[1], "fd") == 0)
         {
             extern int list_fd(void);
             list_fd();
diff --git a/components/finsh/msh.c b/components/finsh/msh.c
@@ -63,7 +63,7 @@ static int cmd_ps(int argc, char **argv)
     extern int list_module(void);
 
 #ifdef RT_USING_MODULE
-    if ((argc == 2) && (strcmp(argv[1], "-m") == 0))
+    if ((argc == 2) && (rt_strcmp(argv[1], "-m") == 0))
         list_module();
     else
 #endif
@@ -237,7 +237,7 @@ static cmd_function_t msh_get_cmd(char *cmd, int size)
             index < _syscall_table_end;
             FINSH_NEXT_SYSCALL(index))
     {
-        if (strncmp(index->name, cmd, size) == 0 &&
+        if (rt_strncmp(index->name, cmd, size) == 0 &&
                 index->name[size] == '\0')
         {
             cmd_func = (cmd_function_t)index->func;
@@ -276,7 +276,7 @@ int msh_exec_module(const char *cmd_line, int size)
     rt_memcpy(pg_name, cmd_line, cmd_length);
     pg_name[cmd_length] = '\0';
 
-    if (strstr(pg_name, ".mo") != RT_NULL || strstr(pg_name, ".MO") != RT_NULL)
+    if (rt_strstr(pg_name, ".mo") != RT_NULL || rt_strstr(pg_name, ".MO") != RT_NULL)
     {
         /* try to open program */
         fd = open(pg_name, O_RDONLY, 0);
@@ -374,12 +374,12 @@ static rt_bool_t _msh_lwp_cmd_exists(const char *path)
 static char *_msh_exec_search_path(const char *path, const char *pg_name)
 {
     char *path_buffer = RT_NULL;
-    ssize_t pg_len = strlen(pg_name);
+    ssize_t pg_len = rt_strlen(pg_name);
     ssize_t base_len = 0;
 
     if (path)
     {
-        base_len = strlen(path);
+        base_len = rt_strlen(path);
     }
 
     path_buffer = rt_malloc(base_len + pg_len + 6);
@@ -390,7 +390,7 @@ static char *_msh_exec_search_path(const char *path, const char *pg_name)
 
     if (base_len > 0)
     {
-        memcpy(path_buffer, path, base_len);
+        rt_memcpy(path_buffer, path, base_len);
         path_buffer[base_len] = '/';
         path_buffer[base_len + 1] = '\0';
     }
@@ -405,7 +405,7 @@ static char *_msh_exec_search_path(const char *path, const char *pg_name)
         return path_buffer;
     }
 
-    if (strstr(path_buffer, ".elf") != NULL)
+    if (rt_strstr(path_buffer, ".elf") != NULL)
     {
         goto not_found;
     }
@@ -506,7 +506,7 @@ int _msh_exec_lwp(int debug, char *cmd, rt_size_t length)
 
     /* only check these paths when the first argument doesn't contain path
        seperator */
-    if (strstr(argv[0], "/"))
+    if (rt_strstr(argv[0], "/"))
     {
         return -1;
     }
@@ -704,14 +704,14 @@ void msh_auto_complete_path(char *path)
             if (dirent == RT_NULL) break;
 
             /* matched the prefix string */
-            if (strncmp(index, dirent->d_name, rt_strlen(index)) == 0)
+            if (rt_strncmp(index, dirent->d_name, rt_strlen(index)) == 0)
             {
                 multi ++;
                 if (min_length == 0)
                 {
                     min_length = rt_strlen(dirent->d_name);
                     /* save dirent name */
-                    strcpy(full_path, dirent->d_name);
+                    rt_strcpy(full_path, dirent->d_name);
                 }
 
                 length = str_common(dirent->d_name, full_path);
@@ -735,7 +735,7 @@ void msh_auto_complete_path(char *path)
                     dirent = readdir(dir);
                     if (dirent == RT_NULL) break;
 
-                    if (strncmp(index, dirent->d_name, rt_strlen(index)) == 0)
+                    if (rt_strncmp(index, dirent->d_name, rt_strlen(index)) == 0)
                         rt_kprintf("%s\n", dirent->d_name);
                 }
             }
@@ -822,14 +822,14 @@ void msh_auto_complete(char *prefix)
         {
             /* skip finsh shell function */
             cmd_name = (const char *) index->name;
-            if (strncmp(prefix, cmd_name, strlen(prefix)) == 0)
+            if (rt_strncmp(prefix, cmd_name, rt_strlen(prefix)) == 0)
             {
                 if (min_length == 0)
                 {
                     /* set name_ptr */
                     name_ptr = cmd_name;
                     /* set initial length */
-                    min_length = strlen(name_ptr);
+                    min_length = rt_strlen(name_ptr);
                 }
 
                 length = str_common(name_ptr, cmd_name);
@@ -865,14 +865,14 @@ static msh_cmd_opt_t *msh_get_cmd_opt(char *opt_str)
     }
     else
     {
-        len = strlen(opt_str);
+        len = rt_strlen(opt_str);
     }
 #if defined(FINSH_USING_SYMTAB)
     for (index = _syscall_table_begin;
             index < _syscall_table_end;
             FINSH_NEXT_SYSCALL(index))
     {
-        if (strncmp(index->name, opt_str, len) == 0 && index->name[len] == '\0')
+        if (rt_strncmp(index->name, opt_str, len) == 0 && index->name[len] == '\0')
         {
             opt = index->opt;
             break;
@@ -906,18 +906,18 @@ static void msh_opt_complete(char *opts_str, struct msh_cmd_opt *cmd_opt)
     const char *name_ptr = RT_NULL;
     int min_length = 0, length, opts_str_len;
 
-    opts_str_len = strlen(opts_str);
+    opts_str_len = rt_strlen(opts_str);
 
     for (opt = cmd_opt; opt->id; opt++)
     {
-        if (!strncmp(opt->name, opts_str, opts_str_len))
+        if (!rt_strncmp(opt->name, opts_str, opts_str_len))
         {
             if (min_length == 0)
             {
                 /* set name_ptr */
                 name_ptr = opt->name;
                 /* set initial length */
-                min_length = strlen(name_ptr);
+                min_length = rt_strlen(name_ptr);
             }
 
             length = str_common(name_ptr, opt->name);
@@ -933,7 +933,7 @@ static void msh_opt_complete(char *opts_str, struct msh_cmd_opt *cmd_opt)
 
     if (name_ptr != NULL)
     {
-        strncpy(opts_str, name_ptr, min_length);
+        rt_strncpy(opts_str, name_ptr, min_length);
     }
 }
 
@@ -959,7 +959,7 @@ void msh_opt_auto_complete(char *prefix)
     {
         opt = msh_get_cmd_opt(prefix);
     }
-    else if (!msh_get_cmd(prefix, strlen(prefix)) && (' ' == prefix[strlen(prefix) - 1]))
+    else if (!msh_get_cmd(prefix, rt_strlen(prefix)) && (' ' == prefix[rt_strlen(prefix) - 1]))
     {
         opt = msh_get_cmd_opt(prefix);
     }
@@ -989,7 +989,7 @@ int msh_cmd_opt_id_get(int argc, char *argv[], void *options)
 
     for (opt_id = 0; (argc >= 2) && opt && opt->id; opt++)
     {
-        if (!strcmp(opt->name, argv[1]))
+        if (!rt_strcmp(opt->name, argv[1]))
         {
             opt_id = opt->id;
             break;
diff --git a/components/finsh/msh_file.c b/components/finsh/msh_file.c
@@ -90,7 +90,7 @@ int msh_exec_script(const char *cmd_line, int size)
     rt_memcpy(pg_name, cmd_line, cmd_length);
     pg_name[cmd_length] = '\0';
 
-    if (strstr(pg_name, ".sh") != RT_NULL || strstr(pg_name, ".SH") != RT_NULL)
+    if (rt_strstr(pg_name, ".sh") != RT_NULL || rt_strstr(pg_name, ".SH") != RT_NULL)
     {
         /* try to open program */
         fd = open(pg_name, O_RDONLY, 0);
@@ -351,7 +351,7 @@ static void directory_delete_for_msh(const char *pathname, char f, char v)
         if (rt_strcmp(".", dirent->d_name) != 0 &&
                 rt_strcmp("..", dirent->d_name) != 0)
         {
-            if (strlen(pathname) + 1 + strlen(dirent->d_name) > DFS_PATH_MAX)
+            if (rt_strlen(pathname) + 1 + rt_strlen(dirent->d_name) > DFS_PATH_MAX)
             {
                 rt_kprintf("cannot remove '%s/%s', path too long.\n", pathname, dirent->d_name);
                 continue;
@@ -518,7 +518,7 @@ static int cmd_mkfs(int argc, char **argv)
     }
     else if (argc == 4)
     {
-        if (strcmp(argv[1], "-t") == 0)
+        if (rt_strcmp(argv[1], "-t") == 0)
         {
             type = argv[2];
             result = dfs_mkfs(type, argv[3]);
@@ -585,7 +585,7 @@ static int cmd_mount(int argc, char **argv)
 
         /* mount a filesystem to the specified directory */
         rt_kprintf("mount device %s(%s) onto %s ... ", device, fstype, path);
-        if (strcmp(fstype, "nfs") == 0)
+        if (rt_strcmp(fstype, "nfs") == 0)
         {
             data = argv[1];
             device = 0;
@@ -663,7 +663,7 @@ static int cmd_umount(int argc, char **argv)
 
     if (argc > 2)
     {
-        flags = strcmp(argv[1], "-f") == 0 ? MNT_FORCE : 0;
+        flags = rt_strcmp(argv[1], "-f") == 0 ? MNT_FORCE : 0;
         path  = argv[2];
     }
 
@@ -693,7 +693,7 @@ static int cmd_df(int argc, char **argv)
     }
     else
     {
-        if ((strcmp(argv[1], "--help") == 0) || (strcmp(argv[1], "-h") == 0))
+        if ((rt_strcmp(argv[1], "--help") == 0) || (rt_strcmp(argv[1], "-h") == 0))
         {
             rt_kprintf("df [path]\n");
         }
@@ -721,7 +721,7 @@ static int cmd_echo(int argc, char **argv)
         fd = open(argv[2], O_RDWR | O_APPEND | O_CREAT, 0);
         if (fd >= 0)
         {
-            write(fd, argv[1], strlen(argv[1]));
+            write(fd, argv[1], rt_strlen(argv[1]));
             close(fd);
         }
         else
@@ -875,7 +875,7 @@ static void directory_setattr(const char *pathname, struct dfs_attr *attr, char
         if (rt_strcmp(".", dirent->d_name) != 0 &&
             rt_strcmp("..", dirent->d_name) != 0)
         {
-            if (strlen(pathname) + 1 + strlen(dirent->d_name) > DFS_PATH_MAX)
+            if (rt_strlen(pathname) + 1 + rt_strlen(dirent->d_name) > DFS_PATH_MAX)
             {
                 rt_kprintf("'%s/%s' setattr failed, path too long.\n", pathname, dirent->d_name);
                 continue;
diff --git a/components/finsh/shell.c b/components/finsh/shell.c
@@ -79,10 +79,10 @@ int finsh_set_prompt(const char *prompt)
     /* strdup */
     if (prompt)
     {
-        finsh_prompt_custom = (char *)rt_malloc(strlen(prompt) + 1);
+        finsh_prompt_custom = (char *)rt_malloc(rt_strlen(prompt) + 1);
         if (finsh_prompt_custom)
         {
-            strcpy(finsh_prompt_custom, prompt);
+            rt_strcpy(finsh_prompt_custom, prompt);
         }
     }
 
@@ -105,11 +105,11 @@ const char *finsh_get_prompt(void)
 
     if (finsh_prompt_custom)
     {
-        strncpy(finsh_prompt, finsh_prompt_custom, sizeof(finsh_prompt) - 1);
+        rt_strncpy(finsh_prompt, finsh_prompt_custom, sizeof(finsh_prompt) - 1);
     }
     else
     {
-        strcpy(finsh_prompt, _MSH_PROMPT);
+        rt_strcpy(finsh_prompt, _MSH_PROMPT);
     }
 
 #if defined(DFS_USING_POSIX) && defined(DFS_USING_WORKDIR)
@@ -423,7 +423,7 @@ static void shell_push_history(struct finsh_shell *shell)
         if (shell->history_count >= FINSH_HISTORY_LINES)
         {
             /* if current cmd is same as last cmd, don't push */
-            if (memcmp(&shell->cmd_history[FINSH_HISTORY_LINES - 1], shell->line, FINSH_CMD_SIZE))
+            if (rt_memcmp(&shell->cmd_history[FINSH_HISTORY_LINES - 1], shell->line, FINSH_CMD_SIZE))
             {
                 /* move history */
                 int index;
@@ -442,7 +442,7 @@ static void shell_push_history(struct finsh_shell *shell)
         else
         {
             /* if current cmd is same as last cmd, don't push */
-            if (shell->history_count == 0 || memcmp(&shell->cmd_history[shell->history_count - 1], shell->line, FINSH_CMD_SIZE))
+            if (shell->history_count == 0 || rt_memcmp(&shell->cmd_history[shell->history_count - 1], shell->line, FINSH_CMD_SIZE))
             {
                 shell->current_history = shell->history_count;
                 rt_memset(&shell->cmd_history[shell->history_count][0], 0, FINSH_CMD_SIZE);
@@ -597,7 +597,7 @@ static void finsh_thread_entry(void *parameter)
                 /* copy the history command */
                 rt_memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
                        FINSH_CMD_SIZE);
-                shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);
+                shell->line_curpos = shell->line_position = (rt_uint16_t)rt_strlen(shell->line);
                 shell_handle_history(shell);
 #endif
                 continue;
@@ -619,7 +619,7 @@ static void finsh_thread_entry(void *parameter)
 
                 rt_memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
                        FINSH_CMD_SIZE);
-                shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);
+                shell->line_curpos = shell->line_position = (rt_uint16_t)rt_strlen(shell->line);
                 shell_handle_history(shell);
 #endif
                 continue;
@@ -758,7 +758,7 @@ static void finsh_thread_entry(void *parameter)
             /* auto complete */
             shell_auto_complete(&shell->line[0]);
             /* re-calculate position */
-            shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);
+            shell->line_curpos = shell->line_position = (rt_uint16_t)rt_strlen(shell->line);
 
             continue;
         }

Original file line number	Diff line number	Diff line change
`@@ -940,64 +940,64 @@ static int cmd_list(int argc, char **argv)`
`940`	`940`	`{`
`941`	`941`	`if(argc == 2)`
`942`	`942`	`{`
`943`		`- if(strcmp(argv[1], "thread") == 0)`
	`943`	`+ if(rt_strcmp(argv[1], "thread") == 0)`
`944`	`944`	`{`
`945`	`945`	`list_thread();`
`946`	`946`	`}`
`947`		`- else if(strcmp(argv[1], "timer") == 0)`
	`947`	`+ else if(rt_strcmp(argv[1], "timer") == 0)`
`948`	`948`	`{`
`949`	`949`	`list_timer();`
`950`	`950`	`}`
`951`	`951`	`#ifdef RT_USING_SEMAPHORE`
`952`		`- else if(strcmp(argv[1], "sem") == 0)`
	`952`	`+ else if(rt_strcmp(argv[1], "sem") == 0)`
`953`	`953`	`{`
`954`	`954`	`list_sem();`
`955`	`955`	`}`
`956`	`956`	`#endif /* RT_USING_SEMAPHORE */`
`957`	`957`	`#ifdef RT_USING_EVENT`
`958`		`- else if(strcmp(argv[1], "event") == 0)`
	`958`	`+ else if(rt_strcmp(argv[1], "event") == 0)`
`959`	`959`	`{`
`960`	`960`	`list_event();`
`961`	`961`	`}`
`962`	`962`	`#endif /* RT_USING_EVENT */`
`963`	`963`	`#ifdef RT_USING_MUTEX`
`964`		`- else if(strcmp(argv[1], "mutex") == 0)`
	`964`	`+ else if(rt_strcmp(argv[1], "mutex") == 0)`
`965`	`965`	`{`
`966`	`966`	`list_mutex();`
`967`	`967`	`}`
`968`	`968`	`#endif /* RT_USING_MUTEX */`
`969`	`969`	`#ifdef RT_USING_MAILBOX`
`970`		`- else if(strcmp(argv[1], "mailbox") == 0)`
	`970`	`+ else if(rt_strcmp(argv[1], "mailbox") == 0)`
`971`	`971`	`{`
`972`	`972`	`list_mailbox();`
`973`	`973`	`}`
`974`	`974`	`#endif /* RT_USING_MAILBOX */`
`975`	`975`	`#ifdef RT_USING_MESSAGEQUEUE`
`976`		`- else if(strcmp(argv[1], "msgqueue") == 0)`
	`976`	`+ else if(rt_strcmp(argv[1], "msgqueue") == 0)`
`977`	`977`	`{`
`978`	`978`	`list_msgqueue();`
`979`	`979`	`}`
`980`	`980`	`#endif /* RT_USING_MESSAGEQUEUE */`
`981`	`981`	`#ifdef RT_USING_MEMHEAP`
`982`		`- else if(strcmp(argv[1], "memheap") == 0)`
	`982`	`+ else if(rt_strcmp(argv[1], "memheap") == 0)`
`983`	`983`	`{`
`984`	`984`	`list_memheap();`
`985`	`985`	`}`
`986`	`986`	`#endif /* RT_USING_MEMHEAP */`
`987`	`987`	`#ifdef RT_USING_MEMPOOL`
`988`		`- else if(strcmp(argv[1], "mempool") == 0)`
	`988`	`+ else if(rt_strcmp(argv[1], "mempool") == 0)`
`989`	`989`	`{`
`990`	`990`	`list_mempool();`
`991`	`991`	`}`
`992`	`992`	`#endif /* RT_USING_MEMPOOL */`
`993`	`993`	`#ifdef RT_USING_DEVICE`
`994`		`- else if(strcmp(argv[1], "device") == 0)`
	`994`	`+ else if(rt_strcmp(argv[1], "device") == 0)`
`995`	`995`	`{`
`996`	`996`	`list_device();`
`997`	`997`	`}`
`998`	`998`	`#endif /* RT_USING_DEVICE */`
`999`	`999`	`#ifdef RT_USING_DFS`
`1000`		`- else if(strcmp(argv[1], "fd") == 0)`
	`1000`	`+ else if(rt_strcmp(argv[1], "fd") == 0)`
`1001`	`1001`	`{`
`1002`	`1002`	`extern int list_fd(void);`
`1003`	`1003`	`list_fd();`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ static int cmd_ps(int argc, char **argv)`
`63`	`63`	`extern int list_module(void);`
`64`	`64`
`65`	`65`	`#ifdef RT_USING_MODULE`
`66`		`- if ((argc == 2) && (strcmp(argv[1], "-m") == 0))`
	`66`	`+ if ((argc == 2) && (rt_strcmp(argv[1], "-m") == 0))`
`67`	`67`	`list_module();`
`68`	`68`	`else`
`69`	`69`	`#endif`
`@@ -237,7 +237,7 @@ static cmd_function_t msh_get_cmd(char *cmd, int size)`
`237`	`237`	`index < _syscall_table_end;`
`238`	`238`	`FINSH_NEXT_SYSCALL(index))`
`239`	`239`	`{`
`240`		`- if (strncmp(index->name, cmd, size) == 0 &&`
	`240`	`+ if (rt_strncmp(index->name, cmd, size) == 0 &&`
`241`	`241`	`index->name[size] == '\0')`
`242`	`242`	`{`
`243`	`243`	`cmd_func = (cmd_function_t)index->func;`
`@@ -276,7 +276,7 @@ int msh_exec_module(const char *cmd_line, int size)`
`276`	`276`	`rt_memcpy(pg_name, cmd_line, cmd_length);`
`277`	`277`	`pg_name[cmd_length] = '\0';`
`278`	`278`
`279`		`- if (strstr(pg_name, ".mo") != RT_NULL \|\| strstr(pg_name, ".MO") != RT_NULL)`
	`279`	`+ if (rt_strstr(pg_name, ".mo") != RT_NULL \|\| rt_strstr(pg_name, ".MO") != RT_NULL)`
`280`	`280`	`{`
`281`	`281`	`/* try to open program */`
`282`	`282`	`fd = open(pg_name, O_RDONLY, 0);`
`@@ -374,12 +374,12 @@ static rt_bool_t _msh_lwp_cmd_exists(const char *path)`
`374`	`374`	`static char _msh_exec_search_path(const char path, const char *pg_name)`
`375`	`375`	`{`
`376`	`376`	`char *path_buffer = RT_NULL;`
`377`		`- ssize_t pg_len = strlen(pg_name);`
	`377`	`+ ssize_t pg_len = rt_strlen(pg_name);`
`378`	`378`	`ssize_t base_len = 0;`
`379`	`379`
`380`	`380`	`if (path)`
`381`	`381`	`{`
`382`		`- base_len = strlen(path);`
	`382`	`+ base_len = rt_strlen(path);`
`383`	`383`	`}`
`384`	`384`
`385`	`385`	`path_buffer = rt_malloc(base_len + pg_len + 6);`
`@@ -390,7 +390,7 @@ static char _msh_exec_search_path(const char path, const char *pg_name)`
`390`	`390`
`391`	`391`	`if (base_len > 0)`
`392`	`392`	`{`
`393`		`- memcpy(path_buffer, path, base_len);`
	`393`	`+ rt_memcpy(path_buffer, path, base_len);`
`394`	`394`	`path_buffer[base_len] = '/';`
`395`	`395`	`path_buffer[base_len + 1] = '\0';`
`396`	`396`	`}`
`@@ -405,7 +405,7 @@ static char _msh_exec_search_path(const char path, const char *pg_name)`
`405`	`405`	`return path_buffer;`
`406`	`406`	`}`
`407`	`407`
`408`		`- if (strstr(path_buffer, ".elf") != NULL)`
	`408`	`+ if (rt_strstr(path_buffer, ".elf") != NULL)`
`409`	`409`	`{`
`410`	`410`	`goto not_found;`
`411`	`411`	`}`
`@@ -506,7 +506,7 @@ int _msh_exec_lwp(int debug, char *cmd, rt_size_t length)`
`506`	`506`
`507`	`507`	`/* only check these paths when the first argument doesn't contain path`
`508`	`508`	`seperator */`
`509`		`- if (strstr(argv[0], "/"))`
	`509`	`+ if (rt_strstr(argv[0], "/"))`
`510`	`510`	`{`
`511`	`511`	`return -1;`
`512`	`512`	`}`
`@@ -704,14 +704,14 @@ void msh_auto_complete_path(char *path)`
`704`	`704`	`if (dirent == RT_NULL) break;`
`705`	`705`
`706`	`706`	`/* matched the prefix string */`
`707`		`- if (strncmp(index, dirent->d_name, rt_strlen(index)) == 0)`
	`707`	`+ if (rt_strncmp(index, dirent->d_name, rt_strlen(index)) == 0)`
`708`	`708`	`{`
`709`	`709`	`multi ++;`
`710`	`710`	`if (min_length == 0)`
`711`	`711`	`{`
`712`	`712`	`min_length = rt_strlen(dirent->d_name);`
`713`	`713`	`/* save dirent name */`
`714`		`- strcpy(full_path, dirent->d_name);`
	`714`	`+ rt_strcpy(full_path, dirent->d_name);`
`715`	`715`	`}`
`716`	`716`
`717`	`717`	`length = str_common(dirent->d_name, full_path);`
`@@ -735,7 +735,7 @@ void msh_auto_complete_path(char *path)`
`735`	`735`	`dirent = readdir(dir);`
`736`	`736`	`if (dirent == RT_NULL) break;`
`737`	`737`
`738`		`- if (strncmp(index, dirent->d_name, rt_strlen(index)) == 0)`
	`738`	`+ if (rt_strncmp(index, dirent->d_name, rt_strlen(index)) == 0)`
`739`	`739`	`rt_kprintf("%s\n", dirent->d_name);`
`740`	`740`	`}`
`741`	`741`	`}`
`@@ -822,14 +822,14 @@ void msh_auto_complete(char *prefix)`
`822`	`822`	`{`
`823`	`823`	`/* skip finsh shell function */`
`824`	`824`	`cmd_name = (const char *) index->name;`
`825`		`- if (strncmp(prefix, cmd_name, strlen(prefix)) == 0)`
	`825`	`+ if (rt_strncmp(prefix, cmd_name, rt_strlen(prefix)) == 0)`
`826`	`826`	`{`
`827`	`827`	`if (min_length == 0)`
`828`	`828`	`{`
`829`	`829`	`/* set name_ptr */`
`830`	`830`	`name_ptr = cmd_name;`
`831`	`831`	`/* set initial length */`
`832`		`- min_length = strlen(name_ptr);`
	`832`	`+ min_length = rt_strlen(name_ptr);`
`833`	`833`	`}`
`834`	`834`
`835`	`835`	`length = str_common(name_ptr, cmd_name);`
`@@ -865,14 +865,14 @@ static msh_cmd_opt_t msh_get_cmd_opt(char opt_str)`
`865`	`865`	`}`
`866`	`866`	`else`
`867`	`867`	`{`
`868`		`- len = strlen(opt_str);`
	`868`	`+ len = rt_strlen(opt_str);`
`869`	`869`	`}`
`870`	`870`	`#if defined(FINSH_USING_SYMTAB)`
`871`	`871`	`for (index = _syscall_table_begin;`
`872`	`872`	`index < _syscall_table_end;`
`873`	`873`	`FINSH_NEXT_SYSCALL(index))`
`874`	`874`	`{`
`875`		`- if (strncmp(index->name, opt_str, len) == 0 && index->name[len] == '\0')`
	`875`	`+ if (rt_strncmp(index->name, opt_str, len) == 0 && index->name[len] == '\0')`
`876`	`876`	`{`
`877`	`877`	`opt = index->opt;`
`878`	`878`	`break;`
`@@ -906,18 +906,18 @@ static void msh_opt_complete(char opts_str, struct msh_cmd_opt cmd_opt)`
`906`	`906`	`const char *name_ptr = RT_NULL;`
`907`	`907`	`int min_length = 0, length, opts_str_len;`
`908`	`908`
`909`		`- opts_str_len = strlen(opts_str);`
	`909`	`+ opts_str_len = rt_strlen(opts_str);`
`910`	`910`
`911`	`911`	`for (opt = cmd_opt; opt->id; opt++)`
`912`	`912`	`{`
`913`		`- if (!strncmp(opt->name, opts_str, opts_str_len))`
	`913`	`+ if (!rt_strncmp(opt->name, opts_str, opts_str_len))`
`914`	`914`	`{`
`915`	`915`	`if (min_length == 0)`
`916`	`916`	`{`
`917`	`917`	`/* set name_ptr */`
`918`	`918`	`name_ptr = opt->name;`
`919`	`919`	`/* set initial length */`
`920`		`- min_length = strlen(name_ptr);`
	`920`	`+ min_length = rt_strlen(name_ptr);`
`921`	`921`	`}`
`922`	`922`
`923`	`923`	`length = str_common(name_ptr, opt->name);`
`@@ -933,7 +933,7 @@ static void msh_opt_complete(char opts_str, struct msh_cmd_opt cmd_opt)`
`933`	`933`
`934`	`934`	`if (name_ptr != NULL)`
`935`	`935`	`{`
`936`		`- strncpy(opts_str, name_ptr, min_length);`
	`936`	`+ rt_strncpy(opts_str, name_ptr, min_length);`
`937`	`937`	`}`
`938`	`938`	`}`
`939`	`939`
`@@ -959,7 +959,7 @@ void msh_opt_auto_complete(char *prefix)`
`959`	`959`	`{`
`960`	`960`	`opt = msh_get_cmd_opt(prefix);`
`961`	`961`	`}`
`962`		`- else if (!msh_get_cmd(prefix, strlen(prefix)) && (' ' == prefix[strlen(prefix) - 1]))`
	`962`	`+ else if (!msh_get_cmd(prefix, rt_strlen(prefix)) && (' ' == prefix[rt_strlen(prefix) - 1]))`
`963`	`963`	`{`
`964`	`964`	`opt = msh_get_cmd_opt(prefix);`
`965`	`965`	`}`
`@@ -989,7 +989,7 @@ int msh_cmd_opt_id_get(int argc, char argv[], void options)`
`989`	`989`
`990`	`990`	`for (opt_id = 0; (argc >= 2) && opt && opt->id; opt++)`
`991`	`991`	`{`
`992`		`- if (!strcmp(opt->name, argv[1]))`
	`992`	`+ if (!rt_strcmp(opt->name, argv[1]))`
`993`	`993`	`{`
`994`	`994`	`opt_id = opt->id;`
`995`	`995`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ int msh_exec_script(const char *cmd_line, int size)`
`90`	`90`	`rt_memcpy(pg_name, cmd_line, cmd_length);`
`91`	`91`	`pg_name[cmd_length] = '\0';`
`92`	`92`
`93`		`- if (strstr(pg_name, ".sh") != RT_NULL \|\| strstr(pg_name, ".SH") != RT_NULL)`
	`93`	`+ if (rt_strstr(pg_name, ".sh") != RT_NULL \|\| rt_strstr(pg_name, ".SH") != RT_NULL)`
`94`	`94`	`{`
`95`	`95`	`/* try to open program */`
`96`	`96`	`fd = open(pg_name, O_RDONLY, 0);`
`@@ -351,7 +351,7 @@ static void directory_delete_for_msh(const char *pathname, char f, char v)`
`351`	`351`	`if (rt_strcmp(".", dirent->d_name) != 0 &&`
`352`	`352`	`rt_strcmp("..", dirent->d_name) != 0)`
`353`	`353`	`{`
`354`		`- if (strlen(pathname) + 1 + strlen(dirent->d_name) > DFS_PATH_MAX)`
	`354`	`+ if (rt_strlen(pathname) + 1 + rt_strlen(dirent->d_name) > DFS_PATH_MAX)`
`355`	`355`	`{`
`356`	`356`	`rt_kprintf("cannot remove '%s/%s', path too long.\n", pathname, dirent->d_name);`
`357`	`357`	`continue;`
`@@ -518,7 +518,7 @@ static int cmd_mkfs(int argc, char **argv)`
`518`	`518`	`}`
`519`	`519`	`else if (argc == 4)`
`520`	`520`	`{`
`521`		`- if (strcmp(argv[1], "-t") == 0)`
	`521`	`+ if (rt_strcmp(argv[1], "-t") == 0)`
`522`	`522`	`{`
`523`	`523`	`type = argv[2];`
`524`	`524`	`result = dfs_mkfs(type, argv[3]);`
`@@ -585,7 +585,7 @@ static int cmd_mount(int argc, char **argv)`
`585`	`585`
`586`	`586`	`/* mount a filesystem to the specified directory */`
`587`	`587`	`rt_kprintf("mount device %s(%s) onto %s ... ", device, fstype, path);`
`588`		`- if (strcmp(fstype, "nfs") == 0)`
	`588`	`+ if (rt_strcmp(fstype, "nfs") == 0)`
`589`	`589`	`{`
`590`	`590`	`data = argv[1];`
`591`	`591`	`device = 0;`
`@@ -663,7 +663,7 @@ static int cmd_umount(int argc, char **argv)`
`663`	`663`
`664`	`664`	`if (argc > 2)`
`665`	`665`	`{`
`666`		`- flags = strcmp(argv[1], "-f") == 0 ? MNT_FORCE : 0;`
	`666`	`+ flags = rt_strcmp(argv[1], "-f") == 0 ? MNT_FORCE : 0;`
`667`	`667`	`path = argv[2];`
`668`	`668`	`}`
`669`	`669`
`@@ -693,7 +693,7 @@ static int cmd_df(int argc, char **argv)`
`693`	`693`	`}`
`694`	`694`	`else`
`695`	`695`	`{`
`696`		`- if ((strcmp(argv[1], "--help") == 0) \|\| (strcmp(argv[1], "-h") == 0))`
	`696`	`+ if ((rt_strcmp(argv[1], "--help") == 0) \|\| (rt_strcmp(argv[1], "-h") == 0))`
`697`	`697`	`{`
`698`	`698`	`rt_kprintf("df [path]\n");`
`699`	`699`	`}`
`@@ -721,7 +721,7 @@ static int cmd_echo(int argc, char **argv)`
`721`	`721`	`fd = open(argv[2], O_RDWR \| O_APPEND \| O_CREAT, 0);`
`722`	`722`	`if (fd >= 0)`
`723`	`723`	`{`
`724`		`- write(fd, argv[1], strlen(argv[1]));`
	`724`	`+ write(fd, argv[1], rt_strlen(argv[1]));`
`725`	`725`	`close(fd);`
`726`	`726`	`}`
`727`	`727`	`else`
`@@ -875,7 +875,7 @@ static void directory_setattr(const char pathname, struct dfs_attr attr, char`
`875`	`875`	`if (rt_strcmp(".", dirent->d_name) != 0 &&`
`876`	`876`	`rt_strcmp("..", dirent->d_name) != 0)`
`877`	`877`	`{`
`878`		`- if (strlen(pathname) + 1 + strlen(dirent->d_name) > DFS_PATH_MAX)`
	`878`	`+ if (rt_strlen(pathname) + 1 + rt_strlen(dirent->d_name) > DFS_PATH_MAX)`
`879`	`879`	`{`
`880`	`880`	`rt_kprintf("'%s/%s' setattr failed, path too long.\n", pathname, dirent->d_name);`
`881`	`881`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -79,10 +79,10 @@ int finsh_set_prompt(const char *prompt)`
`79`	`79`	`/* strdup */`
`80`	`80`	`if (prompt)`
`81`	`81`	`{`
`82`		`- finsh_prompt_custom = (char *)rt_malloc(strlen(prompt) + 1);`
	`82`	`+ finsh_prompt_custom = (char *)rt_malloc(rt_strlen(prompt) + 1);`
`83`	`83`	`if (finsh_prompt_custom)`
`84`	`84`	`{`
`85`		`- strcpy(finsh_prompt_custom, prompt);`
	`85`	`+ rt_strcpy(finsh_prompt_custom, prompt);`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`@@ -105,11 +105,11 @@ const char *finsh_get_prompt(void)`
`105`	`105`
`106`	`106`	`if (finsh_prompt_custom)`
`107`	`107`	`{`
`108`		`- strncpy(finsh_prompt, finsh_prompt_custom, sizeof(finsh_prompt) - 1);`
	`108`	`+ rt_strncpy(finsh_prompt, finsh_prompt_custom, sizeof(finsh_prompt) - 1);`
`109`	`109`	`}`
`110`	`110`	`else`
`111`	`111`	`{`
`112`		`- strcpy(finsh_prompt, _MSH_PROMPT);`
	`112`	`+ rt_strcpy(finsh_prompt, _MSH_PROMPT);`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`#if defined(DFS_USING_POSIX) && defined(DFS_USING_WORKDIR)`
`@@ -423,7 +423,7 @@ static void shell_push_history(struct finsh_shell *shell)`
`423`	`423`	`if (shell->history_count >= FINSH_HISTORY_LINES)`
`424`	`424`	`{`
`425`	`425`	`/* if current cmd is same as last cmd, don't push */`
`426`		`- if (memcmp(&shell->cmd_history[FINSH_HISTORY_LINES - 1], shell->line, FINSH_CMD_SIZE))`
	`426`	`+ if (rt_memcmp(&shell->cmd_history[FINSH_HISTORY_LINES - 1], shell->line, FINSH_CMD_SIZE))`
`427`	`427`	`{`
`428`	`428`	`/* move history */`
`429`	`429`	`int index;`
`@@ -442,7 +442,7 @@ static void shell_push_history(struct finsh_shell *shell)`
`442`	`442`	`else`
`443`	`443`	`{`
`444`	`444`	`/* if current cmd is same as last cmd, don't push */`
`445`		`- if (shell->history_count == 0 \|\| memcmp(&shell->cmd_history[shell->history_count - 1], shell->line, FINSH_CMD_SIZE))`
	`445`	`+ if (shell->history_count == 0 \|\| rt_memcmp(&shell->cmd_history[shell->history_count - 1], shell->line, FINSH_CMD_SIZE))`
`446`	`446`	`{`
`447`	`447`	`shell->current_history = shell->history_count;`
`448`	`448`	`rt_memset(&shell->cmd_history[shell->history_count][0], 0, FINSH_CMD_SIZE);`
`@@ -597,7 +597,7 @@ static void finsh_thread_entry(void *parameter)`
`597`	`597`	`/* copy the history command */`
`598`	`598`	`rt_memcpy(shell->line, &shell->cmd_history[shell->current_history][0],`
`599`	`599`	`FINSH_CMD_SIZE);`
`600`		`- shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);`
	`600`	`+ shell->line_curpos = shell->line_position = (rt_uint16_t)rt_strlen(shell->line);`
`601`	`601`	`shell_handle_history(shell);`
`602`	`602`	`#endif`
`603`	`603`	`continue;`
`@@ -619,7 +619,7 @@ static void finsh_thread_entry(void *parameter)`
`619`	`619`
`620`	`620`	`rt_memcpy(shell->line, &shell->cmd_history[shell->current_history][0],`
`621`	`621`	`FINSH_CMD_SIZE);`
`622`		`- shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);`
	`622`	`+ shell->line_curpos = shell->line_position = (rt_uint16_t)rt_strlen(shell->line);`
`623`	`623`	`shell_handle_history(shell);`
`624`	`624`	`#endif`
`625`	`625`	`continue;`
`@@ -758,7 +758,7 @@ static void finsh_thread_entry(void *parameter)`
`758`	`758`	`/* auto complete */`
`759`	`759`	`shell_auto_complete(&shell->line[0]);`
`760`	`760`	`/* re-calculate position */`
`761`		`- shell->line_curpos = shell->line_position = (rt_uint16_t)strlen(shell->line);`
	`761`	`+ shell->line_curpos = shell->line_position = (rt_uint16_t)rt_strlen(shell->line);`
`762`	`762`
`763`	`763`	`continue;`
`764`	`764`	`}`