+ in the interest of robustness, I added

[oweals/busybox.git] / utility.c

diff --git a/utility.c b/utility.c
index b91da4ce46c157124ac80d47ffb3ea13f6232d12..42b8dc1e96f28222ec4d7de2ed77fac9ed17b58b 100644 (file)
--- a/utility.c
+++ b/utility.c
@@ -1259,17 +1259,15 @@ extern int device_open(char *device, int mode)
  *  This finds the pid of the specified process,
  *  by using the /dev/ps device driver.
  *
- *  [return]
- *  0      failure
- *  pid            when the pid is found.
+ *  Returns a list of all matching PIDs
  */
-extern pid_t findPidByName( char* pidName)
+extern pid_t* findPidByName( char* pidName)
 {
-       int fd, i;
+       int fd, i, j;
        char device[] = "/dev/ps";
-       pid_t thePid = 0;
        pid_t num_pids;
        pid_t* pid_array = NULL;
+       pid_t* pidList=NULL;
 
        /* open device */ 
        fd = open(device, O_RDONLY);
@@ -1300,10 +1298,13 @@ extern pid_t findPidByName( char* pidName)
                        fatalError( "\nDEVPS_GET_PID_INFO: %s\n", strerror (errno));
 
                if ((strstr(info.command_line, pidName) != NULL)) {
-                       thePid = info.pid;
-                       break;
+                       pidList=realloc( pidList, sizeof(pid_t) * (j+2));
+                       if (pidList==NULL)
+                               fatalError("out of memory\n");
+                       pidList[j++]=info.pid;
                }
        }
+       pidList[j]=0;
 
        /* Free memory */
        free( pid_array);
@@ -1312,7 +1313,7 @@ extern pid_t findPidByName( char* pidName)
        if (close (fd) != 0) 
                fatalError( "close failed for `%s': %s\n",device, strerror (errno));
 
-       return thePid;
+       return pidList;
 }
 #else          /* BB_FEATURE_USE_DEVPS_PATCH */
 #if ! defined BB_FEATURE_USE_PROCFS
@@ -1325,14 +1326,14 @@ extern pid_t findPidByName( char* pidName)
  *  Currently, it's implemented by rummaging through 
  *  the proc filesystem.
  *
- *  [return]
- *  0      failure
- *  pid            when the pid is found.
+ *  Returns a list of all matching PIDs
  */
-extern pid_t findPidByName( char* pidName)
+extern pid_t* findPidByName( char* pidName)
 {
        DIR *dir;
        struct dirent *next;
+       pid_t* pidList=NULL;
+       int i=0;
 
        dir = opendir("/proc");
        if (!dir)
@@ -1347,7 +1348,7 @@ extern pid_t findPidByName( char* pidName)
                if (!isdigit(*next->d_name))
                        continue;
 
-               /* Now open the command line file */
+               /* Now open the status file */
                sprintf(filename, "/proc/%s/status", next->d_name);
                status = fopen(filename, "r");
                if (!status) {
@@ -1357,10 +1358,14 @@ extern pid_t findPidByName( char* pidName)
                fclose(status);
 
                if ((strstr(buffer, pidName) != NULL)) {
-                       return strtol(next->d_name, NULL, 0);
+                       pidList=realloc( pidList, sizeof(pid_t) * (i+2));
+                       if (pidList==NULL)
+                               fatalError("out of memory\n");
+                       pidList[i++]=strtol(next->d_name, NULL, 0);
                }
        }
-       return 0;
+       pidList[i]=0;
+       return pidList;
 }
 #endif                                                 /* BB_FEATURE_USE_DEVPS_PATCH */
 #endif                                                 /* BB_KILLALL || ( BB_FEATURE_LINUXRC && ( BB_HALT || BB_REBOOT || BB_POWEROFF )) */
@@ -1371,7 +1376,7 @@ extern void *xmalloc(size_t size)
        void *cp = malloc(size);
 
        if (cp == NULL)
-               fatalError("out of memory");
+               fatalError("out of memory\n");
        return cp;
 }
 
@@ -1516,6 +1521,57 @@ extern int find_real_root_device_name(char* name)
 }
 #endif
 
+const unsigned int CSTRING_BUFFER_LENGTH = 128;
+/* recursive parser that returns cstrings of arbitrary length
+ * from a FILE* 
+ */
+static char *
+cstring_alloc(FILE* f, int depth)
+{
+    char *cstring;
+    char buffer[CSTRING_BUFFER_LENGTH];
+    int         target = CSTRING_BUFFER_LENGTH * depth;
+    int  i, len;
+    int  size;
+
+    /* fill buffer */
+    i = 0;
+    while ((buffer[i] = fgetc(f)) != EOF) {
+               if (buffer[i++] == 0x0a) { break; }
+               if (i == CSTRING_BUFFER_LENGTH) { break; }
+    }
+    len = i;
+
+    /* recurse or malloc? */
+    if (len == CSTRING_BUFFER_LENGTH) {
+               cstring = cstring_alloc(f, (depth + 1));
+    } else {
+               /* [special case] EOF */
+               if ((depth | len) == 0) { return NULL; }
+
+               /* malloc */
+               size = target + len + 1;
+               cstring = malloc(size);
+               if (!cstring) { return NULL; }
+               cstring[size - 1] = 0;
+    }
+
+    /* copy buffer */
+    if (cstring) {
+               memcpy(&cstring[target], buffer, len);
+    }
+    return cstring;
+}
+
+/* 
+ * wrapper around recursive cstring_alloc 
+ * it's the caller's responsibility to free the cstring
+ */ 
+char *
+cstring_lineFromFile(FILE *f)
+{
+    return cstring_alloc(f, 0);
+}
 
 /* END CODE */
 /*