X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=libsysfs%2Fsysfs_dir.c;h=7d98c669c65d575e06bf5f4105950626c93016b0;hb=33aa91b1befa3e4f8da57714ac09b7044cf54451;hp=a83c81f493bef500b55edbc4aee4aa18146d90d5;hpb=070f54223f66490e9d25719c495e074f77da8985;p=elogind.git

diff --git a/libsysfs/sysfs_dir.c b/libsysfs/sysfs_dir.c
index a83c81f49..7d98c669c 100644
--- a/libsysfs/sysfs_dir.c
+++ b/libsysfs/sysfs_dir.c
@@ -1,9 +1,9 @@
 /*
- * syfs_dir.c
+ * sysfs_dir.c
  *
  * Directory utility functions for libsysfs
  *
- * Copyright (C) 2003 International Business Machines, Inc.
+ * Copyright (C) IBM Corp. 2003-2005
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -23,14 +23,54 @@
 #include "libsysfs.h"
 #include "sysfs.h"
 
+static int sort_char(void *new, void *old)
+{
+	return ((strncmp((char *)new, (char *)old, 
+			strlen((char *)new))) < 0 ? 1 : 0);
+}
+
+/**
+ * sysfs_del_name: free function for sysfs_open_subsystem_list
+ * @name: memory area to be freed
+ */
+static void sysfs_del_name(void *name)
+{
+	free(name);
+}
+
+/**
+ * sysfs_del_attribute: routine for dlist integration
+ */
+static void sysfs_del_attribute(void *attr)
+{
+	sysfs_close_attribute((struct sysfs_attribute *)attr);
+}
+
+/**
+ * attr_name_equal: compares attributes by name
+ * @a: attribute name for comparison
+ * @b: sysfs_attribute to be compared.
+ * returns 1 if a==b->name or 0 if not equal
+ */
+static int attr_name_equal(void *a, void *b)
+{
+	if (!a || !b)
+		return 0;
+
+	if (strcmp(((char *)a), ((struct sysfs_attribute *)b)->name) == 0)
+		return 1;
+
+	return 0;
+}
+
 /**
  * sysfs_close_attribute: closes and cleans up attribute
  * @sysattr: attribute to close.
  */
 void sysfs_close_attribute(struct sysfs_attribute *sysattr)
 {
-	if (sysattr != NULL) {
-		if (sysattr->value != NULL)
+	if (sysattr) {
+		if (sysattr->value)
 			free(sysattr->value);
 		free(sysattr);
 	}
@@ -55,20 +95,28 @@ struct sysfs_attribute *sysfs_open_attribute(const char *path)
 {
 	struct sysfs_attribute *sysattr = NULL;
 	struct stat fileinfo;
-	
-	if (path == NULL) {
+
+	if (!path) {
 		errno = EINVAL;
 		return NULL;
 	}
 	sysattr = alloc_attribute();
-	if (sysattr == NULL) {
-		dprintf(stderr, "Error allocating attribute at %s\n", path);
+	if (!sysattr) {
+		dprintf("Error allocating attribute at %s\n", path);
 		return NULL;
 	}
-	strncpy(sysattr->path, path, sizeof(sysattr->path));
+	if (sysfs_get_name_from_path(path, sysattr->name, 
+				SYSFS_NAME_LEN) != 0) {
+		dprintf("Error retrieving attrib name from path: %s\n", path);
+		sysfs_close_attribute(sysattr);
+		return NULL;
+	}
+	safestrcpy(sysattr->path, path);
 	if ((stat(sysattr->path, &fileinfo)) != 0) {
-		perror("stat");
+		dprintf("Stat failed: No such attribute?\n");
 		sysattr->method = 0;
+		free(sysattr);
+		sysattr = NULL;
 	} else {
 		if (fileinfo.st_mode & S_IRUSR)
 			sysattr->method |= SYSFS_METHOD_SHOW;
@@ -88,43 +136,52 @@ int sysfs_read_attribute(struct sysfs_attribute *sysattr)
 {
 	char *fbuf = NULL;
 	char *vbuf = NULL;
-	size_t length = 0;
-	int pgsize = 0;
+	ssize_t length = 0;
+	long pgsize = 0;
 	int fd;
 
-	if (sysattr == NULL) {
+	if (!sysattr) {
 		errno = EINVAL;
 		return -1;
 	}
 	if (!(sysattr->method & SYSFS_METHOD_SHOW)) {
-		dprintf (stderr, "Show method not supported for attribute %s\n",
+		dprintf("Show method not supported for attribute %s\n",
 			sysattr->path);
+		errno = EACCES;
 		return -1;
 	}
 	pgsize = getpagesize();
 	fbuf = (char *)calloc(1, pgsize+1);
-	if (fbuf == NULL) {
-		perror("calloc");
+	if (!fbuf) {
+		dprintf("calloc failed\n");
 		return -1;
 	}
 	if ((fd = open(sysattr->path, O_RDONLY)) < 0) {
-		dprintf (stderr, "Error reading attribute %s\n", sysattr->path);
+		dprintf("Error reading attribute %s\n", sysattr->path);
 		free(fbuf);
 		return -1;
 	}
 	length = read(fd, fbuf, pgsize);
 	if (length < 0) {
-		dprintf (stderr, "Error reading from attribute %s\n",
-			sysattr->path);
+		dprintf("Error reading from attribute %s\n", sysattr->path);
 		close(fd);
 		free(fbuf);
 		return -1;
 	}
+	if (sysattr->len > 0) {
+		if ((sysattr->len == length) && 
+				(!(strncmp(sysattr->value, fbuf, length)))) {
+			close(fd);
+			free(fbuf);
+			return 0;
+		}
+		free(sysattr->value);
+	}
 	sysattr->len = length;
 	close(fd);
 	vbuf = (char *)realloc(fbuf, length+1);
-	if (vbuf == NULL) {
-		perror("realloc");
+	if (!vbuf) {
+		dprintf("realloc failed\n");
 		free(fbuf);
 		return -1;
 	}
@@ -134,363 +191,301 @@ int sysfs_read_attribute(struct sysfs_attribute *sysattr)
 }
 
 /**
- * sysfs_read_attribute_value: given path to attribute, return its value.
- *	values can be up to a pagesize, if buffer is smaller the value will 
- *	be truncated. 
- * @attrpath: sysfs path to attribute
- * @value: buffer to put value
- * @vsize: size of value buffer
+ * sysfs_write_attribute: write value to the attribute
+ * @sysattr: attribute to write
+ * @new_value: value to write
+ * @len: length of "new_value"
  * returns 0 with success and -1 with error.
  */
-int sysfs_read_attribute_value(const char *attrpath, char *value, size_t vsize)
+int sysfs_write_attribute(struct sysfs_attribute *sysattr,
+		const char *new_value, size_t len)
 {
-	struct sysfs_attribute *attr = NULL;
-	size_t length = 0;
+	int fd;
+	int length;
 
-	if (attrpath == NULL || value == NULL) {
+	if (!sysattr || !new_value || len == 0) {
 		errno = EINVAL;
 		return -1;
 	}
 
-	attr = sysfs_open_attribute(attrpath);
-	if (attr == NULL) {
-		dprintf(stderr, "Invalid attribute path %s\n", attrpath);
-		errno = EINVAL;
+	if (!(sysattr->method & SYSFS_METHOD_STORE)) {
+		dprintf ("Store method not supported for attribute %s\n",
+			sysattr->path);
+		errno = EACCES;
 		return -1;
 	}
-	if((sysfs_read_attribute(attr)) != 0 || attr->value == NULL) {
-		dprintf(stderr, "Error reading from attribute %s\n", attrpath);
-		sysfs_close_attribute(attr);
+	if (sysattr->method & SYSFS_METHOD_SHOW) {
+		/*
+		 * read attribute again to see if we can get an updated value 
+		 */
+		if ((sysfs_read_attribute(sysattr))) {
+			dprintf("Error reading attribute\n");
+			return -1;
+		}
+		if ((strncmp(sysattr->value, new_value, sysattr->len)) == 0) {
+			dprintf("Attr %s already has the requested value %s\n",
+					sysattr->name, new_value);
+			return 0;	
+		}
+	}
+	/*
+	 * open O_WRONLY since some attributes have no "read" but only
+	 * "write" permission 
+	 */
+	if ((fd = open(sysattr->path, O_WRONLY)) < 0) {
+		dprintf("Error reading attribute %s\n", sysattr->path);
 		return -1;
 	}
-	length = strlen(attr->value);
-	if (length > vsize) 
-		dprintf(stderr, 
-			"Value length %d is larger than supplied buffer %d\n",
-			length, vsize);
-	strncpy(value, attr->value, vsize);
-	sysfs_close_attribute(attr);
-
-	return 0;
-}
 
-/**
- * sysfs_get_value_from_attrbutes: given a linked list of attributes and an 
- * 	attribute name, return its value
- * @attr: attribute to search
- * @name: name to look for
- * returns char * value - could be NULL
- */
-char *sysfs_get_value_from_attributes(struct sysfs_attribute *attr, 
-					const char *name)
-{	
-	struct sysfs_attribute *cur = NULL;
-	char tmpname[SYSFS_NAME_LEN];
-	
-	if (attr == NULL || name == NULL) {
-		errno = EINVAL;
-		return NULL;
-	}	
-	cur = attr;
-	while (cur != NULL) {
-		memset(tmpname, 0, SYSFS_NAME_LEN);	
-		if ((sysfs_get_name_from_path(cur->path, tmpname,
-		    SYSFS_NAME_LEN)) != 0) {
-			cur = cur->next;
-			continue;
+	length = write(fd, new_value, len);
+	if (length < 0) {
+		dprintf("Error writing to the attribute %s - invalid value?\n",
+			sysattr->name);
+		close(fd);
+		return -1;
+	} else if ((unsigned int)length != len) {
+		dprintf("Could not write %zd bytes to attribute %s\n", 
+					len, sysattr->name);
+		/* 
+		 * since we could not write user supplied number of bytes,
+		 * restore the old value if one available
+		 */
+		if (sysattr->method & SYSFS_METHOD_SHOW) {
+			length = write(fd, sysattr->value, sysattr->len);
+			close(fd);
+			return -1;
 		}
-		if (strcmp(tmpname, name) == 0)
-			return cur->value;
-		cur = cur->next;
-	}
-	return NULL;
-}
-
-/**
- * add_subdir_to_dir: adds subdirectory to directory's subdirs
- * @sysdir: directory to add subdir to
- * @subdir: subdirectory to add.
- */
-static void add_subdir_to_dir(struct sysfs_directory *sysdir, 
-		     struct sysfs_directory *subdir)
-{
-	if (sysdir != NULL && subdir != NULL) {
-		subdir->next = sysdir->subdirs;
-		sysdir->subdirs = subdir;
 	}
-}
 
-/**
- * add_attr_to_dir: adds attribute to directory's attributes
- * @sysdir: directory to add attribute to
- * @sysattr: attribute to add.
- */
-static void add_attr_to_dir(struct sysfs_directory *sysdir, 
-		     			struct sysfs_attribute *sysattr)
-{
-	if (sysdir != NULL && sysattr != NULL) {
-		sysattr->next = sysdir->attributes;
-		sysdir->attributes = sysattr;
+	/*
+	 * Validate length that has been copied. Alloc appropriate area
+	 * in sysfs_attribute. Verify first if the attribute supports reading
+	 * (show method). If it does not, do not bother
+	 */ 
+	if (sysattr->method & SYSFS_METHOD_SHOW) {
+		if (length != sysattr->len) {
+			sysattr->value = (char *)realloc
+				(sysattr->value, length);
+			sysattr->len = length;
+			safestrcpymax(sysattr->value, new_value, length);
+		} else {
+			/*"length" of the new value is same as old one */ 
+			safestrcpymax(sysattr->value, new_value, length);
+		}
 	}
+			
+	close(fd);	
+	return 0;
 }
 
 /**
- * sysfs_close_dlink: closes and cleans up directory link.
- * @dlink: directory link to close.
+ * add_attribute: open and add attribute at path to given directory
+ * @dev: device whose attribute is to be added
+ * @path: path to attribute
+ * returns pointer to attr added with success and NULL with error.
  */
-void sysfs_close_dlink(struct sysfs_dlink *dlink)
+static struct sysfs_attribute *add_attribute(void *dev, const char *path)
 {
-	if (dlink != NULL) {
-		dlink->next = NULL;
-		if (dlink->target != NULL)
-			sysfs_close_directory(dlink->target);
-		free(dlink);
-	}
-}
+	struct sysfs_attribute *attr;
 
-/**
- * add_dlink_to_dir: adds directory link to directory's links list.
- * @sysdir: directory to add it to.
- * @dlink: link to add.
- */
-static void add_dlink_to_dir(struct sysfs_directory *sysdir, 
-					struct sysfs_dlink *dlink)
-{
-	if (sysdir != NULL && dlink != NULL) {
-		dlink->next = sysdir->links;
-		sysdir->links = dlink;
+	attr = sysfs_open_attribute(path);
+	if (!attr) {
+		dprintf("Error opening attribute %s\n",	path);
+		return NULL;
 	}
-}
-
-/**
- * sysfs_close_directory: closes directory, cleans up attributes and links
- * @sysdir: sysfs_directory to close
- */
-void sysfs_close_directory(struct sysfs_directory *sysdir)
-{
-	struct sysfs_directory *sdir = NULL, *dnext = NULL;
-	struct sysfs_dlink *dlink = NULL, *nextl = NULL;
-	struct sysfs_attribute *attr = NULL, *anext = NULL;
-
-	if (sysdir != NULL) {
-		if (sysdir->subdirs != NULL) {
-			for (sdir = sysdir->subdirs; sdir != NULL;
-			     sdir = dnext) {
-				dnext = sdir->next;
-				sysfs_close_directory(sdir);
-			}
-		}
-		if (sysdir->links != NULL) {
-			for (dlink = sysdir->links; dlink != NULL;
-			    dlink = nextl) {
-				nextl = dlink->next;
-				sysfs_close_dlink(dlink);
-			}
-		}
-		if (sysdir->attributes != NULL) {
-			for (attr = sysdir->attributes; attr != NULL;
-			     attr = anext) {
-				anext = attr->next;
-				/* sysfs_close_attribute(attr); */
-				if (attr->value != NULL)
-					free(attr->value);
-				free(attr);
-			}
+	if (attr->method & SYSFS_METHOD_SHOW) {
+		if (sysfs_read_attribute(attr)) {
+			dprintf("Error reading attribute %s\n",	path);
+			sysfs_close_attribute(attr);
+			return NULL;
 		}
-		free(sysdir);
 	}
-}
 
-/**
- * alloc_directory: allocates and initializes directory structure
- * returns struct sysfs_directory with success or NULL with error.
- */
-static struct sysfs_directory *alloc_directory(void)
-{
-	return (struct sysfs_directory *)
-			calloc(1, sizeof(struct sysfs_directory));
-}
+	if (!((struct sysfs_device *)dev)->attrlist) {
+		((struct sysfs_device *)dev)->attrlist = dlist_new_with_delete
+			(sizeof(struct sysfs_attribute), sysfs_del_attribute);
+	}
+	dlist_unshift_sorted(((struct sysfs_device *)dev)->attrlist, 
+			attr, sort_list);
 
-/**
- * alloc_dlink: allocates and initializes directory link structure
- * returns struct sysfs_dlink with success or NULL with error.
- */
-static struct sysfs_dlink *alloc_dlink(void)
-{
-	return (struct sysfs_dlink *)calloc(1, sizeof(struct sysfs_dlink));
+	return attr;
 }
 
-/**
- * sysfs_open_directory: opens a sysfs directory, creates dir struct, and
- *		returns.
- * @path: path of directory to open.
- * returns: struct sysfs_directory * with success and NULL on error.
+/*
+ * get_attribute - given a sysfs_* struct and a name, return the 
+ * sysfs_attribute corresponding to "name"
+ * returns sysfs_attribute on success and NULL on error
  */
-struct sysfs_directory *sysfs_open_directory(const char *path)
+struct sysfs_attribute *get_attribute(void *dev, const char *name)
 {
-	struct sysfs_directory *sdir = NULL;
+	struct sysfs_attribute *cur = NULL;
+	char path[SYSFS_PATH_MAX];
 
-	if (path == NULL) {
+	if (!dev || !name) {
 		errno = EINVAL;
 		return NULL;
 	}
-	sdir = alloc_directory();
-	if (sdir == NULL) {
-		dprintf(stderr, "Error allocating directory %s\n", path);
-		return NULL;
-	}
-	strncpy(sdir->path, path, sizeof(sdir->path));
 
-	return sdir;
+	if (((struct sysfs_device *)dev)->attrlist) {
+		/* check if attr is already in the list */
+		cur = (struct sysfs_attribute *)dlist_find_custom
+			((((struct sysfs_device *)dev)->attrlist), 
+			 	(void *)name, attr_name_equal);
+		if (cur)
+			return cur;
+	}
+	safestrcpymax(path, ((struct sysfs_device *)dev)->path, 
+			SYSFS_PATH_MAX);
+	safestrcatmax(path, "/", SYSFS_PATH_MAX);
+	safestrcatmax(path, name, SYSFS_PATH_MAX);
+	if (!sysfs_path_is_file(path))
+		cur = add_attribute((void *)dev, path);
+	return cur;
 }
 
 /**
- * sysfs_open_dlink: opens a sysfs directory link, creates struct, and returns
- * @path: path of link to open.
- * returns: struct sysfs_dlink * with success and NULL on error.
+ * read_dir_links: grabs links in a specific directory
+ * @sysdir: sysfs directory to read
+ * returns list of link names with success and NULL with error.
  */
-struct sysfs_dlink *sysfs_open_dlink(const char *linkpath)
+struct dlist *read_dir_links(const char *path)
 {
-	struct sysfs_dlink *dlink = NULL;
-	struct sysfs_directory *tdir = NULL;
-	char name[SYSFS_NAME_LEN];
-	char target[SYSFS_PATH_MAX];
+	DIR *dir = NULL;
+	struct dirent *dirent = NULL;
+	char file_path[SYSFS_PATH_MAX], *linkname;
+	struct dlist *linklist = NULL;
 
-	if (linkpath == NULL) {
+	if (!path) {
 		errno = EINVAL;
 		return NULL;
 	}
-
-	memset(name, 0, SYSFS_NAME_LEN);
-	memset(target, 0, SYSFS_PATH_MAX);
-	if ((sysfs_get_name_from_path(linkpath, name, SYSFS_NAME_LEN)) != 0
-	    || (sysfs_get_link(linkpath, target, SYSFS_PATH_MAX)) != 0) {
-		errno = EINVAL;
-		dprintf(stderr, "Invalid link path %s\n", linkpath);
+	dir = opendir(path);
+	if (!dir) {
+		dprintf("Error opening directory %s\n", path);
 		return NULL;
 	}
-	dlink = alloc_dlink();
-	if (dlink == NULL) {
-		dprintf(stderr, 
-			"Error allocating directory link %s\n", linkpath);
-		return NULL;
+	while ((dirent = readdir(dir)) != NULL) {
+		if (0 == strcmp(dirent->d_name, "."))
+			 continue;
+		if (0 == strcmp(dirent->d_name, ".."))
+			continue;
+		memset(file_path, 0, SYSFS_PATH_MAX);
+		safestrcpy(file_path, path);
+		safestrcat(file_path, "/");
+		safestrcat(file_path, dirent->d_name);
+		if (!sysfs_path_is_link(file_path)) {
+			if (!linklist) {
+				linklist = dlist_new_with_delete
+					(SYSFS_NAME_LEN, sysfs_del_name);
+				if (!linklist) {
+					dprintf("Error creating list\n");
+					return NULL;
+				}
+			}
+			linkname = (char *)calloc(1, SYSFS_NAME_LEN);
+			safestrcpymax(linkname, dirent->d_name, SYSFS_NAME_LEN);
+			dlist_unshift_sorted(linklist, linkname, sort_char);
+		}
 	}
-	strcpy(dlink->name, name);
-	tdir = sysfs_open_directory(target);
-	if (tdir == NULL) {
-		dprintf(stderr, "Invalid directory link target %s\n", target);
-		sysfs_close_dlink(dlink);
-		return NULL;
-	}	
-	dlink->target = tdir;
-
-	return dlink;
+	closedir(dir);
+	return linklist;
 }
 
 /**
- * sysfs_read_directory: grabs attributes, links, and subdirectories
- * @sysdir: sysfs directory to open
- * returns 0 with success and -1 with error.
+ * read_dir_subdirs: grabs subdirs in a specific directory
+ * @sysdir: sysfs directory to read
+ * returns list of directory names with success and NULL with error.
  */
-int sysfs_read_directory(struct sysfs_directory *sysdir)
+struct dlist *read_dir_subdirs(const char *path)
 {
 	DIR *dir = NULL;
 	struct dirent *dirent = NULL;
-	struct stat astats;
-	struct sysfs_attribute *attr = NULL;
-	struct sysfs_directory *subdir = NULL;
-	struct sysfs_dlink *dlink = NULL;
-	char file_path[SYSFS_PATH_MAX];
-	int retval = 0;
+	char file_path[SYSFS_PATH_MAX], *dir_name;
+	struct dlist *dirlist = NULL;
 
-	if (sysdir == NULL) {
+	if (!path) {
 		errno = EINVAL;
-		return -1;
+		return NULL;
 	}
-	dir = opendir(sysdir->path);
-	if (dir == NULL) {
-		perror("opendir");
-		return -1;
+	dir = opendir(path);
+	if (!dir) {
+		dprintf("Error opening directory %s\n", path);
+		return NULL;
 	}
-	while(((dirent = readdir(dir)) != NULL) && retval == 0) {
+	while ((dirent = readdir(dir)) != NULL) {
 		if (0 == strcmp(dirent->d_name, "."))
 			 continue;
 		if (0 == strcmp(dirent->d_name, ".."))
 			continue;
 		memset(file_path, 0, SYSFS_PATH_MAX);
-		strncpy(file_path, sysdir->path, sizeof(file_path));
-		strncat(file_path, "/", sizeof(file_path));
-		strncat(file_path, dirent->d_name, sizeof(file_path));
-		if ((lstat(file_path, &astats)) != 0) {
-			perror("stat");
-			continue;
-		}
-		if (S_ISREG(astats.st_mode)) {	
-			attr = sysfs_open_attribute(file_path);
-			if (attr == NULL) {
-				dprintf (stderr, "Error opening attribute %s\n",
-					file_path);
-				retval = -1;
-				break;
-			}
-			if (attr->method & SYSFS_METHOD_SHOW) {
-				if ((sysfs_read_attribute(attr)) != 0) {
-					dprintf (stderr, 
-						"Error reading attribute %s\n",
-						file_path);
-					sysfs_close_attribute(attr);
-					continue;
+		safestrcpy(file_path, path);
+		safestrcat(file_path, "/");
+		safestrcat(file_path, dirent->d_name);
+		if (!sysfs_path_is_dir(file_path)) {
+			if (!dirlist) {
+				dirlist = dlist_new_with_delete
+					(SYSFS_NAME_LEN, sysfs_del_name);
+				if (!dirlist) {
+					dprintf("Error creating list\n");
+					return NULL;
 				}
 			}
-			add_attr_to_dir(sysdir, attr);
-		} else if (S_ISDIR(astats.st_mode)) {
-			subdir = sysfs_open_directory(file_path);
-			if (subdir == NULL) {
-				dprintf (stderr, "Error opening directory %s\n",
-					file_path);
-				retval = -1;
-				break;
-			}
-			add_subdir_to_dir(sysdir, subdir);
-		} else if (S_ISLNK(astats.st_mode)) {
-			dlink = sysfs_open_dlink(file_path);
-			if (dlink == NULL) {
-				dprintf(stderr, "Error opening link %s\n",
-					file_path);
-				retval = -1;
-				break;
-			}
-			add_dlink_to_dir(sysdir, dlink);
+			dir_name = (char *)calloc(1, SYSFS_NAME_LEN);
+			safestrcpymax(dir_name, dirent->d_name, SYSFS_NAME_LEN);
+			dlist_unshift_sorted(dirlist, dir_name, sort_char);
 		}
 	}
 	closedir(dir);
-	return(retval);
+	return dirlist;
 }
 
 /**
- * sysfs_read_dlinks: reads a directory link's target directory. Can
- * 	supply a linked list of links.
- * @dlink: directory link to read.
- * returns 0 with success or -1 with error.
+ * get_attributes_list: build a list of attributes for the given device
+ * @dev: devices whose attributes list is required
+ * returns dlist of attributes on success and NULL on failure
  */
-int sysfs_read_dlinks(struct sysfs_dlink *dlink)
+struct dlist *get_attributes_list(void *dev)
 {
-	struct sysfs_dlink *cur = NULL;
+	DIR *dir = NULL;
+	struct dirent *dirent = NULL;
+	struct sysfs_attribute *attr = NULL;
+	char file_path[SYSFS_PATH_MAX], path[SYSFS_PATH_MAX];
 
-	if (dlink == NULL || dlink->target == NULL) {
+	if (!dev) {
 		errno = EINVAL;
-		return -1;
+		return NULL;
 	}
-	cur = dlink;
-	while (cur != NULL) {
-		if ((sysfs_read_directory(cur->target)) != 0) {
-			dprintf(stderr, 
-				"Error reading directory link target %s\n",
-				dlink->name);
-			return -1;
+	memset(path, 0, SYSFS_PATH_MAX);
+	safestrcpy(path, ((struct sysfs_device *)dev)->path);
+	dir = opendir(path);
+	if (!dir) {
+		dprintf("Error opening directory %s\n", path);
+		return NULL;
+	}
+	while ((dirent = readdir(dir)) != NULL) {
+		if (0 == strcmp(dirent->d_name, "."))
+			 continue;
+		if (0 == strcmp(dirent->d_name, ".."))
+			continue;
+		memset(file_path, 0, SYSFS_PATH_MAX);
+		safestrcpy(file_path, path);
+		safestrcat(file_path, "/");
+		safestrcat(file_path, dirent->d_name);
+		if (!sysfs_path_is_file(file_path)) {
+			if (((struct sysfs_device *)dev)->attrlist) {
+				/* check if attr is already in the list */
+				attr = (struct sysfs_attribute *)
+				dlist_find_custom
+				((((struct sysfs_device *)dev)->attrlist), 
+			 	(void *)dirent->d_name, attr_name_equal);
+				if (attr) 
+					continue;
+				else 
+					add_attribute(dev, file_path);
+			} else 
+				attr = add_attribute(dev, file_path);
 		}
-		cur = cur->next;
 	}
-	
-	return 0;
+	closedir(dir);
+	return ((struct sysfs_device *)dev)->attrlist;
 }