/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #include "cfga_usb.h" #define MAXLINESIZE 512 #define FE_BUFLEN 256 #define isunary(ch) ((ch) == '~' || (ch) == '-') #define iswhite(ch) ((ch) == ' ' || (ch) == '\t') #define isnewline(ch) ((ch) == '\n' || (ch) == '\r' || (ch) == '\f') #define isalphanum(ch) (isalpha(ch) || isdigit(ch)) #define isnamechar(ch) (isalphanum(ch) || (ch) == '_' || (ch) == '-') #define MAX(a, b) ((a) < (b) ? (b) : (a)) #define GETC(a, cntr) a[cntr++] #define UNGETC(cntr) cntr-- typedef struct usb_configrec { char *selection; int idVendor, idProduct, cfgndx; char *serialno; char *pathname; char *driver; } usb_configrec_t; typedef enum { USB_SELECTION, USB_VENDOR, USB_PRODUCT, USB_CFGNDX, USB_SRNO, USB_PATH, USB_DRIVER, USB_NONE } config_field_t; typedef struct usbcfg_var { const char *name; config_field_t field; } usbcfg_var_t; static usbcfg_var_t usbcfg_varlist[] = { { "selection", USB_SELECTION }, { "idVendor", USB_VENDOR }, { "idProduct", USB_PRODUCT }, { "cfgndx", USB_CFGNDX }, { "srno", USB_SRNO }, { "pathname", USB_PATH }, { "driver", USB_DRIVER }, { NULL, USB_NONE } }; typedef enum { EQUALS, AMPERSAND, BIT_OR, STAR, POUND, COLON, SEMICOLON, COMMA, SLASH, WHITE_SPACE, NEWLINE, E_O_F, STRING, HEXVAL, DECVAL, NAME } token_t; static char usbconf_file[] = USBCONF_FILE; static int linenum = 1; static int cntr = 0; static int frec = 0; static int brec = 0; static int btoken = 0; mutex_t file_lock = DEFAULTMUTEX; /* * prototypes */ static int get_string(u_longlong_t *llptr, char *tchar); static int getvalue(char *token, u_longlong_t *valuep); /* * The next item on the line is a string value. Allocate memory for * it and copy the string. Return 1, and set arg ptr to newly allocated * and initialized buffer, or NULL if an error occurs. */ static int get_string(u_longlong_t *llptr, char *tchar) { register char *cp; register char *start = (char *)0; register int len = 0; len = strlen(tchar); start = tchar; /* copy string */ cp = (char *)calloc(len + 1, sizeof (char)); if (cp == (char *)NULL) { *llptr = NULL; return (0); } *llptr = (u_longlong_t)(uintptr_t)cp; for (; len > 0; len--) { /* convert some common escape sequences */ if (*start == '\\') { switch (*(start + 1)) { case 't': /* tab */ *cp++ = '\t'; len--; start += 2; break; case 'n': /* new line */ *cp++ = '\n'; len--; start += 2; break; case 'b': /* back space */ *cp++ = '\b'; len--; start += 2; break; default: /* simply copy it */ *cp++ = *start++; break; } } else { *cp++ = *start++; } } *cp = '\0'; return (1); } /* * get a decimal octal or hex number. Handle '~' for one's complement. */ static int getvalue(char *token, u_longlong_t *valuep) { register int radix; register u_longlong_t retval = 0; register int onescompl = 0; register int negate = 0; register char c; if (*token == '~') { onescompl++; /* perform one's complement on result */ token++; } else if (*token == '-') { negate++; token++; } if (*token == '0') { token++; c = *token; if (c == '\0') { *valuep = 0; /* value is 0 */ return (0); } if (c == 'x' || c == 'X') { radix = 16; token++; } else { radix = 8; } } else { radix = 10; } while ((c = *token++)) { switch (radix) { case 8: if (c >= '0' && c <= '7') { c -= '0'; } else { return (-1); /* invalid number */ } retval = (retval << 3) + c; break; case 10: if (c >= '0' && c <= '9') { c -= '0'; } else { return (-1); /* invalid number */ } retval = (retval * 10) + c; break; case 16: if (c >= 'a' && c <= 'f') { c = c - 'a' + 10; } else if (c >= 'A' && c <= 'F') { c = c - 'A' + 10; } else if (c >= '0' && c <= '9') { c -= '0'; } else { return (-1); /* invalid number */ } retval = (retval << 4) + c; break; } } if (onescompl) retval = ~retval; if (negate) retval = -retval; *valuep = retval; return (0); } /* * returns the field from the token */ static config_field_t usb_get_var_type(char *str) { usbcfg_var_t *cfgvar; cfgvar = &usbcfg_varlist[0]; while (cfgvar->field != USB_NONE) { if (strcasecmp(cfgvar->name, str) == NULL) { break; } else { cfgvar++; } } return (cfgvar->field); } /* ARGSUSED */ static token_t lex(char *buf, char *val, char **errmsg) { int ch, oval, badquote; char *cp; token_t token; cp = val; while ((ch = GETC(buf, cntr)) == ' ' || ch == '\t'); /* * Note the beginning of a token */ btoken = cntr - 1; *cp++ = (char)ch; switch (ch) { case '=': token = EQUALS; break; case '&': token = AMPERSAND; break; case '|': token = BIT_OR; break; case '*': token = STAR; break; case '#': token = POUND; break; case ':': token = COLON; break; case ';': token = SEMICOLON; break; case ',': token = COMMA; break; case '/': token = SLASH; break; case ' ': case '\t': case '\f': while ((ch = GETC(buf, cntr)) == ' ' || ch == '\t' || ch == '\f') *cp++ = (char)ch; (void) UNGETC(cntr); token = WHITE_SPACE; break; case '\n': case '\r': token = NEWLINE; break; case '"': cp--; badquote = 0; while (!badquote && (ch = GETC(buf, cntr)) != '"') { switch (ch) { case '\n': case -1: (void) snprintf(*errmsg, MAXPATHLEN, "Missing \""); cp = val; *cp++ = '\n'; badquote = 1; /* since we consumed the newline/EOF */ (void) UNGETC(cntr); break; case '\\': ch = (char)GETC(buf, cntr); if (!isdigit(ch)) { /* escape the character */ *cp++ = (char)ch; break; } oval = 0; while (ch >= '0' && ch <= '7') { ch -= '0'; oval = (oval << 3) + ch; ch = (char)GETC(buf, cntr); } (void) UNGETC(cntr); /* check for character overflow? */ if (oval > 127) { (void) snprintf(*errmsg, MAXPATHLEN, "Character overflow detected.\n"); } *cp++ = (char)oval; break; default: *cp++ = (char)ch; break; } } token = STRING; break; default: if (ch == -1) { token = EOF; break; } /* * detect a lone '-' (including at the end of a line), and * identify it as a 'name' */ if (ch == '-') { *cp++ = (char)(ch = GETC(buf, cntr)); if (iswhite(ch) || (ch == '\n')) { (void) UNGETC(cntr); cp--; token = NAME; break; } } else if (isunary(ch)) { *cp++ = (char)(ch = GETC(buf, cntr)); } if (isdigit(ch)) { if (ch == '0') { if ((ch = GETC(buf, cntr)) == 'x') { *cp++ = (char)ch; ch = GETC(buf, cntr); while (isxdigit(ch)) { *cp++ = (char)ch; ch = GETC(buf, cntr); } (void) UNGETC(cntr); token = HEXVAL; } else { goto digit; } } else { ch = GETC(buf, cntr); digit: while (isdigit(ch)) { *cp++ = (char)ch; ch = GETC(buf, cntr); } (void) UNGETC(cntr); token = DECVAL; } } else if (isalpha(ch) || ch == '\\') { if (ch != '\\') { ch = GETC(buf, cntr); } else { /* * if the character was a backslash, * back up so we can overwrite it with * the next (i.e. escaped) character. */ cp--; } while (isnamechar(ch) || ch == '\\') { if (ch == '\\') ch = GETC(buf, cntr); *cp++ = (char)ch; ch = GETC(buf, cntr); } (void) UNGETC(cntr); token = NAME; } else { return (-1); } break; } *cp = '\0'; return (token); } /* * Leave NEWLINE as the next character. */ static void find_eol(char *buf) { register int ch; while ((ch = GETC(buf, cntr)) != -1) { if (isnewline(ch)) { (void) UNGETC(cntr); break; } } } /* * Fetch one record from the USBCONF_FILE */ static token_t usb_get_conf_rec(char *buf, usb_configrec_t **rec, char **errmsg) { token_t token; char tokval[MAXLINESIZE]; usb_configrec_t *user_rec; config_field_t cfgvar; u_longlong_t llptr; u_longlong_t value; boolean_t sor = B_TRUE; enum { USB_NEWVAR, USB_CONFIG_VAR, USB_VAR_EQUAL, USB_VAR_VALUE, USB_ERROR } parse_state = USB_NEWVAR; DPRINTF("usb_get_conf_rec:\n"); user_rec = (usb_configrec_t *)calloc(1, sizeof (usb_configrec_t)); if (user_rec == (usb_configrec_t *)NULL) { return (0); } user_rec->idVendor = user_rec->idProduct = user_rec->cfgndx = -1; token = lex(buf, tokval, errmsg); while ((token != EOF) && (token != SEMICOLON)) { switch (token) { case STAR: case POUND: /* skip comments */ find_eol(buf); break; case NEWLINE: linenum++; break; case NAME: case STRING: switch (parse_state) { case USB_NEWVAR: cfgvar = usb_get_var_type(tokval); if (cfgvar == USB_NONE) { parse_state = USB_ERROR; (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: Invalid field %s", tokval); } else { /* * Note the beginning of a record */ if (sor) { brec = btoken; if (frec == 0) frec = brec; sor = B_FALSE; } parse_state = USB_CONFIG_VAR; } break; case USB_VAR_VALUE: if ((cfgvar == USB_VENDOR) || (cfgvar == USB_PRODUCT) || (cfgvar == USB_CFGNDX)) { parse_state = USB_ERROR; (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: Invalid value %s " "for field: %s\n", tokval, usbcfg_varlist[cfgvar].name); } else if (get_string(&llptr, tokval)) { switch (cfgvar) { case USB_SELECTION: user_rec->selection = (char *)(uintptr_t)llptr; parse_state = USB_NEWVAR; break; case USB_SRNO: user_rec->serialno = (char *)(uintptr_t)llptr; parse_state = USB_NEWVAR; break; case USB_PATH: user_rec->pathname = (char *)(uintptr_t)llptr; parse_state = USB_NEWVAR; break; case USB_DRIVER: user_rec->driver = (char *)(uintptr_t)llptr; parse_state = USB_NEWVAR; break; default: parse_state = USB_ERROR; free((char *)(uintptr_t)llptr); } } else { parse_state = USB_ERROR; (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: Invalid value %s " "for field: %s\n", tokval, usbcfg_varlist[cfgvar].name); } break; case USB_ERROR: /* just skip */ break; default: parse_state = USB_ERROR; (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: at %s", tokval); break; } break; case EQUALS: if (parse_state == USB_CONFIG_VAR) { if (cfgvar == USB_NONE) { parse_state = USB_ERROR; (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: unexpected '='"); } else { parse_state = USB_VAR_VALUE; } } else if (parse_state != USB_ERROR) { (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: unexpected '='"); parse_state = USB_ERROR; } break; case HEXVAL: case DECVAL: if ((parse_state == USB_VAR_VALUE) && (cfgvar != USB_NONE)) { (void) getvalue(tokval, &value); switch (cfgvar) { case USB_VENDOR: user_rec->idVendor = (int)value; parse_state = USB_NEWVAR; break; case USB_PRODUCT: user_rec->idProduct = (int)value; parse_state = USB_NEWVAR; break; case USB_CFGNDX: user_rec->cfgndx = (int)value; parse_state = USB_NEWVAR; break; default: (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: Invalid value for " "%s", usbcfg_varlist[cfgvar].name); } } else if (parse_state != USB_ERROR) { parse_state = USB_ERROR; (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: unexpected hex/decimal: %s", tokval); } break; default: (void) snprintf(*errmsg, MAXPATHLEN, "Syntax Error: at: %s", tokval); parse_state = USB_ERROR; break; } token = lex(buf, tokval, errmsg); } *rec = user_rec; return (token); } /* * Here we compare the two records and determine if they are the same */ static boolean_t usb_cmp_rec(usb_configrec_t *cfg_rec, usb_configrec_t *user_rec) { char *ustr, *cstr; boolean_t srno = B_FALSE, path = B_FALSE; DPRINTF("usb_cmp_rec:\n"); if ((cfg_rec->idVendor == user_rec->idVendor) && (cfg_rec->idProduct == user_rec->idProduct)) { if (user_rec->serialno) { if (cfg_rec->serialno) { srno = (strcmp(cfg_rec->serialno, user_rec->serialno) == 0); } else { return (B_FALSE); } } else if (user_rec->pathname) { if (cfg_rec->pathname) { /* * Comparing on this is tricky. At this point * hubd knows: ../hubd@P/device@P while user * will specify ..../hubd@P/keyboard@P * First compare till .../hubd@P * Second compare is just P in "device@P" * * XXX: note that we assume P as one character * as there are no 2 digit hubs in the market. */ ustr = strrchr(user_rec->pathname, '/'); cstr = strrchr(cfg_rec->pathname, '/'); path = (strncmp(cfg_rec->pathname, user_rec->pathname, MAX(ustr - user_rec->pathname, cstr - cfg_rec->pathname)) == 0); path = path && (*(user_rec->pathname + strlen(user_rec->pathname) -1) == *(cfg_rec->pathname + strlen(cfg_rec->pathname) - 1)); } else { return (B_FALSE); } } else if (cfg_rec->serialno || cfg_rec->pathname) { return (B_FALSE); } else { return (B_TRUE); } return (srno || path); } else { return (B_FALSE); } } /* * free the record allocated in usb_get_conf_rec */ static void usb_free_rec(usb_configrec_t *rec) { if (rec == (usb_configrec_t *)NULL) { return; } free(rec->selection); free(rec->serialno); free(rec->pathname); free(rec->driver); free(rec); } int add_entry(char *selection, int vid, int pid, int cfgndx, char *srno, char *path, char *driver, char **errmsg) { int file; int rval = CFGA_USB_OK; char *buf = (char *)NULL; char str[MAXLINESIZE]; token_t token = NEWLINE; boolean_t found = B_FALSE; struct stat st; usb_configrec_t cfgrec, *user_rec = NULL; DPRINTF("add_entry: driver=%s, path=%s\n", driver ? driver : "", path ? path : ""); if (*errmsg == (char *)NULL) { if ((*errmsg = calloc(MAXPATHLEN, 1)) == (char *)NULL) { return (CFGA_USB_CONFIG_FILE); } } (void) mutex_lock(&file_lock); /* Initialize the cfgrec */ cfgrec.selection = selection; cfgrec.idVendor = vid; cfgrec.idProduct = pid; cfgrec.cfgndx = cfgndx; cfgrec.serialno = srno; cfgrec.pathname = path; cfgrec.driver = driver; /* open config_map.conf file */ file = open(usbconf_file, O_RDWR, 0666); if (file == -1) { (void) snprintf(*errmsg, MAXPATHLEN, "failed to open config file\n"); (void) mutex_unlock(&file_lock); return (CFGA_USB_CONFIG_FILE); } if (lockf(file, F_TLOCK, 0) == -1) { (void) snprintf(*errmsg, MAXPATHLEN, "failed to lock config file\n"); close(file); (void) mutex_unlock(&file_lock); return (CFGA_USB_LOCK_FILE); } /* * These variables need to be reinitialized here as they may * have been modified by a previous thread that called this * function */ linenum = 1; cntr = 0; frec = 0; brec = 0; btoken = 0; if (fstat(file, &st) != 0) { DPRINTF("add_entry: failed to fstat config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } if ((buf = (char *)malloc(st.st_size)) == NULL) { DPRINTF("add_entry: failed to fstat config file\n"); rval = CFGA_USB_ALLOC_FAIL; goto exit; } if (st.st_size != read(file, buf, st.st_size)) { DPRINTF("add_entry: failed to read config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } /* set up for reading the file */ while ((token != EOF) && !found) { if (user_rec) { usb_free_rec(user_rec); user_rec = NULL; } token = usb_get_conf_rec(buf, &user_rec, errmsg); found = usb_cmp_rec(&cfgrec, user_rec); DPRINTF("add_entry: token=%x, found=%x\n", token, found); } bzero(str, MAXLINESIZE); if (found) { DPRINTF("FOUND\n"); (void) snprintf(str, MAXLINESIZE, "selection=%s idVendor=0x%x " "idProduct=0x%x ", (cfgrec.selection) ? cfgrec.selection : user_rec->selection, user_rec->idVendor, user_rec->idProduct); if ((user_rec->cfgndx != -1) || (cfgrec.cfgndx != -1)) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "cfgndx=0x%x ", (cfgrec.cfgndx != -1) ? cfgrec.cfgndx : user_rec->cfgndx); } if (user_rec->serialno) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "srno=\"%s\" ", user_rec->serialno); } if (user_rec->pathname) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "pathname=\"%s\" ", user_rec->pathname); } if (user_rec->driver) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "driver=\"%s\" ", user_rec->driver); } else if (cfgrec.driver != NULL) { if (strlen(cfgrec.driver)) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "driver=\"%s\" ", cfgrec.driver); } } (void) strlcat(str, ";", sizeof (str)); /* * Seek to the beginning of the record */ if (lseek(file, brec, SEEK_SET) == -1) { DPRINTF("add_entry: failed to lseek config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } /* * Write the modified record */ if (write(file, str, strlen(str)) == -1) { DPRINTF("add_entry: failed to write config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } /* * Write the rest of the file as it was */ if (write(file, buf+cntr, st.st_size - cntr) == -1) { DPRINTF("add_entry: failed to write config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } } else { DPRINTF("!FOUND\n"); (void) snprintf(str, MAXLINESIZE, "selection=%s idVendor=0x%x idProduct=0x%x ", (cfgrec.selection) ? cfgrec.selection : "enable", cfgrec.idVendor, cfgrec.idProduct); if (cfgrec.cfgndx != -1) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "cfgndx=0x%x ", cfgrec.cfgndx); } if (cfgrec.serialno) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "srno=\"%s\" ", cfgrec.serialno); } if (cfgrec.pathname != NULL) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "pathname=\"%s\" ", cfgrec.pathname); } if (cfgrec.driver != NULL) { if (strlen(cfgrec.driver)) { (void) snprintf(&str[strlen(str)], MAXLINESIZE, "driver=\"%s\" ", cfgrec.driver); } } (void) strlcat(str, ";\n", sizeof (str)); /* * Incase this is the first entry, add it after the comments */ if (frec == 0) { frec = st.st_size; } /* * Go to the beginning of the records */ if (lseek(file, frec, SEEK_SET) == -1) { DPRINTF("add_entry: failed to lseek config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } /* * Add the entry */ if (write(file, str, strlen(str)) == -1) { DPRINTF("add_entry: failed to write config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } /* * write the remaining file as it was */ if (write(file, buf+frec, st.st_size - frec) == -1) { DPRINTF("add_entry: failed to write config file\n"); rval = CFGA_USB_CONFIG_FILE; goto exit; } } /* no error encountered */ if (rval == CFGA_USB_OK) { free(errmsg); } exit: if (buf != NULL) { free(buf); } if (lockf(file, F_ULOCK, 0) == -1) { DPRINTF("add_entry: failed to unlock config file\n"); rval = CFGA_USB_LOCK_FILE; } close(file); (void) mutex_unlock(&file_lock); return (rval); }