Avoid stack munching stdio implementations.

 -Erik

1 files changed, 100 insertions, 75 deletions

diff --git a/modutils/modprobe.c b/modutils/modprobe.c
index 6a3e06df4..a72028fa2 100644
--- a/modutils/modprobe.c
+++ b/modutils/modprobe.c
@@ -9,13 +9,13 @@
  */
 
 #include <sys/utsname.h>
-#include <stdio.h>
 #include <getopt.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <syslog.h>
 #include <string.h>
 #include <ctype.h>
+#include <fcntl.h>
 #include "busybox.h"
 
 
@@ -46,11 +46,11 @@ static int autoclean, show_only, quiet, do_syslog, verbose;
 
 static struct dep_t *build_dep ( void )
 {
+        int fd, n;
         struct utsname un;
-        FILE *f;
         struct dep_t *first = 0;
         struct dep_t *current = 0;
-        char buffer [4096];
+        char buffer[256];
         char *filename = buffer;
         int continuation_line = 0;
         
@@ -58,21 +58,35 @@ static struct dep_t *build_dep ( void )
                 return 0;
                 
         // check for buffer overflow in following code
-        if ( xstrlen ( un. release ) > ( sizeof( buffer ) - 64 ))
+        if ( xstrlen ( un.release ) > ( sizeof( buffer ) - 64 )) {
                 return 0;
+        }
                                 
         strcpy ( filename, "/lib/modules/" );
-        strcat ( filename, un. release );
+        strcat ( filename, un.release );
         strcat ( filename, "/modules.dep" );
 
-        f = fopen ( filename, "r" );
-        if ( !f )
+        if ((fd = open ( filename, O_RDONLY )) < 0)
                 return 0;
-        
-        while ( fgets ( buffer, sizeof( buffer), f )) {
-                int l = xstrlen ( buffer );
+
+        while ( (n = read(fd, buffer, 255)) > 0) {
+                int l;
                 char *p = 0;
-                
+
+                /* Jump through hoops to simulate how fgets() grabs just one line at a
+                 * time... Don't use any stdio since modprobe gets called from a kernel
+                 * thread and stdio junk can overflow the limited stack... */
+                p = strchr ( buffer, '\n' );
+                if (p) {
+                        off_t offset;
+                        /* Get the current file descriptor offset */
+                        offset = lseek(fd, 0L, SEEK_CUR);
+                        /* Set the file descriptor offset to right after the \n */
+                        lseek(fd, offset-n+p-buffer+1, SEEK_SET);
+                        *(p+1)='\0';
+                }
+
+                l = xstrlen ( buffer );
                 while ( isspace ( buffer [l-1] )) {
                         buffer [l-1] = 0;
                         l--;
@@ -105,10 +119,10 @@ static struct dep_t *build_dep ( void )
                                 mod = xstrndup ( mods, col - mods - ext );
                                         
                                 if ( !current ) {
-                                        first = current = (struct dep_t *) malloc ( sizeof ( struct dep_t ));
+                                        first = current = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
                                 }
                                 else {
-                                        current-> m_next = (struct dep_t *) malloc ( sizeof ( struct dep_t ));
+                                        current-> m_next = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
                                         current = current-> m_next;
                                 }
                                 current-> m_module  = mod;
@@ -164,79 +178,90 @@ static struct dep_t *build_dep ( void )
                 else
                         continuation_line = 0;
         }
-        fclose ( f );
+        close ( fd );
 
         // alias parsing is not 100% correct (no correct handling of continuation lines within an alias) !
 
-        f = fopen ( "/etc/modules.conf", "r" );
-        if ( !f )
-                f = fopen ( "/etc/conf.modules", "r" );
-        if ( f ) {
-                continuation_line = 0;
+        if ((fd = open ( "/etc/modules.conf", O_RDONLY )) < 0)
+                if ((fd = open ( "/etc/conf.modules", O_RDONLY )) < 0)
+                        return first;
         
-                while ( fgets ( buffer, sizeof( buffer), f )) {
-                        int l;
-                        char *p;
-                        
-                        p = strchr ( buffer, '#' );
-                        if ( p )
-                                *p = 0;
-                                
-                        l = xstrlen ( buffer );
+        continuation_line = 0;
+        while ( read(fd, buffer, 255) > 0) {
+                int l;
+                char *p;
                 
-                        while ( l && isspace ( buffer [l-1] )) {
-                                buffer [l-1] = 0;
-                                l--;
-                        }
-                        
-                        if ( l == 0 ) {
-                                continuation_line = 0;
-                                continue;
-                        }
+                /* Jump through hoops to simulate how fgets() grabs just one line at a
+                 * time... Don't use any stdio since modprobe gets called from a kernel
+                 * thread and stdio junk can overflow the limited stack... */
+                p = strchr ( buffer, '\n' );
+                if (p) {
+                        off_t offset;
+                        /* Get the current file descriptor offset */
+                        offset = lseek(fd, 0L, SEEK_CUR);
+                        /* Set the file descriptor offset to right after the \n */
+                        lseek(fd, offset-n+p-buffer+1, SEEK_SET);
+                        *(p+1)='\0';
+                }
+
+                p = strchr ( buffer, '#' );
+                if ( p )
+                        *p = 0;
                         
-                        if ( !continuation_line ) {             
-                                if (( strncmp ( buffer, "alias", 5 ) == 0 ) && isspace ( buffer [5] )) {
-                                        char *alias, *mod;
+                l = xstrlen ( buffer );
+        
+                while ( l && isspace ( buffer [l-1] )) {
+                        buffer [l-1] = 0;
+                        l--;
+                }
+                
+                if ( l == 0 ) {
+                        continuation_line = 0;
+                        continue;
+                }
+                
+                if ( !continuation_line ) {             
+                        if (( strncmp ( buffer, "alias", 5 ) == 0 ) && isspace ( buffer [5] )) {
+                                char *alias, *mod;
 
-                                        alias = buffer + 6;
-                                        
-                                        while ( isspace ( *alias ))
-                                                alias++;                        
-                                        mod = alias;                                    
-                                        while ( !isspace ( *mod ))
-                                                mod++;
-                                        *mod = 0;
+                                alias = buffer + 6;
+                                
+                                while ( isspace ( *alias ))
+                                        alias++;                        
+                                mod = alias;                                    
+                                while ( !isspace ( *mod ))
+                                        mod++;
+                                *mod = 0;
+                                mod++;
+                                while ( isspace ( *mod ))
                                         mod++;
-                                        while ( isspace ( *mod ))
-                                                mod++;
-                                                                                        
+                                                                                
 //                                      fprintf ( stderr, "ALIAS: '%s' -> '%s'\n", alias, mod );
-                                        
-                                        if ( !current ) {
-                                                first = current = (struct dep_t *) malloc ( sizeof ( struct dep_t ));
-                                        }
-                                        else {
-                                                current-> m_next = (struct dep_t *) malloc ( sizeof ( struct dep_t ));
-                                                current = current-> m_next;
-                                        }
-                                        current-> m_module  = xstrdup ( alias );
-                                        current-> m_isalias = 1;
-                                        
-                                        if (( strcmp ( alias, "off" ) == 0 ) || ( strcmp ( alias, "null" ) == 0 )) {
-                                                current-> m_depcnt = 0;
-                                                current-> m_deparr = 0;
-                                        }
-                                        else {
-                                                current-> m_depcnt  = 1;
-                                                current-> m_deparr  = xmalloc ( 1 * sizeof( char * ));
-                                                current-> m_deparr[0] = xstrdup ( mod );
-                                        }
-                                        current-> m_next    = 0;                                        
-                                }                               
-                        }
+                                
+                                if ( !current ) {
+                                        first = current = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
+                                }
+                                else {
+                                        current-> m_next = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
+                                        current = current-> m_next;
+                                }
+                                current-> m_module  = xstrdup ( alias );
+                                current-> m_isalias = 1;
+                                
+                                if (( strcmp ( alias, "off" ) == 0 ) || ( strcmp ( alias, "null" ) == 0 )) {
+                                        current-> m_depcnt = 0;
+                                        current-> m_deparr = 0;
+                                }
+                                else {
+                                        current-> m_depcnt  = 1;
+                                        current-> m_deparr  = xmalloc ( 1 * sizeof( char * ));
+                                        current-> m_deparr[0] = xstrdup ( mod );
+                                }
+                                current-> m_next    = 0;                                        
+                        }                               
                 }
-                fclose ( f );
         }
+        close ( fd );
         
         return first;
 }