/* Find our devices */ SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { char config_line[PATH_MAX]; size_t len; FILE *fp; DBG_INIT (); #if 0 DBG_LEVEL = 10; #endif DBG (2, "sane_init: version_code %s 0, authorize %s 0\n", version_code == 0 ? "=" : "!=", authorize == 0 ? "=" : "!="); DBG (1, "sane_init: SANE Canon630u backend version %d.%d.%d from %s\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING); if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); sanei_usb_init (); fp = sanei_config_open (CANONUSB_CONFIG_FILE); if (!fp) { /* no config-file: try these */ attach_scanner ("/dev/scanner", 0); attach_scanner ("/dev/usbscanner", 0); attach_scanner ("/dev/usb/scanner", 0); return SANE_STATUS_GOOD; } DBG (3, "reading configure file %s\n", CANONUSB_CONFIG_FILE); while (sanei_config_read (config_line, sizeof (config_line), fp)) { if (config_line[0] == '#') continue; /* ignore line comments */ len = strlen (config_line); if (!len) continue; /* ignore empty lines */ DBG (4, "attach_matching_devices(%s)\n", config_line); sanei_usb_attach_matching_devices (config_line, attach_one); } DBG (4, "finished reading configure file\n"); fclose (fp); return SANE_STATUS_GOOD; }
SANE_Status sane_init( SANE_Int *versionP, SANE_Auth_Callback authorize ) { FILE *fp; SANE_Status status; DBG_INIT(); DBG(DCODE, "sane_init: version %s null, authorize %s null\n", (versionP) ? "!=" : "==", (authorize) ? "!=" : "=="); if( versionP != NULL ) *versionP = SANE_VERSION_CODE(SANE_CURRENT_MAJOR, V_MINOR, 0); status = SANE_STATUS_GOOD; if( (fp = sanei_config_open(ST400_CONFIG_FILE)) != NULL ) { char line[PATH_MAX], *str; size_t len, linenum; linenum = 0; DBG(DCODE, "sane_init: reading config file\n"); while( sanei_config_read(line, sizeof(line), fp) ) { ++linenum; str = line; if( str[0] == '#' ) continue; /* ignore comments */ str = (char *)sanei_config_skip_whitespace(str); len = strlen(str); if( !len ) continue; /* ignore empty lines */ if( strncmp(str, "option", 6) == 0 && isspace(str[6]) ) { DBG(DCODE, "sane_init: config line <%s>\n", line); status = st400_config_do_option(str+7, linenum); } else { DBG(DCODE, "sane_init: attaching device <%s>\n", line); sanei_config_attach_matching_devices(line, st400_attach_one); } if( status != SANE_STATUS_GOOD ) break; } DBG(DCODE, "sane_init: closing config file\n"); fclose(fp); } if( status == SANE_STATUS_GOOD && st400_devices == NULL ) { DBG(DCODE, "sane_init: attaching default device <%s>\n", ST400_DEFAULT_DEVICE); sanei_config_attach_matching_devices(ST400_DEFAULT_DEVICE, st400_attach_one); } return status; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { char dev_name[PATH_MAX]; size_t len; FILE *fp; authorize = authorize; /* silence gcc */ DBG_INIT (); if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); fp = sanei_config_open (ABATON_CONFIG_FILE); if (!fp) { /* default to /dev/scanner instead of insisting on config file */ attach ("/dev/scanner", 0, SANE_FALSE); return SANE_STATUS_GOOD; } while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { if (dev_name[0] == '#') /* ignore line comments */ continue; len = strlen (dev_name); if (!len) continue; /* ignore empty lines */ if (strncmp (dev_name, "option", 6) == 0 && isspace (dev_name[6])) { const char *str = dev_name + 7; while (isspace (*str)) ++str; continue; } sanei_config_attach_matching_devices (dev_name, attach_one); } fclose (fp); return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize) { FILE *fp; char dev_name[PATH_MAX]; size_t len; DBG_INIT (); DBG (DBG_sane_init, "sane_init\n"); DBG (DBG_error, "This is sane-leo version %d.%d-%d\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD); DBG (DBG_error, "(C) 2002 by Frank Zago\n"); if (version_code) { *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); } fp = sanei_config_open (LEO_CONFIG_FILE); if (!fp) { /* default to /dev/scanner instead of insisting on config file */ attach_scanner ("/dev/scanner", 0); return SANE_STATUS_GOOD; } while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { if (dev_name[0] == '#') /* ignore line comments */ continue; len = strlen (dev_name); if (!len) continue; /* ignore empty lines */ sanei_config_attach_matching_devices (dev_name, attach_one); } fclose (fp); DBG (DBG_proc, "sane_init: leave\n"); return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { char devnam[PATH_MAX] = "/dev/scanner"; FILE *fp; authorize = authorize; /* silence gcc */ DBG_INIT (); DBG (11, ">> sane_init\n"); #if defined PACKAGE && defined VERSION DBG (2, "sane_init: " PACKAGE " " VERSION "\n"); #endif if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); fp = sanei_config_open(RICOH_CONFIG_FILE); if (fp) { char line[PATH_MAX], *lp; size_t len; /* read config file */ while (sanei_config_read (line, sizeof (line), fp)) { if (line[0] == '#') /* ignore line comments */ continue; len = strlen (line); if (!len) continue; /* ignore empty lines */ /* skip white space: */ for (lp = line; isspace(*lp); ++lp); strcpy (devnam, lp); } fclose (fp); } sanei_config_attach_matching_devices (devnam, attach_one); DBG (11, "<< sane_init\n"); return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { char dev_name[PATH_MAX], *str; size_t len; FILE *fp; authorize = authorize; /* stop gcc from complaining */ DBG_INIT (); DBG (2, "SANE v4l backend version %d.%d build %d from %s\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING); if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); fp = sanei_config_open (V4L_CONFIG_FILE); if (!fp) { DBG (2, "sane_init: file `%s' not accessible (%s), trying /dev/video0\n", V4L_CONFIG_FILE, strerror (errno)); return attach ("/dev/video0", 0); } while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { if (dev_name[0] == '#') /* ignore line comments */ continue; len = strlen (dev_name); if (!len) continue; /* ignore empty lines */ /* Remove trailing space and trailing comments */ for (str = dev_name; *str && !isspace (*str) && *str != '#'; ++str); attach (dev_name, 0); } fclose (fp); return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int *version_code, SANE_Auth_Callback authorize) { char dev_name[PATH_MAX]; size_t len; FILE *fp; authorize = authorize; /* silence compilation warnings */ DBG_INIT(); sanei_thread_init(); if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); fp = sanei_config_open (TAMARACK_CONFIG_FILE); if (!fp) { /* default to /dev/scanner instead of insisting on config file */ attach ("/dev/scanner", 0); return SANE_STATUS_GOOD; } while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { if (dev_name[0] == '#') /* ignore line comments */ continue; len = strlen (dev_name); if (!len) continue; /* ignore empty lines */ sanei_config_attach_matching_devices (dev_name, attach_one); } fclose (fp); return SANE_STATUS_GOOD; }
/* * Called by SANE to find out about supported devices. * * From the SANE spec: * This function can be used to query the list of devices that are * available. If the function executes successfully, it stores a * pointer to a NULL terminated array of pointers to SANE_Device * structures in *device_list. The returned list is guaranteed to * remain unchanged and valid until (a) another call to this function * is performed or (b) a call to sane_exit() is performed. This * function can be called repeatedly to detect when new devices become * available. If argument local_only is true, only local devices are * returned (devices directly attached to the machine that SANE is * running on). If it is false, the device list includes all remote * devices that are accessible to the SANE library. * * SANE does not require that this function is called before a * sane_open() call is performed. A device name may be specified * explicitly by a user which would make it unnecessary and * undesirable to call this function first. * * Read the config file, find scanners with help from sanei_* * store in global device structs */ SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) { struct scanner *dev; char line[PATH_MAX]; const char *lp; FILE *fp; int num_devices=0; int i=0; local_only = local_only; /* get rid of compiler warning */ DBG (10, "sane_get_devices: start\n"); global_has_cal_buffer = 1; global_lines_per_block = 16; fp = sanei_config_open (CONFIG_FILE); if (fp) { DBG (15, "sane_get_devices: reading config file %s\n", CONFIG_FILE); while (sanei_config_read (line, PATH_MAX, fp)) { lp = line; /* ignore comments */ if (*lp == '#') continue; /* skip empty lines */ if (*lp == 0) continue; if ((strncmp ("usb", lp, 3) == 0) && isspace (lp[3])) { DBG (15, "sane_get_devices: looking for '%s'\n", lp); sanei_usb_attach_matching_devices(lp, attach_one); } else if (!strncmp(lp, "has_cal_buffer", 14) && isspace (lp[14])) { int buf; lp += 14; lp = sanei_config_skip_whitespace (lp); buf = atoi (lp); if(buf){ global_has_cal_buffer = 1; } else{ global_has_cal_buffer = 0; } DBG (15, "sane_get_devices: setting \"has_cal_buffer\" to %d\n", global_has_cal_buffer); } else if (!strncmp(lp, "lines_per_block", 15) && isspace (lp[15])) { int buf; lp += 15; lp = sanei_config_skip_whitespace (lp); buf = atoi (lp); if(buf < 1 || buf > 32){ DBG (15, "sane_get_devices: \"lines_per_block\"=%d\n out of range", buf ); continue; } DBG (15, "sane_get_devices: \"lines_per_block\" is %d\n", buf); global_lines_per_block = buf; } else{ DBG (5, "sane_get_devices: config line \"%s\" ignored.\n", lp); } } fclose (fp); } else { DBG (5, "sane_get_devices: no config file '%s', using defaults\n", CONFIG_FILE); DBG (15, "sane_get_devices: looking for 'usb 0x08F0 0x0005'\n"); sanei_usb_attach_matching_devices("usb 0x08F0 0x0005", attach_one); } for (dev = scanner_devList; dev; dev=dev->next) { DBG (15, "sane_get_devices: found scanner %s\n",dev->device_name); num_devices++; } DBG (15, "sane_get_devices: found %d scanner(s)\n",num_devices); sane_devArray = calloc (num_devices + 1, sizeof (SANE_Device*)); if (!sane_devArray) return SANE_STATUS_NO_MEM; for (dev = scanner_devList; dev; dev=dev->next) { sane_devArray[i++] = (SANE_Device *)&dev->sane; } sane_devArray[i] = 0; *device_list = sane_devArray; DBG (10, "sane_get_devices: finish\n"); return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * piVersion, SANE_Auth_Callback pfnAuth) { FILE *conf_fp; /* Config file stream */ SANE_Char line[PATH_MAX]; SANE_Char *str = NULL; SANE_String_Const proper_str; int nline = 0; /* prevent compiler from complaing about unused parameters */ pfnAuth = pfnAuth; strcpy(usb_devfile, "/dev/usb/scanner0"); _pFirstSaneDev = 0; iNumSaneDev = 0; InitHp5400_internal(); DBG_INIT (); HP5400_DBG (DBG_MSG, "sane_init: SANE hp5400 backend version %d.%d-%d (from %s)\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING); sanei_usb_init (); conf_fp = sanei_config_open (HP5400_CONFIG_FILE); iNumSaneDev = 0; if (conf_fp) { HP5400_DBG (DBG_MSG, "Reading config file\n"); while (sanei_config_read (line, sizeof (line), conf_fp)) { ++nline; if (str) { free (str); } proper_str = sanei_config_get_string (line, &str); /* Discards white lines and comments */ if (!str || proper_str == line || str[0] == '#') { HP5400_DBG (DBG_MSG, "Discarding line %d\n", nline); } else { /* If line's not blank or a comment, then it's the device * filename or a usb directive. */ HP5400_DBG (DBG_MSG, "Trying to attach %s\n", line); sanei_usb_attach_matching_devices (line, attach_one_device); } } /* while */ fclose (conf_fp); } else { HP5400_DBG (DBG_ERR, "Unable to read config file \"%s\": %s\n", HP5400_CONFIG_FILE, strerror (errno)); HP5400_DBG (DBG_MSG, "Using default built-in values\n"); attach_one_device (usb_devfile); } if (piVersion != NULL) { *piVersion = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); } return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback __sane_unused__ authorize) { char f[] = "sane_init"; char dev_name[PATH_MAX], *p; size_t len; FILE *fp; int baud; DBG_INIT (); if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0); fp = sanei_config_open (DC210_CONFIG_FILE); /* defaults */ Camera.baud = DEFAULT_BAUD_RATE; Camera.tty_name = DEFAULT_TTY; if (!fp) { /* default to /dev/whatever instead of insisting on config file */ DBG (1, "%s: missing config file '%s'\n", f, DC210_CONFIG_FILE); } else { while (sanei_config_read (dev_name, sizeof (dev_name), fp)) { dev_name[sizeof (dev_name) - 1] = '\0'; DBG (20, "%s: config- %s\n", f, dev_name); if (dev_name[0] == '#') continue; /* ignore line comments */ len = strlen (dev_name); if (!len) continue; /* ignore empty lines */ if (strncmp (dev_name, "port=", 5) == 0) { p = strchr (dev_name, '/'); if (p) Camera.tty_name = strdup (p); DBG (20, "Config file port=%s\n", Camera.tty_name); } else if (strncmp (dev_name, "baud=", 5) == 0) { baud = atoi (&dev_name[5]); switch (baud) { case 9600: Camera.baud = B9600; break; case 19200: Camera.baud = B19200; break; case 38400: Camera.baud = B38400; break; #ifdef B57600 case 57600: Camera.baud = B57600; break; #endif #ifdef B115200 case 115200: Camera.baud = B115200; break; #endif } DBG (20, "Config file baud=%d\n", Camera.baud); } else if (strcmp (dev_name, "dumpinquiry") == 0) { dumpinquiry = SANE_TRUE; } else if (strncmp (dev_name, "cmdrespause=", 12) == 0) { cmdrespause = atoi (&dev_name[12]); DBG (20, "Config file cmdrespause=%lu\n", cmdrespause); } else if (strncmp (dev_name, "breakpause=", 11) == 0) { breakpause = atoi (&dev_name[11]); DBG (20, "Config file breakpause=%lu\n", breakpause); } } fclose (fp); } if (init_dc210 (&Camera) == -1) return SANE_STATUS_INVAL; if (get_info (&Camera) == -1) { DBG (2, "error: could not get info\n"); close_dc210 (Camera.fd); return SANE_STATUS_INVAL; } if (Camera.pic_taken == 0) { sod[DC210_OPT_IMAGE_NUMBER].cap |= SANE_CAP_INACTIVE; image_range.min = 0; image_range.max = 0; } else { sod[DC210_OPT_IMAGE_NUMBER].cap &= ~SANE_CAP_INACTIVE; image_range.min = 1; image_range.max = Camera.pic_taken; } /* load the current images array */ Camera.Pictures = get_pictures_info (); if (Camera.pic_taken == 0) { Camera.current_picture_number = 0; parms.bytes_per_line = 0; parms.pixels_per_line = 0; parms.lines = 0; } else { Camera.current_picture_number = 1; if (Camera.Pictures[Camera.current_picture_number - 1].low_res) { parms.bytes_per_line = 640 * 3; parms.pixels_per_line = 640; parms.lines = 480; } else { parms.bytes_per_line = 1152 * 3; parms.pixels_per_line = 1152; parms.lines = 864; } } if (dumpinquiry) { DBG (0, "\nCamera information:\n~~~~~~~~~~~~~~~~~\n\n"); DBG (0, "Model...........: DC%x\n", Camera.model); DBG (0, "Firmware version: %d.%d\n", Camera.ver_major, Camera.ver_minor); DBG (0, "Pictures........: %d/%d\n", Camera.pic_taken, Camera.pic_taken + Camera.pic_left); DBG (0, "Resolution......: %s\n", Camera.flags.low_res ? "low" : "high"); DBG (0, "Battery state...: %s\n", Camera.flags.low_batt ? "low" : "good"); } return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { SANE_Char line[PATH_MAX]; SANE_Char *word, *end; SANE_String_Const cp; SANE_Int linenumber; FILE *fp; DBG_INIT (); DBG (2, "SANE Mustek USB backend version %d.%d build %d from %s\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING); if (version_code) *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); DBG (5, "sane_init: authorize %s null\n", authorize ? "!=" : "=="); num_devices = 0; first_dev = 0; first_handle = 0; devlist = 0; new_dev = 0; new_dev_len = 0; new_dev_alloced = 0; sanei_usb_init (); fp = sanei_config_open (MUSTEK_USB_CONFIG_FILE); if (!fp) { /* default to /dev/usb/scanner instead of insisting on config file */ DBG (3, "sane_init: couldn't open config file `%s': %s. Using " "/dev/usb/scanner directly\n", MUSTEK_USB_CONFIG_FILE, strerror (errno)); attach ("/dev/usb/scanner", 0, SANE_FALSE); return SANE_STATUS_GOOD; } linenumber = 0; DBG (4, "sane_init: reading config file `%s'\n", MUSTEK_USB_CONFIG_FILE); while (sanei_config_read (line, sizeof (line), fp)) { word = 0; linenumber++; cp = sanei_config_get_string (line, &word); if (!word || cp == line) { DBG (5, "sane_init: config file line %d: ignoring empty line\n", linenumber); if (word) free (word); continue; } if (word[0] == '#') { DBG (5, "sane_init: config file line %d: ignoring comment line\n", linenumber); free (word); continue; } if (strcmp (word, "option") == 0) { free (word); word = 0; cp = sanei_config_get_string (cp, &word); if (!word) { DBG (1, "sane_init: config file line %d: missing quotation mark?\n", linenumber); continue; } if (strcmp (word, "max_block_size") == 0) { free (word); word = 0; cp = sanei_config_get_string (cp, &word); if (!word) { DBG (1, "sane_init: config file line %d: missing quotation mark?\n", linenumber); continue; } errno = 0; max_block_size = strtol (word, &end, 0); if (end == word) { DBG (3, "sane-init: config file line %d: max_block_size " "must have a parameter; using 8192 bytes\n", linenumber); max_block_size = 8192; } if (errno) { DBG (3, "sane-init: config file line %d: max_block_size `%s' " "is invalid (%s); using 8192 bytes\n", linenumber, word, strerror (errno)); max_block_size = 8192; } else { DBG (3, "sane_init: config file line %d: max_block_size set " "to %d bytes\n", linenumber, max_block_size); } if (word) free (word); word = 0; } else if (strcmp (word, "1200ub") == 0) { if (new_dev_len > 0) { /* this is a 1200 UB */ new_dev[new_dev_len - 1]->chip->scanner_type = MT_1200UB; new_dev[new_dev_len - 1]->sane.model = "1200 UB"; DBG (3, "sane_init: config file line %d: `%s' is a Mustek " "1200 UB\n", linenumber, new_dev[new_dev_len - 1]->sane.name); } else { DBG (3, "sane_init: config file line %d: option " "1200ub ignored, was set before any device " "name\n", linenumber); } if (word) free (word); word = 0; } else if (strcmp (word, "1200cu") == 0) { if (new_dev_len > 0) { /* this is a 1200 CU */ new_dev[new_dev_len - 1]->chip->scanner_type = MT_1200CU; new_dev[new_dev_len - 1]->sane.model = "1200 CU"; DBG (3, "sane_init: config file line %d: `%s' is a Mustek " "1200 CU\n", linenumber, new_dev[new_dev_len - 1]->sane.name); } else { DBG (3, "sane_init: config file line %d: option " "1200cu ignored, was set before any device " "name\n", linenumber); } if (word) free (word); word = 0; } else if (strcmp (word, "1200cu_plus") == 0) { if (new_dev_len > 0) { /* this is a 1200 CU Plus */ new_dev[new_dev_len - 1]->chip->scanner_type = MT_1200CU_PLUS; new_dev[new_dev_len - 1]->sane.model = "1200 CU Plus"; DBG (3, "sane_init: config file line %d: `%s' is a Mustek " "1200 CU Plus\n", linenumber, new_dev[new_dev_len - 1]->sane.name); } else { DBG (3, "sane_init: config file line %d: option " "1200cu_plus ignored, was set before any device " "name\n", linenumber); } if (word) free (word); word = 0; } else if (strcmp (word, "600cu") == 0) { if (new_dev_len > 0) { /* this is a 600 CU */ new_dev[new_dev_len - 1]->chip->scanner_type = MT_600CU; new_dev[new_dev_len - 1]->sane.model = "600 CU"; DBG (3, "sane_init: config file line %d: `%s' is a Mustek " "600 CU\n", linenumber, new_dev[new_dev_len - 1]->sane.name); } else { DBG (3, "sane_init: config file line %d: option " "600cu ignored, was set before any device " "name\n", linenumber); } if (word) free (word); word = 0; } else { DBG (3, "sane_init: config file line %d: option " "%s is unknown\n", linenumber, word); if (word) free (word); word = 0; } } else { new_dev_len = 0; DBG (4, "sane_init: config file line %d: trying to attach `%s'\n", linenumber, line); sanei_usb_attach_matching_devices (line, attach_one_device); if (word) free (word); word = 0; } } if (new_dev_alloced > 0) { new_dev_len = new_dev_alloced = 0; free (new_dev); } fclose (fp); DBG (5, "sane_init: exit\n"); return SANE_STATUS_GOOD; }
SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { char backend_name[PATH_MAX]; size_t len; FILE *fp; int i; DBG_INIT(); auth_callback = authorize; DBG(1, "sane_init: SANE dll backend version %s from %s\n", DLL_VERSION, PACKAGE_VERSION); /* chain preloaded backends together: */ for (i = 0; i < NELEMS(preloaded_backends); ++i) { if (!preloaded_backends[i].name) continue; preloaded_backends[i].next = first_backend; first_backend = &preloaded_backends[i]; } /* Return the version number of the sane-backends package to allow the frontend to print them. This is done only for net and dll, because these backends are usually called by the frontend. */ if (version_code) *version_code = SANE_VERSION_CODE (SANE_DLL_V_MAJOR, SANE_DLL_V_MINOR, SANE_DLL_V_BUILD); fp = sanei_config_open (DLL_CONFIG_FILE); if (!fp) { DBG(1, "sane_init: Couldn't open config file (%s): %s\n", DLL_CONFIG_FILE, strerror (errno)); return SANE_STATUS_GOOD; /* don't insist on config file */ } while (sanei_config_read (backend_name, sizeof (backend_name), fp)) { if (backend_name[0] == '#') /* ignore line comments */ continue; len = strlen (backend_name); if (!len) continue; /* ignore empty lines */ add_backend (backend_name, 0); } fclose (fp); fp = sanei_config_open (DLL_ALIASES_FILE); if (!fp) return SANE_STATUS_GOOD; /* don't insist on aliases file */ while (sanei_config_read (backend_name, sizeof (backend_name), fp)) { if (backend_name[0] == '#') /* ignore line comments */ continue; len = strlen (backend_name); if (!len) continue; /* ignore empty lines */ add_alias (backend_name); } fclose (fp); return SANE_STATUS_GOOD; }
SANE_Status sanei_configure_attach (const char *config_file, SANEI_Config * config, SANE_Status (*attach) (SANEI_Config * config, const char *devname)) { SANE_Char line[PATH_MAX]; SANE_Char *token, *string; SANE_Int len; const char *lp, *lp2; FILE *fp; SANE_Status status = SANE_STATUS_GOOD; int i, j, count; void *value = NULL; int size=0; SANE_Bool found; SANE_Word *wa; SANE_Bool *ba; DBG (3, "sanei_configure_attach: start\n"); /* open configuration file */ fp = sanei_config_open (config_file); if (!fp) { DBG (2, "sanei_configure_attach: couldn't access %s\n", config_file); DBG (3, "sanei_configure_attach: exit\n"); return SANE_STATUS_ACCESS_DENIED; } /* loop reading the configuration file, all line beginning by "option " are * parsed for value to store in configuration structure, other line are * used are device to try to attach */ while (sanei_config_read (line, PATH_MAX, fp) && status == SANE_STATUS_GOOD) { /* skip white spaces at beginning of line */ lp = sanei_config_skip_whitespace (line); /* skip empty lines */ if (*lp == 0) continue; /* skip comment line */ if (line[0] == '#') continue; len = strlen (line); /* delete newline characters at end */ if (line[len - 1] == '\n') line[--len] = '\0'; lp2 = lp; /* to ensure maximum compatibility, we accept line like: * option "option_name" "option_value" * "option_name" "option_value" * So we parse the line 2 time to find an option */ /* check if it is an option */ lp = sanei_config_get_string (lp, &token); if (strncmp (token, "option", 6) == 0) { /* skip the "option" token */ free (token); lp = sanei_config_get_string (lp, &token); } /* search for a matching descriptor */ i = 0; found = SANE_FALSE; while (config!=NULL && i < config->count && !found) { if (strcmp (config->descriptors[i]->name, token) == 0) { found = SANE_TRUE; switch (config->descriptors[i]->type) { case SANE_TYPE_INT: size=config->descriptors[i]->size; value = malloc (size); wa = (SANE_Word *) value; count = config->descriptors[i]->size / sizeof (SANE_Word); for (j = 0; j < count; j++) { lp = sanei_config_get_string (lp, &string); if (string == NULL) { DBG (2, "sanei_configure_attach: couldn't find a string to parse"); return SANE_STATUS_INVAL; } wa[j] = strtol (string, NULL, 0); free (string); } break; case SANE_TYPE_BOOL: size=config->descriptors[i]->size; value = malloc (size); ba = (SANE_Bool *) value; count = config->descriptors[i]->size / sizeof (SANE_Bool); for (j = 0; j < count; j++) { lp = sanei_config_get_string (lp, &string); if (string == NULL) { DBG (2, "sanei_configure_attach: couldn't find a string to parse"); return SANE_STATUS_INVAL; } if ((strcmp (string, "1") == 0) || (strcmp (string, "true") == 0)) { ba[j] = SANE_TRUE; } else { if ((strcmp (string, "0") == 0) || (strcmp (string, "false") == 0)) ba[j] = SANE_FALSE; else { DBG (2, "sanei_configure_attach: couldn't find a valid boolean value"); return SANE_STATUS_INVAL; } } free (string); } break; case SANE_TYPE_FIXED: size=config->descriptors[i]->size; value = malloc (size); wa = (SANE_Word *) value; count = config->descriptors[i]->size / sizeof (SANE_Word); for (j = 0; j < count; j++) { lp = sanei_config_get_string (lp, &string); if (string == NULL) { DBG (2, "sanei_configure_attach: couldn't find a string to parse"); return SANE_STATUS_INVAL; } wa[j] = SANE_FIX(strtod (string, NULL)); free (string); } break; case SANE_TYPE_STRING: sanei_config_get_string (lp, &string); if (string == NULL) { DBG (2, "sanei_configure_attach: couldn't find a string value to parse"); return SANE_STATUS_INVAL; } value = string; size=strlen(string)+1; if(size>config->descriptors[i]->size) { size=config->descriptors[i]->size-1; string[size]=0; } break; default: DBG (1, "sanei_configure_attach: incorrect type %d for option %s, skipping option ...\n", config->descriptors[i]->type, config->descriptors[i]->name); } /* check decoded value */ status = sanei_check_value (config->descriptors[i], value); /* if value OK, copy it in configuration struct */ if (status == SANE_STATUS_GOOD) { memcpy (config->values[i], value, size); } if (value != NULL) { free (value); value = NULL; } } if (status != SANE_STATUS_GOOD) { DBG (1, "sanei_configure_attach: failed to parse option '%s', line '%s'\n", token, line); } i++; } free (token); /* not detected as an option, so we call the attach function * with it */ if (!found && status == SANE_STATUS_GOOD) { /* if not an option, try to attach */ /* to avoid every backend to depend on scsi and usb functions * we call back the backend for attach. In turn it will call * sanei_usb_attach_matching_devices, sanei_config_attach_matching_devices * or other. This means 2 callback functions per backend using this * function. */ DBG (3, "sanei_configure_attach: trying to attach with '%s'\n", lp2); if(attach!=NULL) attach (config, lp2); } } fclose (fp); DBG (3, "sanei_configure_attach: exit\n"); return status; }
SANE_Status sanei_authorize (const char *resource, const char *backend, SANE_Auth_Callback authorize) { FILE *passwd_file; char passwd_filename[256]; char line[1024], *linep; SANE_Bool entry_found = SANE_FALSE; char md5resource[256]; char username[SANE_MAX_USERNAME_LEN]; char password[SANE_MAX_PASSWORD_LEN]; INIT_RND (); DBG (4, "called for ``%s'' by %s\n", resource, backend); if (strlen (resource) > 127) DBG (1, "resource is longer than 127 chars...\n"); sprintf (passwd_filename, "%s.users", backend); passwd_file = sanei_config_open (passwd_filename); if (passwd_file == NULL) { DBG (3, "could not open ``%s''...\n", passwd_filename); return SANE_STATUS_GOOD; } while (sanei_config_read (line, 1024, passwd_file)) { if ((strlen (line) > 0) && (line[strlen (line) - 1] == '\n')) line[strlen (line) - 1] = '\n'; if ((strlen (line) > 0) && (line[strlen (line) - 1] == '\r')) line[strlen (line) - 1] = '\r'; if (strchr (line, ':') != NULL) { if (strchr (strchr (line, ':') + 1, ':') != NULL) { if (strcmp (strchr (strchr (line, ':') + 1, ':') + 1, resource) == 0) { entry_found = SANE_TRUE; break; } } } } if (entry_found == SANE_FALSE) { fclose (passwd_file); DBG (3, "could not find resource ``%s''...\n", resource); return SANE_STATUS_GOOD; } if (authorize == NULL) { DBG (2, "no authorization callback supplied by frontend\n"); return SANE_STATUS_ACCESS_DENIED; } sprintf (md5resource, "%.128s$MD5$%x%lx%08lx", resource, getpid (), time (NULL), randombits ()); memset (username, 0, SANE_MAX_USERNAME_LEN); memset (password, 0, SANE_MAX_PASSWORD_LEN); (*authorize) (md5resource, username, password); fseek (passwd_file, 0L, SEEK_SET); while (sanei_config_read (line, 1024, passwd_file)) { if ((strlen (line) > 0) && (line[strlen (line) - 1] == '\n')) line[strlen (line) - 1] = '\n'; if ((strlen (line) > 0) && (line[strlen (line) - 1] == '\r')) line[strlen (line) - 1] = '\r'; if ((strncmp (line, username, strlen (username)) == 0) && (((strchr (line, ':')) - line) == (signed) strlen (username))) { linep = strchr (line, ':') + 1; if ((strchr (linep, ':') != NULL) && (strcmp (strchr (linep, ':') + 1, resource) == 0)) { *(strchr (linep, ':')) = 0; if (check_passwd (password, linep, md5resource, username)) { fclose (passwd_file); DBG (2, "authorization succeeded\n"); return SANE_STATUS_GOOD; } } } } fclose (passwd_file); DBG (1, "authorization failed\n"); return SANE_STATUS_ACCESS_DENIED; }