Merge branch 'master' of https://github.com/RT-Thread/rt-thread

29 files changed, 545 insertions, 256 deletions

diff --git a/components/dfs/filesystems/devfs/devfs.c b/components/dfs/filesystems/devfs/devfs.c
index 1f4569558f..fcbb738572 100644
--- a/components/dfs/filesystems/devfs/devfs.c
+++ b/components/dfs/filesystems/devfs/devfs.c
@@ -213,8 +213,7 @@ int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat
 
         st->st_size  = 0;
         st->st_mtime = 0;
-        st->st_blksize = 512;
-        
+
         return DFS_STATUS_OK;
     }
     else
@@ -238,8 +237,7 @@ int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat
 
             st->st_size  = 0;
             st->st_mtime = 0;
-            st->st_blksize = 512;
-            
+
             return DFS_STATUS_OK;
         }
     }
diff --git a/components/dfs/filesystems/elmfat/dfs_elm.c b/components/dfs/filesystems/elmfat/dfs_elm.c
index 3658a5dc80..ca2c082972 100644
--- a/components/dfs/filesystems/elmfat/dfs_elm.c
+++ b/components/dfs/filesystems/elmfat/dfs_elm.c
@@ -738,7 +738,6 @@ int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
             st->st_mode &= ~(DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH);
 
         st->st_size  = file_info.fsize;
-        st->st_blksize = 512;
 
         /* get st_mtime. */
         {
diff --git a/components/dfs/filesystems/jffs2/dfs_jffs2.c b/components/dfs/filesystems/jffs2/dfs_jffs2.c
index 6516797544..78c7730136 100644
--- a/components/dfs/filesystems/jffs2/dfs_jffs2.c
+++ b/components/dfs/filesystems/jffs2/dfs_jffs2.c
@@ -331,7 +331,7 @@ static int dfs_jffs2_open(struct dfs_fd* file)
 		return jffs2_result_to_dfs(result);
     }
 	
-	/* save this pointer, it will be used when calling read()��write(), 
+	/* save this pointer, it will be used when calling read()��write(), 
 	flush(), lessk(), and will be rt_free when calling close()*/
 	file->data = jffs2_file;
 	file->pos = jffs2_file->f_offset; 
@@ -686,7 +686,6 @@ static int dfs_jffs2_stat(struct dfs_filesystem* fs, const char *path, struct st
 	st->st_dev  = 0;
 	st->st_size = s.st_size;
 	st->st_mtime = s.st_mtime;
-	st->st_blksize = 1;//fixme: what's this field?
 
 	return 0;
 }
diff --git a/components/dfs/filesystems/lwip/lwip_netdb.c b/components/dfs/filesystems/lwip/lwip_netdb.c
index 6871474251..1e14dfb093 100644
--- a/components/dfs/filesystems/lwip/lwip_netdb.c
+++ b/components/dfs/filesystems/lwip/lwip_netdb.c
@@ -29,6 +29,7 @@ struct hostent *gethostbyname(const char *name)
 {
     return lwip_gethostbyname(name);
 }
+RTM_EXPORT(gethostbyname);
 
 int gethostbyname_r(const char *name, struct hostent *ret, char *buf,
                 size_t buflen, struct hostent **result, int *h_errnop)
@@ -40,6 +41,7 @@ void freeaddrinfo(struct addrinfo *ai)
 {
     lwip_freeaddrinfo(ai);
 }
+RTM_EXPORT(freeaddrinfo);
 
 int getaddrinfo(const char *nodename,
        const char *servname,
@@ -48,3 +50,4 @@ int getaddrinfo(const char *nodename,
 {
     return lwip_getaddrinfo(nodename, servname, hints, res);
 }
+RTM_EXPORT(getaddrinfo);
diff --git a/components/dfs/filesystems/lwip/lwip_select.c b/components/dfs/filesystems/lwip/lwip_select.c
index 3477b6f1d6..31d9190cfc 100644
--- a/components/dfs/filesystems/lwip/lwip_select.c
+++ b/components/dfs/filesystems/lwip/lwip_select.c
@@ -118,5 +118,6 @@ select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
     
     return result;
 }
+RTM_EXPORT(select);
 
 #endif
diff --git a/components/dfs/filesystems/lwip/lwip_sockets.c b/components/dfs/filesystems/lwip/lwip_sockets.c
index 346ef7b266..6b68378f7d 100644
--- a/components/dfs/filesystems/lwip/lwip_sockets.c
+++ b/components/dfs/filesystems/lwip/lwip_sockets.c
@@ -32,154 +32,167 @@
 
 int accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 {
-	int new_client = -1;
+    int new_client = -1;
     int sock = dfs_lwip_getsocket(s);
 
     new_client = lwip_accept(sock, addr, addrlen);
-	if (new_client != -1)
-	{
-		/* this is a new socket, create it in file system fd */
-		int fd;
-		struct dfs_fd *d;
-		
-		/* allocate a fd */
-		fd = fd_new();
-		if (fd < 0)
-		{
-			rt_set_errno(-DFS_STATUS_ENOMEM);
-			lwip_close(sock);
+    if (new_client != -1)
+    {
+        /* this is a new socket, create it in file system fd */
+        int fd;
+        struct dfs_fd *d;
 
-            printf("no fd yet!\n");
-			return -1;
-		}
-		d = fd_get(fd);
+        /* allocate a fd */
+        fd = fd_new();
+        if (fd < 0)
+        {
+            rt_set_errno(-DFS_STATUS_ENOMEM);
+            lwip_close(sock);
 
-		/* this is a socket fd */
-		d->type = FT_SOCKET;
-		d->path = RT_NULL;
-		
-		d->fs = dfs_lwip_get_fs();
-		
-		d->flags = DFS_O_RDWR; /* set flags as read and write */
-		d->size = 0;
-		d->pos	= 0;
+            rt_kprintf("no fd yet!\n");
+            return -1;
+        }
+        d = fd_get(fd);
 
-		/* set socket to the data of dfs_fd */
-		d->data = (void*) new_client;
+        /* this is a socket fd */
+        d->type = FT_SOCKET;
+        d->path = RT_NULL;
+
+        d->fs = dfs_lwip_get_fs();
+
+        d->flags = DFS_O_RDWR; /* set flags as read and write */
+        d->size = 0;
+        d->pos  = 0;
+
+        /* set socket to the data of dfs_fd */
+        d->data = (void *) new_client;
+
+        /* release the ref-count of fd */
+        fd_put(d);
 
-	    /* release the ref-count of fd */
-	    fd_put(d);
-        
         return fd;
-	}
+    }
 
-	return new_client;
+    return new_client;
 }
+RTM_EXPORT(accept);
 
 int bind(int s, const struct sockaddr *name, socklen_t namelen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_bind(sock, name, namelen);
 }
+RTM_EXPORT(bind);
 
 int shutdown(int s, int how)
 {
     int sock;
-	struct dfs_fd *d;
+    struct dfs_fd *d;
 
-	d = fd_get(s);
-	if (d == RT_NULL)
-	{
-		rt_set_errno(-DFS_STATUS_EBADF);
-		
-		return -1;
-	}
+    d = fd_get(s);
+    if (d == RT_NULL)
+    {
+        rt_set_errno(-DFS_STATUS_EBADF);
 
-	sock = dfs_lwip_getsocket(s);
+        return -1;
+    }
+
+    sock = dfs_lwip_getsocket(s);
     if (lwip_shutdown(sock, how) == 0)
     {
-    	/* socket has been closed, delete it from file system fd */
-		fd_put(d);
-		fd_put(d);
-		
-		return 0;
+        /* socket has been closed, delete it from file system fd */
+        fd_put(d);
+        fd_put(d);
+
+        return 0;
     }
 
-	return -1;
+    return -1;
 }
+RTM_EXPORT(shutdown);
 
-int getpeername (int s, struct sockaddr *name, socklen_t *namelen)
+int getpeername(int s, struct sockaddr *name, socklen_t *namelen)
 {
     int sock = dfs_lwip_getsocket(s);
 
     return lwip_getpeername(sock, name, namelen);
 }
+RTM_EXPORT(getpeername);
 
-int getsockname (int s, struct sockaddr *name, socklen_t *namelen)
+int getsockname(int s, struct sockaddr *name, socklen_t *namelen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_getsockname(sock, name, namelen);
 }
+RTM_EXPORT(getsockname);
 
-int getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen)
+int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_getsockopt(sock, level, optname, optval, optlen);
 }
+RTM_EXPORT(getsockopt);
 
-int setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen)
+int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_setsockopt(sock, level, optname, optval, optlen);
 }
+RTM_EXPORT(setsockopt);
 
 int connect(int s, const struct sockaddr *name, socklen_t namelen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_connect(sock, name, namelen);
 }
+RTM_EXPORT(connect);
 
 int listen(int s, int backlog)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_listen(sock, backlog);
 }
+RTM_EXPORT(listen);
 
 int recv(int s, void *mem, size_t len, int flags)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_recv(sock, mem, len, flags);
 }
+RTM_EXPORT(recv);
 
 int recvfrom(int s, void *mem, size_t len, int flags,
-      struct sockaddr *from, socklen_t *fromlen)
+             struct sockaddr *from, socklen_t *fromlen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_recvfrom(sock, mem, len, flags, from, fromlen);
 }
+RTM_EXPORT(recvfrom);
 
 int send(int s, const void *dataptr, size_t size, int flags)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_send(sock, dataptr, size, flags);
 }
+RTM_EXPORT(send);
 
 int sendto(int s, const void *dataptr, size_t size, int flags,
-    const struct sockaddr *to, socklen_t tolen)
+           const struct sockaddr *to, socklen_t tolen)
 {
     int sock = dfs_lwip_getsocket(s);
-    
+
     return lwip_sendto(sock, dataptr, size, flags, to, tolen);
 }
+RTM_EXPORT(sendto);
 
 int socket(int domain, int type, int protocol)
 {
@@ -207,13 +220,13 @@ int socket(int domain, int type, int protocol)
         d->path = RT_NULL;
 
         d->fs = dfs_lwip_get_fs();
-        
+
         d->flags = DFS_O_RDWR; /* set flags as read and write */
         d->size = 0;
         d->pos  = 0;
-        
+
         /* set socket to the data of dfs_fd */
-        d->data = (void*) sock;
+        d->data = (void *) sock;
     }
 
     /* release the ref-count of fd */
@@ -221,4 +234,4 @@ int socket(int domain, int type, int protocol)
 
     return fd;
 }
-
+RTM_EXPORT(socket);
diff --git a/components/dfs/filesystems/lwip/sys/socket.h b/components/dfs/filesystems/lwip/sys/socket.h
index 5317e05e4c..b9608d97ed 100644
--- a/components/dfs/filesystems/lwip/sys/socket.h
+++ b/components/dfs/filesystems/lwip/sys/socket.h
@@ -29,9 +29,11 @@
 extern "C" {
 #endif
 
+#include <inttypes.h>
 #include <lwip/sockets.h>
 
 typedef uint16_t sa_family_t;
+typedef uint16_t in_port_t;
 
 struct sockaddr_storage
 {
diff --git a/components/dfs/filesystems/nfs/dfs_nfs.c b/components/dfs/filesystems/nfs/dfs_nfs.c
index 7ff5fef5f7..4bf96c2aeb 100644
--- a/components/dfs/filesystems/nfs/dfs_nfs.c
+++ b/components/dfs/filesystems/nfs/dfs_nfs.c
@@ -850,7 +850,6 @@ int nfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
 
     st->st_size  = info->size;
     st->st_mtime = info->mtime.seconds;
-    st->st_blksize = 512;
 
     xdr_free((xdrproc_t)xdr_GETATTR3res, (char *)&res);
     xdr_free((xdrproc_t)xdr_nfs_fh3, (char *)handle);
diff --git a/components/dfs/filesystems/ramfs/dfs_ramfs.c b/components/dfs/filesystems/ramfs/dfs_ramfs.c
index fecebe4688..7533b6f192 100644
--- a/components/dfs/filesystems/ramfs/dfs_ramfs.c
+++ b/components/dfs/filesystems/ramfs/dfs_ramfs.c
@@ -292,7 +292,6 @@ int dfs_ramfs_stat(struct dfs_filesystem *fs,
 
     st->st_size = dirent->size;
     st->st_mtime = 0;
-    st->st_blksize = 512;
 
     return DFS_STATUS_OK;
 }
diff --git a/components/dfs/filesystems/romfs/dfs_romfs.c b/components/dfs/filesystems/romfs/dfs_romfs.c
index 65fc331466..6110d61227 100644
--- a/components/dfs/filesystems/romfs/dfs_romfs.c
+++ b/components/dfs/filesystems/romfs/dfs_romfs.c
@@ -96,7 +96,8 @@ struct romfs_dirent *dfs_romfs_lookup(struct romfs_dirent *root_dirent, const ch
 		{
             if (check_dirent(&dirent[index]) != 0)
                 return RT_NULL;
-			if (rt_strncmp(dirent[index].name, subpath, (subpath_end - subpath)) == 0)
+			if (rt_strlen(dirent[index].name) == (subpath_end - subpath) &&
+					rt_strncmp(dirent[index].name, subpath, (subpath_end - subpath)) == 0)
 			{
 				dirent_size = dirent[index].size;
 
@@ -245,7 +246,6 @@ int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
 
 	st->st_size = dirent->size;
 	st->st_mtime = 0;
-	st->st_blksize = 512;
 
 	return DFS_STATUS_OK;
 }
diff --git a/components/dfs/filesystems/uffs/dfs_uffs.c b/components/dfs/filesystems/uffs/dfs_uffs.c
index faaee0990e..87517aaaf5 100644
--- a/components/dfs/filesystems/uffs/dfs_uffs.c
+++ b/components/dfs/filesystems/uffs/dfs_uffs.c
@@ -347,7 +347,7 @@ static int dfs_uffs_open(struct dfs_fd* file)
 		return uffs_result_to_dfs(uffs_get_error());
 	}
 
-	/* save this pointer, it will be used when calling read()��write(),
+	/* save this pointer, it will be used when calling read()��write(),
 	 * flush(), seek(), and will be free when calling close()*/
 
 	file->data = (void *)fd;
@@ -619,7 +619,6 @@ static int dfs_uffs_stat(struct dfs_filesystem* fs, const char *path, struct sta
 	st->st_mtime = s.st_mtime;
 
 	mtd = RT_MTD_NAND_DEVICE(fs->dev_id);
-	st->st_blksize = mtd->page_size;
 
 	return 0;
 }
diff --git a/components/dfs/include/dfs_def.h b/components/dfs/include/dfs_def.h
index a73ff4ec8b..0f75a5162b 100644
--- a/components/dfs/include/dfs_def.h
+++ b/components/dfs/include/dfs_def.h
@@ -255,14 +255,17 @@
 #define DFS_S_IWOTH              00002
 #define DFS_S_IXOTH              00001
 
+#ifdef _MSC_VER
+#include <wchar.h>
+#else
 struct stat
 {
     rt_device_t st_dev;
     rt_uint16_t st_mode;
     rt_uint32_t st_size;
     rt_time_t   st_mtime;
-    rt_uint32_t st_blksize;
 };
+#endif
 
 struct statfs
 {
diff --git a/components/dfs/src/dfs_file.c b/components/dfs/src/dfs_file.c
index aebe2996c6..752933b66f 100644
--- a/components/dfs/src/dfs_file.c
+++ b/components/dfs/src/dfs_file.c
@@ -392,7 +392,6 @@ int dfs_file_stat(const char *path, struct stat *buf)
 
         buf->st_size    = 0;
         buf->st_mtime   = 0;
-        buf->st_blksize = 512;
 
         /* release full path */
         rt_free(fullpath);
diff --git a/components/dfs/src/dfs_posix.c b/components/dfs/src/dfs_posix.c
index c379d5c969..52a9139d80 100644
--- a/components/dfs/src/dfs_posix.c
+++ b/components/dfs/src/dfs_posix.c
@@ -368,7 +368,6 @@ int fstat(int fildes, struct stat *buf)
 
     buf->st_size    = d->size;
     buf->st_mtime   = 0;
-    buf->st_blksize = 512;
 
     fd_put(d);
 
diff --git a/components/external/SQLite-3.8.1/src/os_rtthread.c b/components/external/SQLite-3.8.1/src/os_rtthread.c
index fb51b53685..6d57ed7098 100644
--- a/components/external/SQLite-3.8.1/src/os_rtthread.c
+++ b/components/external/SQLite-3.8.1/src/os_rtthread.c
@@ -1728,7 +1728,7 @@ static int fcntlSizeHint(rtthreadFile *pFile, i64 nByte){
       ** is the same technique used by glibc to implement posix_fallocate()
       ** on systems that do not have a real fallocate() system call.
       */
-      int nBlk = buf.st_blksize;  /* File-system block size */
+      int nBlk = 4096; // no blksize in RT-Thread, use 4096. /* File-system block size */
       i64 iWrite;                 /* Next offset to write to */
 
       if( robust_ftruncate(pFile->h, nSize) ){
diff --git a/components/finsh/SConscript b/components/finsh/SConscript
index 8d6729e4a7..639cbebd4a 100644
--- a/components/finsh/SConscript
+++ b/components/finsh/SConscript
@@ -22,8 +22,9 @@ finsh_token.c
 ''')
 
 msh_src = Split('''
-msh_cmd.c
 msh.c
+msh_cmd.c
+msh_file.c
 ''')
 
 CPPPATH = [cwd]
diff --git a/components/finsh/cmd.c b/components/finsh/cmd.c
index c42b412f23..29b22c05c2 100644
--- a/components/finsh/cmd.c
+++ b/components/finsh/cmd.c
@@ -99,17 +99,17 @@ static long _list_thread(struct rt_list_node *list)
         else if (thread->stat == RT_THREAD_INIT)    rt_kprintf(" init   ");
         else if (thread->stat == RT_THREAD_CLOSE)   rt_kprintf(" close  ");
 
-        ptr = (rt_uint8_t*)thread->stack_addr;
+        ptr = (rt_uint8_t *)thread->stack_addr;
         while (*ptr == '#')ptr ++;
 
         rt_kprintf(" 0x%08x 0x%08x 0x%08x 0x%08x %03d\n",
-            thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
-            thread->stack_size,
-            thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t)thread->stack_addr),
-            thread->remaining_tick,
-            thread->error);
+                   thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
+                   thread->stack_size,
+                   thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t)thread->stack_addr),
+                   thread->remaining_tick,
+                   thread->error);
     }
-	
+
     return 0;
 }
 
@@ -148,7 +148,7 @@ static long _list_sem(struct rt_list_node *list)
         sem = (struct rt_semaphore *)(rt_list_entry(node, struct rt_object, list));
         if (!rt_list_isempty(&sem->parent.suspend_thread))
         {
-            rt_kprintf("%-8.*s  %03d %d:", 
+            rt_kprintf("%-8.*s  %03d %d:",
                        RT_NAME_MAX,
                        sem->parent.parent.name,
                        sem->value,
@@ -448,7 +448,7 @@ static long _list_device(struct rt_list_node *list)
 {
     struct rt_device *device;
     struct rt_list_node *node;
-    char * const device_type_str[] =
+    char *const device_type_str[] =
     {
         "Character Device",
         "Block Device",
@@ -464,11 +464,11 @@ static long _list_device(struct rt_list_node *list)
         "SPI Bus",
         "SPI Device",
         "SDIO Bus",
-		"PM Pseudo Device",
+        "PM Pseudo Device",
         "Pipe",
         "Portal Device",
-		"Timer Device",
-		"Miscellaneous Device",
+        "Timer Device",
+        "Miscellaneous Device",
         "Unknown"
     };
 
@@ -507,13 +507,13 @@ int list_module(void)
 
     list = &rt_object_container[RT_Object_Class_Module].object_list;
 
-    rt_kprintf("module name     ref\n");
-    rt_kprintf("------------ --------\n");
+    rt_kprintf("module name     ref      address \n");
+    rt_kprintf("------------ -------- ------------\n");
     for (node = list->next; node != list; node = node->next)
     {
         module = (struct rt_module *)(rt_list_entry(node, struct rt_object, list));
-        rt_kprintf("%-16.*s %-04d\n",
-                   RT_NAME_MAX, module->parent.name, module->nref);
+        rt_kprintf("%-16.*s %-04d  0x%08x\n",
+                   RT_NAME_MAX, module->parent.name, module->nref, module->module_space);
     }
 
     return 0;
@@ -525,13 +525,13 @@ int list_mod_detail(const char *name)
 {
     int i;
     struct rt_module *module;
-    
+
     /* find module */
     if ((module = rt_module_find(name)) != RT_NULL)
     {
         /* module has entry point */
         if (!(module->parent.flag & RT_MODULE_FLAG_WITHOUTENTRY))
-        {   
+        {
             struct rt_thread *thread;
             struct rt_list_node *tlist;
             rt_uint8_t *ptr;
@@ -548,15 +548,15 @@ int list_mod_detail(const char *name)
                 else if (thread->stat == RT_THREAD_SUSPEND) rt_kprintf(" suspend");
                 else if (thread->stat == RT_THREAD_INIT)    rt_kprintf(" init   ");
 
-                ptr = (rt_uint8_t*)thread->stack_addr;
+                ptr = (rt_uint8_t *)thread->stack_addr;
                 while (*ptr == '#')ptr ++;
 
                 rt_kprintf(" 0x%08x 0x%08x 0x%08x 0x%08x %03d\n",
-                    thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
-                    thread->stack_size,
-                    thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t)thread->stack_addr),
-                    thread->remaining_tick,
-                    thread->error);
+                           thread->stack_size + ((rt_uint32_t)thread->stack_addr - (rt_uint32_t)thread->sp),
+                           thread->stack_size,
+                           thread->stack_size - ((rt_uint32_t) ptr - (rt_uint32_t)thread->stack_addr),
+                           thread->remaining_tick,
+                           thread->error);
             }
 
             /* list sub thread in module */
@@ -607,18 +607,18 @@ int list_mod_detail(const char *name)
             if (!rt_list_isempty(tlist)) _list_timer(tlist);
         }
 
-		if (module->nsym > 0)
-		{
-	        rt_kprintf("symbol    address   \n");
-	        rt_kprintf("-------- ----------\n");
-	    
-	        /* list module export symbols */
-	        for (i=0; i<module->nsym; i++)
-	        {
-	            rt_kprintf("%s 0x%x\n",
-	                       module->symtab[i].name, module->symtab[i].addr);
-	        }
-		}
+        if (module->nsym > 0)
+        {
+            rt_kprintf("symbol    address   \n");
+            rt_kprintf("-------- ----------\n");
+
+            /* list module export symbols */
+            for (i = 0; i < module->nsym; i++)
+            {
+                rt_kprintf("%s 0x%x\n",
+                           module->symtab[i].name, module->symtab[i].addr);
+            }
+        }
     }
 
     return 0;
@@ -632,16 +632,16 @@ long list(void)
     struct finsh_syscall_item *syscall_item;
     struct finsh_sysvar_item *sysvar_item;
 #endif
-	
+
     rt_kprintf("--Function List:\n");
     {
         struct finsh_syscall *index;
         for (index = _syscall_table_begin;
-             index < _syscall_table_end;
-             FINSH_NEXT_SYSCALL(index))
+                index < _syscall_table_end;
+                FINSH_NEXT_SYSCALL(index))
         {
-			/* skip the internal command */
-			if (strncmp((char*)index->name, "__", 2) == 0) continue;
+            /* skip the internal command */
+            if (strncmp((char *)index->name, "__", 2) == 0) continue;
 
 #ifdef FINSH_USING_DESCRIPTION
             rt_kprintf("%-16s -- %s\n", index->name, index->desc);
@@ -664,8 +664,8 @@ long list(void)
     {
         struct finsh_sysvar *index;
         for (index = _sysvar_table_begin;
-             index < _sysvar_table_end;
-             FINSH_NEXT_SYSVAR(index))
+                index < _sysvar_table_end;
+                FINSH_NEXT_SYSVAR(index))
         {
 #ifdef FINSH_USING_DESCRIPTION
             rt_kprintf("%-16s -- %s\n", index->name, index->desc);
@@ -682,7 +682,7 @@ long list(void)
         sysvar_item = sysvar_item->next;
     }
 #endif
-	
+
     return 0;
 }
 FINSH_FUNCTION_EXPORT(list, list all symbol in system)
@@ -732,12 +732,12 @@ void list_prefix(char *prefix)
     {
         struct finsh_syscall *index;
         for (index = _syscall_table_begin;
-             index < _syscall_table_end;
-             FINSH_NEXT_SYSCALL(index))
+                index < _syscall_table_end;
+                FINSH_NEXT_SYSCALL(index))
         {
-			/* skip internal command */
-			if (str_is_prefix("__", index->name) == 0) continue;
-			
+            /* skip internal command */
+            if (str_is_prefix("__", index->name) == 0) continue;
+
             if (str_is_prefix(prefix, index->name) == 0)
             {
                 if (func_cnt == 0)
@@ -807,10 +807,10 @@ void list_prefix(char *prefix)
 
     /* checks in system variable */
     {
-        struct finsh_sysvar* index;
+        struct finsh_sysvar *index;
         for (index = _sysvar_table_begin;
-             index < _sysvar_table_end;
-             FINSH_NEXT_SYSVAR(index))
+                index < _sysvar_table_end;
+                FINSH_NEXT_SYSVAR(index))
         {
             if (str_is_prefix(prefix, index->name) == 0)
             {
diff --git a/components/finsh/msh.c b/components/finsh/msh.c
index 6d747b40db..bd4b12d9d5 100644
--- a/components/finsh/msh.c
+++ b/components/finsh/msh.c
@@ -37,7 +37,7 @@
 #endif
 
 #define RT_FINSH_ARG_MAX    10
-typedef int (*cmd_function_t)(int argc, char** argv);
+typedef int (*cmd_function_t)(int argc, char **argv);
 
 #ifdef FINSH_USING_MSH
 #ifdef FINSH_USING_MSH_ONLY
@@ -56,7 +56,7 @@ rt_bool_t msh_is_used(void)
     return __msh_state;
 }
 
-static int msh_exit(int argc, char** argv)
+static int msh_exit(int argc, char **argv)
 {
     /* return to finsh shell mode */
     __msh_state = RT_FALSE;
@@ -74,15 +74,15 @@ static int msh_enter(void)
 FINSH_FUNCTION_EXPORT_ALIAS(msh_enter, msh, use module shell);
 #endif
 
-int msh_help(int argc, char** argv)
+int msh_help(int argc, char **argv)
 {
     rt_kprintf("RT-Thread shell commands:\n");
     {
         struct finsh_syscall *index;
 
         for (index = _syscall_table_begin;
-            index < _syscall_table_end;
-            FINSH_NEXT_SYSCALL(index))
+                index < _syscall_table_end;
+                FINSH_NEXT_SYSCALL(index))
         {
             if (strncmp(index->name, "__cmd_", 6) != 0) continue;
 #if defined(FINSH_USING_DESCRIPTION) && defined(FINSH_USING_SYMTAB)
@@ -98,7 +98,7 @@ int msh_help(int argc, char** argv)
 }
 FINSH_FUNCTION_EXPORT_ALIAS(msh_help, __cmd_help, RT-Thread shell help.);
 
-static int msh_split(char* cmd, rt_size_t length, char* argv[RT_FINSH_ARG_MAX])
+static int msh_split(char *cmd, rt_size_t length, char *argv[RT_FINSH_ARG_MAX])
 {
     char *ptr;
     rt_size_t position;
@@ -161,13 +161,13 @@ static cmd_function_t msh_get_cmd(char *cmd, int size)
     cmd_function_t cmd_func = RT_NULL;
 
     for (index = _syscall_table_begin;
-        index < _syscall_table_end;
-        FINSH_NEXT_SYSCALL(index))
+            index < _syscall_table_end;
+            FINSH_NEXT_SYSCALL(index))
     {
         if (strncmp(index->name, "__cmd_", 6) != 0) continue;
-        
+
         if (strncmp(&index->name[6], cmd, size) == 0 &&
-			index->name[6 + size] == '\0')
+                index->name[6 + size] == '\0')
         {
             cmd_func = (cmd_function_t)index->func;
             break;
@@ -180,7 +180,7 @@ static cmd_function_t msh_get_cmd(char *cmd, int size)
 #if defined(RT_USING_MODULE) && defined(RT_USING_DFS)
 /* Return 0 on module executed. Other value indicate error.
  */
-int msh_exec_module(const char* cmd_line, int size)
+int msh_exec_module(const char *cmd_line, int size)
 {
     int ret;
     int fd = -1;
@@ -197,7 +197,7 @@ int msh_exec_module(const char* cmd_line, int size)
     length = cmd_length + 32;
 
     /* allocate program name memory */
-    pg_name = (char*) rt_malloc(length);
+    pg_name = (char *) rt_malloc(length);
     if (pg_name == RT_NULL)
         return -RT_ENOMEM;
 
@@ -251,12 +251,21 @@ int msh_exec_module(const char* cmd_line, int size)
 
 int system(const char *command)
 {
-    return msh_exec_module(command, rt_strlen(command));
+    int ret = -RT_ENOMEM;
+    char *cmd = rt_strdup(command);
+
+    if (cmd)
+    {
+        ret = msh_exec(cmd, rt_strlen(cmd));
+        rt_free(cmd);
+    }
+
+    return ret;
 }
 RTM_EXPORT(system);
 #endif
 
-static int _msh_exec_cmd(char* cmd, rt_size_t length, int *retp)
+static int _msh_exec_cmd(char *cmd, rt_size_t length, int *retp)
 {
     int argc;
     int cmd0_size = 0;
@@ -287,12 +296,12 @@ static int _msh_exec_cmd(char* cmd, rt_size_t length, int *retp)
     return 0;
 }
 
-int msh_exec(char* cmd, rt_size_t length)
+int msh_exec(char *cmd, rt_size_t length)
 {
     int cmd_ret;
 
-	/* strim the beginning of command */
-    while(*cmd  == ' ' || *cmd == '\t')
+    /* strim the beginning of command */
+    while (*cmd  == ' ' || *cmd == '\t')
     {
         cmd++;
         length--;
@@ -318,7 +327,12 @@ int msh_exec(char* cmd, rt_size_t length)
 #endif
 
 #if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR)
-	/* change to this directory */
+    if (msh_exec_script(cmd, length) == 0)
+    {
+        return 0;
+    }
+
+    /* change to this directory */
     if (chdir(cmd) == 0)
     {
         return 0;
@@ -329,7 +343,7 @@ int msh_exec(char* cmd, rt_size_t length)
     {
         char *tcmd;
         tcmd = cmd;
-        while(*tcmd != ' ' && *tcmd != '\0')
+        while (*tcmd != ' ' && *tcmd != '\0')
         {
             tcmd++;
         }
@@ -355,14 +369,14 @@ static int str_common(const char *str1, const char *str2)
 #ifdef RT_USING_DFS
 void msh_auto_complete_path(char *path)
 {
-    DIR* dir = RT_NULL;
+    DIR *dir = RT_NULL;
     struct dirent *dirent = RT_NULL;
     char *full_path, *ptr, *index;
 
     if (!path)
         return;
 
-    full_path = (char*)rt_malloc(256);
+    full_path = (char *)rt_malloc(256);
     if (full_path == RT_NULL) return; /* out of memory */
 
     if (*path != '/')
@@ -434,9 +448,9 @@ void msh_auto_complete_path(char *path)
                     /* save dirent name */
                     strcpy(full_path, dirent->d_name);
                 }
-                
+
                 length = str_common(dirent->d_name, full_path);
-                
+
                 if (length < min_length)
                 {
                     min_length = length;
@@ -460,7 +474,7 @@ void msh_auto_complete_path(char *path)
                         rt_kprintf("%s\n", dirent->d_name);
                 }
             }
-            
+
             length = index - path;
             memcpy(index, full_path, min_length);
             path[length + min_length] = '\0';
@@ -481,7 +495,7 @@ void msh_auto_complete(char *prefix)
     min_length = 0;
     name_ptr = RT_NULL;
 
-    if (*prefix == '\0') 
+    if (*prefix == '\0')
     {
         msh_help(0, RT_NULL);
         return;
@@ -522,7 +536,7 @@ void msh_auto_complete(char *prefix)
             /* skip finsh shell function */
             if (strncmp(index->name, "__cmd_", 6) != 0) continue;
 
-            cmd_name = (const char*) &index->name[6];
+            cmd_name = (const char *) &index->name[6];
             if (strncmp(prefix, cmd_name, strlen(prefix)) == 0)
             {
                 if (min_length == 0)
diff --git a/components/finsh/msh.h b/components/finsh/msh.h
index 959170da3d..df49732956 100644
--- a/components/finsh/msh.h
+++ b/components/finsh/msh.h
@@ -33,7 +33,10 @@
 #include <rtthread.h>
 
 rt_bool_t msh_is_used(void);
-int msh_exec(char* cmd, rt_size_t length);
+int msh_exec(char *cmd, rt_size_t length);
 void msh_auto_complete(char *prefix);
 
+int msh_exec_module(const char *cmd_line, int size);
+int msh_exec_script(const char *cmd_line, int size);
+
 #endif
diff --git a/components/finsh/msh_cmd.c b/components/finsh/msh_cmd.c
index fc6b56cdd1..a4b865b028 100644
--- a/components/finsh/msh_cmd.c
+++ b/components/finsh/msh_cmd.c
@@ -41,7 +41,7 @@
 extern char working_directory[];
 #endif
 
-int cmd_ls(int argc, char** argv)
+int cmd_ls(int argc, char **argv)
 {
     extern void ls(const char *pathname);
 
@@ -53,7 +53,7 @@ int cmd_ls(int argc, char** argv)
         ls("/");
 #endif
     }
-    else 
+    else
     {
         ls(argv[1]);
     }
@@ -62,7 +62,7 @@ int cmd_ls(int argc, char** argv)
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_ls, __cmd_ls, List information about the FILEs.);
 
-int cmd_cp(int argc, char** argv)
+int cmd_cp(int argc, char **argv)
 {
     void copy(const char *src, const char *dst);
 
@@ -80,7 +80,7 @@ int cmd_cp(int argc, char** argv)
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_cp, __cmd_cp, Copy SOURCE to DEST.);
 
-int cmd_mv(int argc, char** argv)
+int cmd_mv(int argc, char **argv)
 {
     if (argc != 3)
     {
@@ -89,66 +89,66 @@ int cmd_mv(int argc, char** argv)
     }
     else
     {
-		int fd;
-		char *dest = RT_NULL;
+        int fd;
+        char *dest = RT_NULL;
 
         rt_kprintf("%s => %s\n", argv[1], argv[2]);
 
-		fd = open(argv[2], O_DIRECTORY, 0);
-		if (fd >= 0)
-		{
-			char *src;
-			
-			close(fd);
+        fd = open(argv[2], O_DIRECTORY, 0);
+        if (fd >= 0)
+        {
+            char *src;
+
+            close(fd);
 
-			/* it's a directory */			
-			dest = (char*)rt_malloc(DFS_PATH_MAX);
-			if (dest == RT_NULL)
-			{
-				rt_kprintf("out of memory\n");
-				return -RT_ENOMEM;
-			}
+            /* it's a directory */
+            dest = (char *)rt_malloc(DFS_PATH_MAX);
+            if (dest == RT_NULL)
+            {
+                rt_kprintf("out of memory\n");
+                return -RT_ENOMEM;
+            }
 
-			src = argv[1] + rt_strlen(argv[1]);
-			while (src != argv[1]) 
-			{
-				if (*src == '/') break;
-				src --;
-			}
+            src = argv[1] + rt_strlen(argv[1]);
+            while (src != argv[1])
+            {
+                if (*src == '/') break;
+                src --;
+            }
 
-			rt_snprintf(dest, DFS_PATH_MAX - 1, "%s/%s", argv[2], src);
-		}
-		else
-		{
-			fd = open(argv[2], O_RDONLY, 0);
-			if (fd >= 0)
-			{
-				close(fd);
-				
-				unlink(argv[2]);
-			}
+            rt_snprintf(dest, DFS_PATH_MAX - 1, "%s/%s", argv[2], src);
+        }
+        else
+        {
+            fd = open(argv[2], O_RDONLY, 0);
+            if (fd >= 0)
+            {
+                close(fd);
 
-			dest = argv[2];
-		}
+                unlink(argv[2]);
+            }
 
-		rename(argv[1], dest);
-		if (dest != RT_NULL && dest != argv[2]) rt_free(dest);
+            dest = argv[2];
+        }
+
+        rename(argv[1], dest);
+        if (dest != RT_NULL && dest != argv[2]) rt_free(dest);
     }
 
     return 0;
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_mv, __cmd_mv, Rename SOURCE to DEST.);
 
-int cmd_cat(int argc, char** argv)
+int cmd_cat(int argc, char **argv)
 {
     int index;
-    extern void cat(const char* filename);
+    extern void cat(const char *filename);
 
     if (argc == 1)
     {
         rt_kprintf("Usage: cat [FILE]...\n");
         rt_kprintf("Concatenate FILE(s)\n");
-		return 0;
+        return 0;
     }
 
     for (index = 1; index < argc; index ++)
@@ -160,7 +160,7 @@ int cmd_cat(int argc, char** argv)
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_cat, __cmd_cat, Concatenate FILE(s));
 
-int cmd_rm(int argc, char** argv)
+int cmd_rm(int argc, char **argv)
 {
     int index;
 
@@ -168,7 +168,7 @@ int cmd_rm(int argc, char** argv)
     {
         rt_kprintf("Usage: rm FILE...\n");
         rt_kprintf("Remove (unlink) the FILE(s).\n");
-		return 0;
+        return 0;
     }
 
     for (index = 1; index < argc; index ++)
@@ -178,10 +178,10 @@ int cmd_rm(int argc, char** argv)
 
     return 0;
 }
-FINSH_FUNCTION_EXPORT_ALIAS(cmd_rm, __cmd_rm, Remove (unlink) the FILE(s).);
+FINSH_FUNCTION_EXPORT_ALIAS(cmd_rm, __cmd_rm, Remove(unlink) the FILE(s).);
 
 #ifdef DFS_USING_WORKDIR
-int cmd_cd(int argc, char** argv)
+int cmd_cd(int argc, char **argv)
 {
     if (argc == 1)
     {
@@ -196,34 +196,34 @@ int cmd_cd(int argc, char** argv)
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_cd, __cmd_cd, Change the shell working directory.);
 
-int cmd_pwd(int argc, char** argv)
+int cmd_pwd(int argc, char **argv)
 {
-	rt_kprintf("%s\n", working_directory);
-	return 0;
+    rt_kprintf("%s\n", working_directory);
+    return 0;
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_pwd, __cmd_pwd, Print the name of the current working directory.);
 #endif
 
-int cmd_mkdir(int argc, char** argv)
+int cmd_mkdir(int argc, char **argv)
 {
-	if (argc == 1)
-	{
-		rt_kprintf("Usage: mkdir [OPTION] DIRECTORY\n");
-		rt_kprintf("Create the DIRECTORY, if they do not already exist.\n");
-	}
-	else
-	{
-		mkdir(argv[1], 0);
-	}
+    if (argc == 1)
+    {
+        rt_kprintf("Usage: mkdir [OPTION] DIRECTORY\n");
+        rt_kprintf("Create the DIRECTORY, if they do not already exist.\n");
+    }
+    else
+    {
+        mkdir(argv[1], 0);
+    }
 
-	return 0;
+    return 0;
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_mkdir, __cmd_mkdir, Create the DIRECTORY.);
 
-int cmd_mkfs(int argc, char** argv)
+int cmd_mkfs(int argc, char **argv)
 {
     int result = 0;
-    char* type="elm"; /* use the default file system type as 'fatfs' */
+    char *type = "elm"; /* use the default file system type as 'fatfs' */
 
     if (argc == 2)
     {
@@ -234,7 +234,7 @@ int cmd_mkfs(int argc, char** argv)
         if (strcmp(argv[1], "-t") == 0)
         {
             type = argv[2];
-            result = dfs_mkfs(type, argv[1]);
+            result = dfs_mkfs(type, argv[3]);
         }
     }
     else
@@ -242,7 +242,7 @@ int cmd_mkfs(int argc, char** argv)
         rt_kprintf("Usage: mkfs [-t type] device\n");
         return 0;
     }
-    
+
     if (result != RT_EOK)
     {
         rt_kprintf("mkfs failed, result=%d\n", result);
@@ -255,17 +255,17 @@ FINSH_FUNCTION_EXPORT_ALIAS(cmd_mkfs, __cmd_mkfs, format disk with file system);
 #endif
 
 #ifdef RT_USING_LWIP
-int cmd_ifconfig(int argc, char** argv)
+int cmd_ifconfig(int argc, char **argv)
 {
     extern void list_if(void);
-    extern void set_if(char* netif_name, char* ip_addr, char* gw_addr, char* nm_addr);
+    extern void set_if(char *netif_name, char *ip_addr, char *gw_addr, char *nm_addr);
 
 
-    if(argc == 1)
+    if (argc == 1)
     {
         list_if();
     }
-    else if(argc == 5)
+    else if (argc == 5)
     {
         rt_kprintf("config : %s\n", argv[1]);
         rt_kprintf("IP addr: %s\n", argv[2]);
@@ -283,22 +283,22 @@ int cmd_ifconfig(int argc, char** argv)
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_ifconfig, __cmd_ifconfig, list the information of network interfaces);
 
 #ifdef RT_LWIP_TCP
-int cmd_netstat(int argc, char** argv)
+int cmd_netstat(int argc, char **argv)
 {
- 	extern void list_tcps(void);
+    extern void list_tcps(void);
 
-	list_tcps();
-	return 0;
+    list_tcps();
+    return 0;
 }
-FINSH_FUNCTION_EXPORT_ALIAS(cmd_netstat, __cmd_netstat, list the information of TCP/IP);
+FINSH_FUNCTION_EXPORT_ALIAS(cmd_netstat, __cmd_netstat, list the information of TCP / IP);
 #endif
 #endif /* RT_USING_LWIP */
 
-int cmd_ps(int argc, char** argv)
+int cmd_ps(int argc, char **argv)
 {
     extern long list_thread(void);
     extern int list_module(void);
-    
+
 #ifdef RT_USING_MODULE
     if ((argc == 2) && (strcmp(argv[1], "-m") == 0))
         list_module();
@@ -309,14 +309,14 @@ int cmd_ps(int argc, char** argv)
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_ps, __cmd_ps, List threads in the system.);
 
-int cmd_time(int argc, char** argv)
+int cmd_time(int argc, char **argv)
 {
     return 0;
 }
 FINSH_FUNCTION_EXPORT_ALIAS(cmd_time, __cmd_time, Execute command with time.);
 
 #ifdef RT_USING_HEAP
-int cmd_free(int argc, char** argv)
+int cmd_free(int argc, char **argv)
 {
     extern void list_mem(void);
     extern void list_memheap(void);
diff --git a/components/finsh/msh_file.c b/components/finsh/msh_file.c
new file mode 100644
index 0000000000..80012e9bb8
--- /dev/null
+++ b/components/finsh/msh_file.c
@@ -0,0 +1,159 @@
+/*
+ *  script for RT-Thread module shell
+ *
+ * COPYRIGHT (C) 2013-2015, Shanghai Real-Thread Technology Co., Ltd
+ *
+ *  This file is part of RT-Thread (http://www.rt-thread.org)
+ *  Maintainer: bernard.xiong <bernard.xiong at gmail.com>
+ *
+ *  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2015-09-25     Bernard      the first verion for FinSH
+ */
+
+#include <rtthread.h>
+#include <finsh.h>
+
+#include "msh.h"
+
+#if defined(FINSH_USING_MSH) && defined(RT_USING_DFS)
+#include <dfs_posix.h>
+
+static int msh_readline(int fd, char *line_buf, int size)
+{
+    char ch;
+    int index = 0;
+
+    do
+    {
+        if (read(fd, &ch, 1) != 1)
+        {
+            /* nothing in this file */
+            return 0;
+        }
+    }
+    while (ch == '\n' || ch == '\r');
+
+    /* set the first character */
+    line_buf[index ++] = ch;
+
+    while (index < size)
+    {
+        if (read(fd, &ch, 1) == 1)
+        {
+            if (ch == '\n' || ch == '\r')
+            {
+                line_buf[index] = '\0';
+                break;
+            }
+
+            line_buf[index++] = ch;
+        }
+        else
+        {
+            line_buf[index] = '\0';
+            break;
+        }
+    }
+
+    return index;
+}
+
+int msh_exec_script(const char *cmd_line, int size)
+{
+    int ret;
+    int fd = -1;
+    char *pg_name;
+    int length, cmd_length = 0;
+
+    if (size == 0) return -RT_ERROR;
+
+    /* get the length of command0 */
+    while ((cmd_line[cmd_length] != ' ' && cmd_line[cmd_length] != '\t') && cmd_length < size)
+        cmd_length ++;
+
+    /* get name length */
+    length = cmd_length + 32;
+
+    /* allocate program name memory */
+    pg_name = (char *) rt_malloc(length);
+    if (pg_name == RT_NULL) return -RT_ENOMEM;
+
+    /* copy command0 */
+    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)
+    {
+        /* try to open program */
+        fd = open(pg_name, O_RDONLY, 0);
+
+        /* search in /bin path */
+        if (fd < 0)
+        {
+            rt_snprintf(pg_name, length - 1, "/bin/%.*s", cmd_length, cmd_line);
+            fd = open(pg_name, O_RDONLY, 0);
+        }
+    }
+
+    rt_free(pg_name);
+    if (fd >= 0)
+    {
+        /* found script */
+        char *line_buf;
+        int length;
+
+        line_buf = (char *) rt_malloc(RT_CONSOLEBUF_SIZE);
+
+        /* read line by line and then exec it */
+        do
+        {
+            length = msh_readline(fd, line_buf, RT_CONSOLEBUF_SIZE);
+            if (length > 0)
+            {
+                char ch = '\0';
+                int index;
+
+                for (index = 0; index < length; index ++)
+                {
+                    ch = line_buf[index];
+                    if (ch == ' ' || ch == '\t') continue;
+                    else break;
+                }
+
+                if (ch != '#') /* not a comment */
+                    msh_exec(line_buf, length);
+            }
+        }
+        while (length > 0);
+
+        close(fd);
+        rt_free(line_buf);
+
+        ret = 0;
+    }
+    else
+    {
+        ret = -1;
+    }
+
+    return ret;
+}
+
+#endif
diff --git a/components/finsh/shell.c b/components/finsh/shell.c
index ce80e4dec2..8962a7333f 100644
--- a/components/finsh/shell.c
+++ b/components/finsh/shell.c
@@ -425,7 +425,7 @@ void finsh_thread_entry(void *parameter)
 
                 if (rt_device_read(shell->device, 0, &next, 1) == 1)
                 {
-                    if (next == '\0') ch = 'r'; /* linux telnet will issue '\0' */
+                    if (next == '\0') ch = '\r'; /* linux telnet will issue '\0' */
                     else ch = next;
                 }
                 else ch = '\r';
diff --git a/components/libc/armlibc/libc_syms.c b/components/libc/armlibc/libc_syms.c
new file mode 100644
index 0000000000..847c48544a
--- /dev/null
+++ b/components/libc/armlibc/libc_syms.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+
+#include <rtm.h>
+
+/* some export routines for module */
+
+RTM_EXPORT(strstr);
+RTM_EXPORT(strlen);
+RTM_EXPORT(strchr);
+RTM_EXPORT(strcpy);
+RTM_EXPORT(strncpy);
+RTM_EXPORT(strcmp);
+RTM_EXPORT(strncmp);
+RTM_EXPORT(strcat);
+RTM_EXPORT(strtol);
+
+RTM_EXPORT(memcpy);
+RTM_EXPORT(memcmp);
+RTM_EXPORT(memmove);
+RTM_EXPORT(memset);
+RTM_EXPORT(memchr);
+
+RTM_EXPORT(toupper);
+RTM_EXPORT(atoi);
+
+RTM_EXPORT(localtime);
+RTM_EXPORT(time);
+
+/* import the full stdio for printf */
+#ifdef __MICROLIB
+#error "[RT_USING_LIBC] Please use standard libc but not microlib."
+#endif
+
+RTM_EXPORT(puts);
+RTM_EXPORT(printf);
diff --git a/components/libc/armlibc/mem_std.c b/components/libc/armlibc/mem_std.c
index 6faf86555f..56aa525df2 100644
--- a/components/libc/armlibc/mem_std.c
+++ b/components/libc/armlibc/mem_std.c
@@ -22,18 +22,22 @@ void *malloc(int n)
 {
     return rt_malloc(n);
 }
+RTM_EXPORT(malloc);
 
 void *realloc(void *rmem, rt_size_t newsize)
 {
     return rt_realloc(rmem, newsize);
 }
+RTM_EXPORT(realloc);
 
 void *calloc(rt_size_t nelem, rt_size_t elsize)
 {
 	return rt_calloc(nelem, elsize);
 }
+RTM_EXPORT(calloc);
 
 void free(void *rmem)
 {
     rt_free(rmem);
 }
+RTM_EXPORT(free);
diff --git a/components/libc/dlib/sys/types.h b/components/libc/dlib/sys/types.h
index b01d8283d4..3074bd69d0 100644
--- a/components/libc/dlib/sys/types.h
+++ b/components/libc/dlib/sys/types.h
@@ -9,4 +9,6 @@ typedef rt_int32_t key_t;       /* Used for interprocess communication. */
 typedef rt_int32_t pid_t;       /* Used for process IDs and process group IDs. */
 typedef signed long ssize_t;    /* Used for a count of bytes or an error indication. */
 
+typedef int mode_t;
+
 #endif
diff --git a/components/libc/newlib/libc_sym.c b/components/libc/newlib/libc_sym.c
new file mode 100644
index 0000000000..48e488f5d8
--- /dev/null
+++ b/components/libc/newlib/libc_sym.c
@@ -0,0 +1,47 @@
+#include <rtthread.h>
+#include <rtm.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+RTM_EXPORT(strcpy);
+RTM_EXPORT(strncpy);
+RTM_EXPORT(strlen);
+RTM_EXPORT(strcat);
+RTM_EXPORT(strstr);
+RTM_EXPORT(strchr);
+RTM_EXPORT(strcmp);
+RTM_EXPORT(strtol);
+RTM_EXPORT(strtoul);
+RTM_EXPORT(strncmp);
+
+RTM_EXPORT(memcpy);
+RTM_EXPORT(memcmp);
+RTM_EXPORT(memmove);
+RTM_EXPORT(memset);
+RTM_EXPORT(memchr);
+
+RTM_EXPORT(putchar);
+RTM_EXPORT(puts);
+RTM_EXPORT(printf);
+RTM_EXPORT(sprintf);
+RTM_EXPORT(snprintf);
+
+RTM_EXPORT(fwrite);
+
+#include <time.h>
+RTM_EXPORT(localtime);
+RTM_EXPORT(time);
+
+#include <setjmp.h>
+RTM_EXPORT(longjmp);
+RTM_EXPORT(setjmp);
+
+RTM_EXPORT(exit);
+RTM_EXPORT(abort);
+
+RTM_EXPORT(rand);
+
+#include <assert.h>
+RTM_EXPORT(__assert_func);
diff --git a/components/net/lwip-1.4.1/src/arch/sys_arch.c b/components/net/lwip-1.4.1/src/arch/sys_arch.c
index d3a69f9ac3..c0aed9d4f0 100644
--- a/components/net/lwip-1.4.1/src/arch/sys_arch.c
+++ b/components/net/lwip-1.4.1/src/arch/sys_arch.c
@@ -115,9 +115,10 @@ static void tcpip_init_done_callback(void *arg)
                 netif_set_up(ethif->netif);
             }
 
-#if LWIP_NETIF_LINK_CALLBACK
-            netif_set_link_up(ethif->netif);
-#endif
+            if (!(ethif->flags & ETHIF_LINK_PHYUP))
+            {
+                netif_set_link_up(ethif->netif);
+            }
 
             /* enter critical */
             rt_enter_critical();
diff --git a/components/net/lwip-1.4.1/src/include/netif/ethernetif.h b/components/net/lwip-1.4.1/src/include/netif/ethernetif.h
index 2019df7017..bdad32ec20 100644
--- a/components/net/lwip-1.4.1/src/include/netif/ethernetif.h
+++ b/components/net/lwip-1.4.1/src/include/netif/ethernetif.h
@@ -11,6 +11,10 @@
 #define ETHERNET_MTU		RT_LWIP_ETH_MTU
 #endif
 
+/* eth flag with auto_linkup or phy_linkup */
+#define ETHIF_LINK_AUTOUP	0x0000
+#define ETHIF_LINK_PHYUP	0x0100
+
 struct eth_device
 {
 	/* inherit from rt_device */
@@ -20,9 +24,9 @@ struct eth_device
 	struct netif *netif;
 	struct rt_semaphore tx_ack;
 
-	rt_uint8_t  flags;
+	rt_uint16_t flags;
 	rt_uint8_t  link_changed;
-	rt_uint16_t link_status;
+	rt_uint8_t  link_status;
 
 	/* eth device interface */
 	struct pbuf* (*eth_rx)(rt_device_t dev);
@@ -31,7 +35,7 @@ struct eth_device
 
 rt_err_t eth_device_ready(struct eth_device* dev);
 rt_err_t eth_device_init(struct eth_device * dev, char *name);
-rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint8_t flag);
+rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint16_t flag);
 rt_err_t eth_device_linkchange(struct eth_device* dev, rt_bool_t up);
 
 int eth_system_device_init(void);
diff --git a/components/net/lwip-1.4.1/src/netif/ethernetif.c b/components/net/lwip-1.4.1/src/netif/ethernetif.c
index 2e0ef2f8bd..f0b2f814dc 100644
--- a/components/net/lwip-1.4.1/src/netif/ethernetif.c
+++ b/components/net/lwip-1.4.1/src/netif/ethernetif.c
@@ -154,7 +154,7 @@ static err_t eth_netif_device_init(struct netif *netif)
         }
 
         /* copy device flags to netif flags */
-        netif->flags = ethif->flags;
+        netif->flags = (ethif->flags & 0xff);
 
         /* set default netif */
         if (netif_default == RT_NULL)
@@ -173,9 +173,11 @@ static err_t eth_netif_device_init(struct netif *netif)
             netif_set_up(ethif->netif);
         }
 
-#ifdef LWIP_NETIF_LINK_CALLBACK
-        netif_set_link_up(ethif->netif);
-#endif
+        if (!(ethif->flags & ETHIF_LINK_PHYUP))
+        {
+            /* set link_up for this netif */
+            netif_set_link_up(ethif->netif);
+        }
 
         return ERR_OK;
     }
@@ -184,7 +186,7 @@ static err_t eth_netif_device_init(struct netif *netif)
 }
 
 /* Keep old drivers compatible in RT-Thread */
-rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint8_t flags)
+rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint16_t flags)
 {
     struct netif* netif;
 
@@ -246,7 +248,7 @@ rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint8_
 
 rt_err_t eth_device_init(struct eth_device * dev, char *name)
 {
-    rt_uint8_t flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
+    rt_uint16_t flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
 
 #if LWIP_DHCP
     /* DHCP support */