chiark / gitweb /
98529cb8407e7ffa2739b23341872618ec0191bd
[elogind.git] / namedev.c
1 /*
2  * namedev.c
3  *
4  * Userspace devfs
5  *
6  * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
7  *
8  *
9  *      This program is free software; you can redistribute it and/or modify it
10  *      under the terms of the GNU General Public License as published by the
11  *      Free Software Foundation version 2 of the License.
12  * 
13  *      This program is distributed in the hope that it will be useful, but
14  *      WITHOUT ANY WARRANTY; without even the implied warranty of
15  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *      General Public License for more details.
17  * 
18  *      You should have received a copy of the GNU General Public License along
19  *      with this program; if not, write to the Free Software Foundation, Inc.,
20  *      675 Mass Ave, Cambridge, MA 02139, USA.
21  *
22  */
23
24 #include <stddef.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdio.h>
28 #include <fcntl.h>
29 #include <ctype.h>
30 #include <unistd.h>
31 #include <errno.h>
32 #include <time.h>
33 #include <sys/wait.h>
34 #include <sys/stat.h>
35
36 #include "libsysfs/sysfs/libsysfs.h"
37 #include "list.h"
38 #include "udev.h"
39 #include "udev_lib.h"
40 #include "udev_version.h"
41 #include "logging.h"
42 #include "namedev.h"
43 #include "klibc_fixups.h"
44
45 static struct sysfs_attribute *find_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, char *attr);
46
47 LIST_HEAD(config_device_list);
48 LIST_HEAD(perm_device_list);
49
50
51 /* compare string with pattern (supports * ? [0-9] [!A-Z]) */
52 static int strcmp_pattern(const char *p, const char *s)
53 {
54         if (s[0] == '\0') {
55                 while (p[0] == '*')
56                         p++;
57                 return (p[0] != '\0');
58         }
59         switch (p[0]) {
60         case '[':
61                 {
62                         int not = 0;
63                         p++;
64                         if (p[0] == '!') {
65                                 not = 1;
66                                 p++;
67                         }
68                         while ((p[0] != '\0') && (p[0] != ']')) {
69                                 int match = 0;
70                                 if (p[1] == '-') {
71                                         if ((s[0] >= p[0]) && (s[0] <= p[2]))
72                                                 match = 1;
73                                         p += 3;
74                                 } else {
75                                         match = (p[0] == s[0]);
76                                         p++;
77                                 }
78                                 if (match ^ not) {
79                                         while ((p[0] != '\0') && (p[0] != ']'))
80                                                 p++;
81                                         if (p[0] == ']')
82                                                 return strcmp_pattern(p+1, s+1);
83                                 }
84                         }
85                 }
86                 break;
87         case '*':
88                 if (strcmp_pattern(p, s+1))
89                         return strcmp_pattern(p+1, s);
90                 return 0;
91         case '\0':
92                 if (s[0] == '\0') {
93                         return 0;
94                 }
95                 break;
96         default:
97                 if ((p[0] == s[0]) || (p[0] == '?'))
98                         return strcmp_pattern(p+1, s+1);
99                 break;
100         }
101         return 1;
102 }
103
104 static struct perm_device *find_perm(char *name)
105 {
106         struct perm_device *perm;
107
108         list_for_each_entry(perm, &perm_device_list, node) {
109                 if (strcmp_pattern(perm->name, name))
110                         continue;
111                 return perm;
112         }
113         return NULL;
114 }
115
116 static mode_t get_default_mode(void)
117 {
118         mode_t mode = 0600;     /* default to owner rw only */
119
120         if (strlen(default_mode_str) != 0)
121                 mode = strtol(default_mode_str, NULL, 8);
122
123         return mode;
124 }
125
126 static char *get_default_owner(void)
127 {
128         if (strlen(default_owner_str) == 0)
129                 strfieldcpy(default_owner_str, "root");
130
131         return default_owner_str;
132 }
133
134 static char *get_default_group(void)
135 {
136         if (strlen(default_group_str) == 0)
137                 strfieldcpy(default_group_str, "root");
138
139         return default_group_str;
140 }
141
142 /* extract possible {attr} and move str behind it */
143 static char *get_format_attribute(char **str)
144 {
145         char *pos;
146         char *attr = NULL;
147
148         if (*str[0] == '{') {
149                 pos = strchr(*str, '}');
150                 if (pos == NULL) {
151                         dbg("missing closing brace for format");
152                         return NULL;
153                 }
154                 pos[0] = '\0';
155                 attr = *str+1;
156                 *str = pos+1;
157                 dbg("attribute='%s', str='%s'", attr, *str);
158         }
159         return attr;
160 }
161
162 /* extract possible format length and move str behind it*/
163 static int get_format_len(char **str)
164 {
165         int num;
166         char *tail;
167
168         if (isdigit(*str[0])) {
169                 num = (int) strtoul(*str, &tail, 10);
170                 if (num > 0) {
171                         *str = tail;
172                         dbg("format length=%i", num);
173                         return num;
174                 } else {
175                         dbg("format parsing error '%s'", *str);
176                 }
177         }
178         return -1;
179 }
180
181 static void apply_format(struct udevice *udev, char *string, size_t maxsize,
182                          struct sysfs_class_device *class_dev,
183                          struct sysfs_device *sysfs_device)
184 {
185         char temp[NAME_SIZE];
186         char temp2[NAME_SIZE];
187         char *tail;
188         char *pos;
189         char *attr;
190         int len;
191         int i;
192         char c;
193         char *spos;
194         char *rest;
195         int slen;
196         struct sysfs_attribute *tmpattr;
197
198         pos = string;
199
200         while (1) {
201                 pos = strchr(string, '%');
202                 if (pos != NULL) {
203                         pos[0] = '\0';
204                         tail = pos+1;
205                         len = get_format_len(&tail);
206                         c = tail[0];
207                         strfieldcpy(temp, tail+1);
208                         tail = temp;
209                 } else {
210                         break;
211                 }
212                 dbg("format=%c, string='%s', tail='%s'",c , string, tail);
213
214                 attr = get_format_attribute(&tail);
215
216                 switch (c) {
217                 case 'b':
218                         if (strlen(udev->bus_id) == 0)
219                                 break;
220                         strfieldcatmax(string, udev->bus_id, maxsize);
221                         dbg("substitute bus_id '%s'", udev->bus_id);
222                         break;
223                 case 'k':
224                         if (strlen(udev->kernel_name) == 0)
225                                 break;
226                         strfieldcatmax(string, udev->kernel_name, maxsize);
227                         dbg("substitute kernel name '%s'", udev->kernel_name);
228                         break;
229                 case 'n':
230                         if (strlen(udev->kernel_number) == 0)
231                                 break;
232                         strfieldcatmax(string, udev->kernel_number, maxsize);
233                         dbg("substitute kernel number '%s'", udev->kernel_number);
234                                 break;
235                 case 'm':
236                         strintcatmax(string, udev->minor, maxsize);
237                         dbg("substitute minor number '%u'", udev->minor);
238                         break;
239                 case 'M':
240                         strintcatmax(string, udev->major, maxsize);
241                         dbg("substitute major number '%u'", udev->major);
242                         break;
243                 case 'c':
244                         if (strlen(udev->program_result) == 0)
245                                 break;
246                         /* get part part of the result string */
247                         i = 0;
248                         if (attr != NULL)
249                                 i = strtoul(attr, &rest, 10);
250                         if (i > 0) {
251                                 foreach_strpart(udev->program_result, " \n\r", spos, slen) {
252                                         i--;
253                                         if (i == 0)
254                                                 break;
255                                 }
256                                 if (i > 0) {
257                                         dbg("requested part of result string not found");
258                                         break;
259                                 }
260                                 if (rest[0] == '+')
261                                         strfieldcpy(temp2, spos);
262                                 else
263                                         strfieldcpymax(temp2, spos, slen+1);
264                                 strfieldcatmax(string, temp2, maxsize);
265                                 dbg("substitute part of result string '%s'", temp2);
266                         } else {
267                                 strfieldcatmax(string, udev->program_result, maxsize);
268                                 dbg("substitute result string '%s'", udev->program_result);
269                         }
270                         break;
271                 case 's':
272                         if (attr != NULL) {
273                                 tmpattr = find_sysfs_attribute(class_dev, sysfs_device, attr);
274                                 if (tmpattr == NULL) {
275                                         dbg("sysfa attribute '%s' not found", attr);
276                                         break;
277                                 }
278                                 strfieldcatmax(string, tmpattr->value, maxsize);
279                                 dbg("substitute sysfs value '%s'", tmpattr->value);
280                         } else {
281                                 dbg("missing attribute");
282                         }
283                         break;
284                 case '%':
285                         strfieldcatmax(string, "%", maxsize);
286                         break;
287                 default:
288                         dbg("unknown substitution type '%%%c'", c);
289                         break;
290                 }
291                 /* truncate to specified length */
292                 if (len > 0)
293                         pos[len] = '\0';
294
295                 strfieldcatmax(string, tail, maxsize);
296         }
297 }
298
299 /* 
300  * Note, we can have multiple files for different busses in here due
301  * to the mess that USB has for its device tree...
302  */
303 static struct bus_file {
304         char *bus;
305         char *file;
306 } bus_files[] = {
307         { .bus = "scsi",        .file = "vendor" },
308         { .bus = "usb",         .file = "idVendor" },
309         { .bus = "usb",         .file = "iInterface" },
310         { .bus = "usb-serial",  .file = "detach_state" },
311         { .bus = "ide",         .file = "detach_state" },
312         { .bus = "pci",         .file = "vendor" },
313         {}
314 };
315
316 #define SECONDS_TO_WAIT_FOR_FILE        10
317 static void wait_for_device_to_initialize(struct sysfs_device *sysfs_device)
318 {
319         /* sleep until we see the file for this specific bus type show up this
320          * is needed because we can easily out-run the kernel in looking for
321          * these files before the paticular subsystem has created them in the
322          * sysfs tree properly.
323          *
324          * And people thought that the /sbin/hotplug event system was going to
325          * be slow, poo on you for arguing that before even testing it...
326          */
327         struct bus_file *b = &bus_files[0];
328         struct sysfs_attribute *tmpattr;
329         int found = 0;
330         int loop = SECONDS_TO_WAIT_FOR_FILE;
331
332         while (1) {
333                 if (b->bus == NULL) {
334                         if (!found)
335                                 break;
336                         /* sleep to give the kernel a chance to create the file */
337                         sleep(1);
338                         --loop;
339                         if (loop == 0)
340                                 break;
341                         b = &bus_files[0];
342                 }
343                 if (strcmp(sysfs_device->bus, b->bus) == 0) {
344                         found = 1;
345                         dbg("looking for file '%s' on bus '%s'", b->file, b->bus);
346                         tmpattr = sysfs_get_device_attr(sysfs_device, b->file);
347                         if (tmpattr) {
348                                 /* found it! */
349                                 goto exit;
350                         }
351                         dbg("can't find '%s' file", b->file);
352                 }
353                 ++b;
354         }
355         if (!found)
356                 dbg("did not find bus type '%s' on list of bus_id_files, "
357                     "contact greg@kroah.com", sysfs_device->bus);
358 exit:
359         return; /* here to prevent compiler warning... */
360 }
361
362 static void fix_kernel_name(struct udevice *udev)
363 {
364         char *temp = udev->kernel_name;
365
366         while (*temp != 0x00) {
367                 /* Some block devices have a ! in their name, 
368                  * we need to change that to / */
369                 if (*temp == '!')
370                         *temp = '/';
371                 ++temp;
372         }
373 }
374
375 static int execute_program(char *path, char *value, int len)
376 {
377         int retval;
378         int count;
379         int status;
380         int fds[2];
381         pid_t pid;
382         char *pos;
383         char arg[PROGRAM_SIZE];
384         char *argv[sizeof(arg) / 2];
385         int i;
386
387         i = 0;
388         if (strchr(path, ' ')) {
389                 strfieldcpy(arg, path);
390                 pos = arg;
391                 while (pos != NULL) {
392                         if (pos[0] == '\'') {
393                                 /* don't separate if in apostrophes */
394                                 pos++;
395                                 argv[i] = strsep(&pos, "\'");
396                                 while (pos[0] == ' ')
397                                         pos++;
398                 } else {
399                                 argv[i] = strsep(&pos, " ");
400                         }
401                         dbg("arg[%i] '%s'", i, argv[i]);
402                         i++;
403                 }
404         }
405         argv[i] =  NULL;
406
407         retval = pipe(fds);
408         if (retval != 0) {
409                 dbg("pipe failed");
410                 return -1;
411         }
412
413         pid = fork();
414         switch(pid) {
415         case 0:
416                 /* child */
417                 close(STDOUT_FILENO);
418
419                 /* dup write side of pipe to STDOUT */
420                 dup(fds[1]);
421                 if (argv[0] !=  NULL) {
422                         dbg("execute '%s' with given arguments", argv[0]);
423                         retval = execv(argv[0], argv);
424                 } else {
425                         dbg("execute '%s' with main argument", path);
426                         retval = execv(path, main_argv);
427                 }
428
429                 info(FIELD_PROGRAM " execution of '%s' failed", path);
430                 exit(1);
431         case -1:
432                 dbg("fork failed");
433                 return -1;
434         default:
435                 /* parent reads from fds[0] */
436                 close(fds[1]);
437                 retval = 0;
438                 i = 0;
439                 while (1) {
440                         count = read(fds[0], value + i, len - i-1);
441                         if (count <= 0)
442                                 break;
443
444                         i += count;
445                         if (i >= len-1) {
446                                 dbg("result len %d too short", len);
447                                 retval = -1;
448                                 break;
449                         }
450                 }
451
452                 if (count < 0) {
453                         dbg("read failed with '%s'", strerror(errno));
454                         retval = -1;
455                 }
456
457                 if (i > 0 && value[i] == '\n')
458                         i--;
459                 value[i] = '\0';
460                 dbg("result is '%s'", value);
461
462                 close(fds[0]);
463                 wait(&status);
464
465                 if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) {
466                         dbg("exec program status 0x%x", status);
467                         retval = -1;
468                 }
469         }
470         return retval;
471 }
472
473 static struct sysfs_attribute *find_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, char *attr)
474 {
475         struct sysfs_attribute *tmpattr = NULL;
476         char *c;
477
478         dbg("look for device attribute '%s'", attr);
479         /* try to find the attribute in the class device directory */
480         tmpattr = sysfs_get_classdev_attr(class_dev, attr);
481         if (tmpattr)
482                 goto attr_found;
483
484         /* look in the class device directory if present */
485         if (sysfs_device) {
486                 tmpattr = sysfs_get_device_attr(sysfs_device, attr);
487                 if (tmpattr)
488                         goto attr_found;
489         }
490
491         return NULL;
492
493 attr_found:
494         c = strchr(tmpattr->value, '\n');
495         if (c != NULL)
496                 c[0] = '\0';
497
498         dbg("found attribute '%s'", tmpattr->path);
499         return tmpattr;
500 }
501
502 static int compare_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, struct sysfs_pair *pair)
503 {
504         struct sysfs_attribute *tmpattr;
505         int i;
506         int len;
507
508         if ((pair == NULL) || (pair->file[0] == '\0') || (pair->value == '\0'))
509                 return -ENODEV;
510
511         tmpattr = find_sysfs_attribute(class_dev, sysfs_device, pair->file);
512         if (tmpattr == NULL)
513                 return -ENODEV;
514
515         /* strip trailing whitespace of value, if not asked to match for it */
516         if (! isspace(pair->value[strlen(pair->value)-1])) {
517                 i = len = strlen(tmpattr->value);
518                 while (i > 0 &&  isspace(tmpattr->value[i-1]))
519                         i--;
520                 if (i < len) {
521                         tmpattr->value[i] = '\0';
522                         dbg("remove %i trailing whitespace chars from '%s'",
523                             len - i, tmpattr->value);
524                 }
525         }
526
527         dbg("compare attribute '%s' value '%s' with '%s'",
528                   pair->file, tmpattr->value, pair->value);
529         if (strcmp_pattern(pair->value, tmpattr->value) != 0)
530                 return -ENODEV;
531
532         dbg("found matching attribute '%s' with value '%s'",
533             pair->file, pair->value);
534         return 0;
535 }
536
537 static int match_sysfs_pairs(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
538 {
539         struct sysfs_pair *pair;
540         int i;
541
542         for (i = 0; i < MAX_SYSFS_PAIRS; ++i) {
543                 pair = &dev->sysfs_pair[i];
544                 if ((pair->file[0] == '\0') || (pair->value[0] == '\0'))
545                         break;
546                 if (compare_sysfs_attribute(class_dev, sysfs_device, pair) != 0) {
547                         dbg("sysfs attribute doesn't match");
548                         return -ENODEV;
549                 }
550         }
551
552         return 0;
553 }
554
555 static int match_id(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
556 {
557         char path[SYSFS_PATH_MAX];
558         char *temp = NULL;
559
560         /* we have to have a sysfs device for ID to work */
561         if (!sysfs_device)
562                 return -ENODEV;
563
564         strfieldcpy(path, sysfs_device->path);
565         temp = strrchr(path, '/');
566         temp++;
567         dbg("search '%s' in '%s', path='%s'", dev->id, temp, path);
568         if (strcmp_pattern(dev->id, temp) != 0)
569                 return -ENODEV;
570         else
571                 return 0;
572 }
573
574 static int match_place(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
575 {
576         char path[SYSFS_PATH_MAX];
577         int found;
578         char *temp = NULL;
579
580         /* we have to have a sysfs device for PLACE to work */
581         if (!sysfs_device)
582                 return -ENODEV;
583
584         found = 0;
585         strfieldcpy(path, sysfs_device->path);
586         temp = strrchr(path, '/');
587         dbg("search '%s' in '%s', path='%s'", dev->place, temp, path);
588         if (strstr(temp, dev->place) != NULL) {
589                 found = 1;
590         } else {
591                 *temp = 0x00;
592                 temp = strrchr(path, '/');
593                 dbg("search '%s' in '%s', path='%s'", dev->place, temp, path);
594                 if (strstr(temp, dev->place) != NULL)
595                         found = 1;
596         }
597         if (!found) {
598                 dbg("place doesn't match");
599                 return -ENODEV;
600         }
601
602         return 0;
603 }
604
605 static struct sysfs_device *get_sysfs_device(struct sysfs_class_device *class_dev)
606 {
607         struct sysfs_device *sysfs_device;
608         struct sysfs_class_device *class_dev_parent;
609         struct timespec tspec;
610         int loop;
611
612         /* Figure out where the device symlink is at.  For char devices this will
613          * always be in the class_dev->path.  But for block devices, it's different.
614          * The main block device will have the device symlink in it's path, but
615          * all partitions have the symlink in its parent directory.
616          * But we need to watch out for block devices that do not have parents, yet
617          * look like a partition (fd0, loop0, etc.)  They all do not have a device
618          * symlink yet.  We do sit and spin on waiting for them right now, we should
619          * possibly have a whitelist for these devices here...
620          */
621         class_dev_parent = sysfs_get_classdev_parent(class_dev);
622         if (class_dev_parent) 
623                 dbg("Really a partition");
624
625         tspec.tv_sec = 0;
626         tspec.tv_nsec = 10000000;  /* sleep 10 millisec */
627         loop = 10;
628         while (loop--) {
629                 if (udev_sleep)
630                         nanosleep(&tspec, NULL);
631                 if (class_dev_parent)
632                         sysfs_device = sysfs_get_classdev_device(class_dev_parent);
633                 else
634                         sysfs_device = sysfs_get_classdev_device(class_dev);
635
636                 if (sysfs_device != NULL)
637                         goto device_found;
638         }
639         dbg("timed out waiting for device symlink, continuing on anyway...");
640         
641 device_found:
642         /* We have another issue with just the wait above - the sysfs part of
643          * the kernel may not be quick enough to have created the link to the
644          * device under the "bus" subsystem. Due to this, the sysfs_device->bus
645          * will not contain the actual bus name :(
646          *
647          * Libsysfs now provides a new API sysfs_get_device_bus(), so use it
648          * if needed
649          */
650         if (sysfs_device) {
651                 if (sysfs_device->bus[0] != '\0')
652                         goto bus_found;
653
654                 loop = 10;
655                 tspec.tv_nsec = 10000000;
656                 while (loop--) {
657                         if (udev_sleep)
658                                 nanosleep(&tspec, NULL);
659                         sysfs_get_device_bus(sysfs_device);
660                         
661                         if (sysfs_device->bus[0] != '\0')
662                                 goto bus_found;
663                 }
664                 dbg("timed out waiting to find the device bus, continuing on anyway");
665                 goto exit;
666 bus_found:
667                 dbg("device %s is registered with bus '%s'",
668                                 sysfs_device->name, sysfs_device->bus);
669         }
670 exit:
671         return sysfs_device;
672 }
673
674 static int match_rule(struct config_device *dev, struct sysfs_class_device *class_dev, struct udevice *udev, struct sysfs_device *sysfs_device)
675 {
676         while (1) {
677                 /* check for matching bus value */
678                 if (dev->bus[0] != '\0') {
679                         if (sysfs_device == NULL) {
680                                 dbg("device has no bus");
681                                 goto try_parent;
682                         }
683                         dbg("check for " FIELD_BUS " dev->bus='%s' sysfs_device->bus='%s'", dev->bus, sysfs_device->bus);
684                         if (strcmp_pattern(dev->bus, sysfs_device->bus) != 0) {
685                                 dbg(FIELD_BUS " is not matching");
686                                 goto try_parent;
687                         } else {
688                                 dbg(FIELD_BUS " matches");
689                         }
690                 }
691
692                 /* check for matching kernel name*/
693                 if (dev->kernel[0] != '\0') {
694                         dbg("check for " FIELD_KERNEL " dev->kernel='%s' class_dev->name='%s'", dev->kernel, class_dev->name);
695                         if (strcmp_pattern(dev->kernel, class_dev->name) != 0) {
696                                 dbg(FIELD_KERNEL " is not matching");
697                                 goto try_parent;
698                         } else {
699                                 dbg(FIELD_KERNEL " matches");
700                         }
701                 }
702
703                 /* check for matching bus id */
704                 if (dev->id[0] != '\0') {
705                         dbg("check " FIELD_ID);
706                         if (match_id(dev, class_dev, sysfs_device) != 0) {
707                                 dbg(FIELD_ID " is not matching");
708                                 goto try_parent;
709                         } else {
710                                 dbg(FIELD_ID " matches");
711                         }
712                 }
713
714                 /* check for matching place of device */
715                 if (dev->place[0] != '\0') {
716                         dbg("check " FIELD_PLACE);
717                         if (match_place(dev, class_dev, sysfs_device) != 0) {
718                                 dbg(FIELD_PLACE " is not matching");
719                                 goto try_parent;
720                         } else {
721                                 dbg(FIELD_PLACE " matches");
722                         }
723                 }
724
725                 /* check for matching sysfs pairs */
726                 if (dev->sysfs_pair[0].file[0] != '\0') {
727                         dbg("check " FIELD_SYSFS " pairs");
728                         if (match_sysfs_pairs(dev, class_dev, sysfs_device) != 0) {
729                                 dbg(FIELD_SYSFS " is not matching");
730                                 goto try_parent;
731                         } else {
732                                 dbg(FIELD_SYSFS " matches");
733                         }
734                 }
735
736                 /* execute external program */
737                 if (dev->program[0] != '\0') {
738                         dbg("check " FIELD_PROGRAM);
739                         apply_format(udev, dev->program, sizeof(dev->program),
740                                      class_dev, sysfs_device);
741                         if (execute_program(dev->program, udev->program_result, NAME_SIZE) != 0) {
742                                 dbg(FIELD_PROGRAM " returned nonzero");
743                                 goto try_parent;
744                         } else {
745                                 dbg(FIELD_PROGRAM " returned successful");
746                         }
747                 }
748
749                 /* check for matching result of external program */
750                 if (dev->result[0] != '\0') {
751                         dbg("check for " FIELD_RESULT
752                             " dev->result='%s', udev->program_result='%s'",
753                             dev->result, udev->program_result);
754                         if (strcmp_pattern(dev->result, udev->program_result) != 0) {
755                                 dbg(FIELD_RESULT " is not matching");
756                                 goto try_parent;
757                         } else {
758                                 dbg(FIELD_RESULT " matches");
759                         }
760                 }
761
762                 /* Yeah, we matched! */
763                 return 0;
764
765 try_parent:
766                 dbg("try parent sysfs device");
767                 sysfs_device = sysfs_get_device_parent(sysfs_device);
768                 if (sysfs_device == NULL)
769                         return -ENODEV;
770                 dbg("sysfs_device->path='%s'", sysfs_device->path);
771                 dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id);
772                 dbg("sysfs_device->bus='%s'", sysfs_device->bus);
773         }
774
775 }
776
777 int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *udev)
778 {
779         struct sysfs_device *sysfs_device = NULL;
780         struct config_device *dev;
781         struct perm_device *perm;
782         char *pos;
783
784         udev->mode = 0;
785
786         /* find the sysfs_device associated with this class device */
787         sysfs_device = get_sysfs_device(class_dev);
788         if (sysfs_device) {
789                 dbg("sysfs_device->path='%s'", sysfs_device->path);
790                 dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id);
791                 dbg("sysfs_device->bus='%s'", sysfs_device->bus);
792                 strfieldcpy(udev->bus_id, sysfs_device->bus_id);
793                 wait_for_device_to_initialize(sysfs_device);
794         }
795         dbg("class_dev->name = '%s'", class_dev->name);
796
797         strfieldcpy(udev->kernel_name, class_dev->name);
798         fix_kernel_name(udev);
799         dbg("udev->kernel_name = '%s'", udev->kernel_name);
800
801         /* get kernel number */
802         pos = class_dev->name + strlen(class_dev->name);
803         while (isdigit(*(pos-1)))
804                 pos--;
805         strfieldcpy(udev->kernel_number, pos);
806         dbg("kernel_number='%s'", udev->kernel_number);
807
808         /* look for a matching rule to apply */
809         list_for_each_entry(dev, &config_device_list, node) {
810                 dbg("process rule");
811                 if (match_rule(dev, class_dev, udev, sysfs_device) == 0) {
812                         if (dev->name[0] == '\0' && dev->symlink[0] == '\0') {
813                                 info("configured rule in '%s' at line %i applied, '%s' is ignored",
814                                      dev->config_file, dev->config_line, udev->kernel_name);
815                                 return -1;
816                         }
817
818                         if (dev->symlink[0] != '\0') {
819                                 char temp[NAMESIZE];
820
821                                 info("configured rule in '%s' at line %i applied, added symlink '%s'",
822                                      dev->config_file, dev->config_line, dev->symlink);
823                                 strfieldcpy(temp, dev->symlink);
824                                 apply_format(udev, temp, sizeof(temp), class_dev, sysfs_device);
825                                 if (udev->symlink[0] != '\0')
826                                         strfieldcat(udev->symlink, " ");
827                                 strfieldcat(udev->symlink, temp);
828                         }
829
830                         if (dev->name[0] != '\0') {
831                                 info("configured rule in '%s' at line %i applied, '%s' becomes '%s'",
832                                      dev->config_file, dev->config_line, udev->kernel_name, dev->name);
833                                 strfieldcpy(udev->name, dev->name);
834                                 goto found;
835                         }
836                 }
837         }
838
839         /* no rule was found so we use the kernel name */
840         strfieldcpy(udev->name, udev->kernel_name);
841         goto done;
842
843 found:
844         apply_format(udev, udev->name, sizeof(udev->name), class_dev, sysfs_device);
845         udev->partitions = dev->partitions;
846         strfieldcpy(udev->config_file, dev->config_file);
847         udev->config_line = dev->config_line;
848
849         /* get permissions given in rule */
850         set_empty_perms(udev, dev->mode,
851                               dev->owner,
852                               dev->group);
853
854 done:
855         /* get permissions given in config file or set defaults */
856         perm = find_perm(udev->name);
857         if (perm != NULL) {
858                 set_empty_perms(udev, perm->mode,
859                                       perm->owner,
860                                       perm->group);
861         } else {
862                 set_empty_perms(udev, get_default_mode(),
863                                       get_default_owner(),
864                                       get_default_group());
865         }
866
867         dbg("name, '%s' is going to have owner='%s', group='%s', mode = %#o",
868             udev->name, udev->owner, udev->group, udev->mode);
869
870         /* store time of action */
871         udev->config_time = time(NULL);
872
873         return 0;
874 }
875
876 int namedev_init(void)
877 {
878         int retval;
879
880         retval = namedev_init_rules();
881         if (retval)
882                 return retval;
883
884         retval = namedev_init_permissions();
885         if (retval)
886                 return retval;
887
888         dump_config_dev_list();
889         dump_perm_dev_list();
890         return retval;
891 }