int serialConnectDevice (SerialDevice *serial, const char *device) { if ((serial->fileDescriptor = open(device, O_RDWR|O_NOCTTY|O_NONBLOCK)) != -1) { serial->package.deviceIndex = -1; { char *truePath; if ((truePath = _truename(device, NULL))) { char *com; { char *c = truePath; while (*c) { *c = toupper(*c); c += 1; } } if ((com = strstr(truePath, "COM"))) { serial->package.deviceIndex = atoi(com+3) - 1; } free(truePath); } } if (serial->package.deviceIndex >= 0) { if (serialPrepareDevice(serial)) { logMessage(LOG_CATEGORY(SERIAL_IO), "device opened: %s: fd=%d", device, serial->fileDescriptor); return 1; } } else { logMessage(LOG_ERR, "could not determine serial device number: %s", device); } close(serial->fileDescriptor); } else { logMessage(LOG_ERR, "cannot open serial device: %s: %s", device, strerror(errno)); } return 0; }
/** * canonpath: make canonical path name. * * @param[in,out] path path * @return path * * @attention canonpath() rewrite argument buffer. */ char * canonpath(char *path) { #ifdef __DJGPP__ char *p; if (_USE_LFN) { char name[260], sfn[13]; char *base; /* * Ensure we're using a complete long name, not a mixture * of long and short. */ _truename(path, path); /* * _truename will successfully convert the path of a non- * existant file, but it's probably still a mixture of long and * short components - convert the path separately. */ if (access(path, F_OK) != 0) { base = basename(path); strcpy(name, base); *base = '\0'; _truename(path, path); strcat(path, name); } /* * Convert the case of 8.3 names, as other djgpp functions do. */ if (!_preserve_fncase()) { for (p = path+3, base = p-1; *base; p++) { if (*p == '\\' || *p == '\0') { memcpy(name, base+1, p-base-1); name[p-base-1] = '\0'; if (!strcmp(_lfn_gen_short_fname(name, sfn), name)) { while (++base < p) if (*base >= 'A' && *base <= 'Z') *base += 'a' - 'A'; } else base = p; } } } } /* * Lowercase the drive letter and convert to slashes. */ path[0] = tolower(path[0]); for (p = path+2; *p; ++p) if (*p == '\\') *p = '/'; #else #ifdef _WIN32 char *p, *s; p = path; /* * Change \ to / in a path (for DOS/Windows paths) */ while ((p = strchr(p, '\\')) != NULL) *p = '/'; #ifdef __CYGWIN__ /* * On NT with CYGWIN, getcwd can return something like * "//c/tmp", which isn't usable. We change that to "c:/tmp". */ p = path; if (p[0] == '/' && p[1] == '/' && isdrivechar(p[2]) && p[3] == '/') { s = &p[2]; /* point drive char */ *p++ = *s++; *p++ = ':'; while (*p++ = *s++) ; } #endif /* __CYGWIN__ */ #endif /* _WIN32 */ #endif /* __DJGPP__ */ return path; }
void kpse_set_program_name P2C(const_string, argv0, const_string, progname) { string ext, sdir, sdir_parent, sdir_grandparent; string s = getenv ("KPATHSEA_DEBUG"); #ifdef WIN32 string debug_output = getenv("KPATHSEA_DEBUG_OUTPUT"); string append_debug_output = getenv("KPATHSEA_DEBUG_APPEND"); int err, olderr; #endif /* Set debugging stuff first, in case we end up doing debuggable stuff during this initialization. */ if (s) { kpathsea_debug |= atoi (s); } #ifndef HAVE_PROGRAM_INVOCATION_NAME #if defined(WIN32) /* Set various info about user. Among many things, ensure that HOME is set. If debug_paths is on, turn on some message if $HOME is not found. */ if (KPSE_DEBUG_P(KPSE_DEBUG_PATHS)) { set_home_warning(); } init_user_info(); /* redirect stderr to debug_output. Easier to send logfiles. */ if (debug_output) { int flags = _O_CREAT | _O_TRUNC | _O_RDWR; err = -1; if (_stricmp(debug_output, "con") == 0 || _stricmp(debug_output, "con:") == 0) { err = _fileno(stdout); } else { if (append_debug_output) { flags = _O_CREAT | _O_APPEND | _O_WRONLY; } else { flags = _O_CREAT | _O_TRUNC | _O_WRONLY; xputenv("KPATHSEA_DEBUG_APPEND", "yes"); } } if ((err < 0) && (err = _open(debug_output, flags, _S_IREAD | _S_IWRITE)) == -1) { WARNING1("Can't open %s for stderr redirection!\n", debug_output); perror(debug_output); } else if ((olderr = _dup(fileno(stderr))) == -1) { WARNING("Can't dup() stderr!\n"); close(err); } else if (_dup2(err, fileno(stderr)) == -1) { WARNING1("Can't redirect stderr to %s!\n", debug_output); close(olderr); close(err); } else { close(err); } } /* Win95 always gives the short filename for argv0, not the long one. There is only this way to catch it. It makes all the selfdir stuff useless for win32. */ { char short_path[PATH_MAX], path[PATH_MAX], *fp; /* SearchPath() always gives back an absolute directory */ if (SearchPath(NULL, argv0, ".exe", PATH_MAX, short_path, &fp) == 0) FATAL1("Can't determine where the executable %s is.\n", argv0); if (!win32_get_long_filename(short_path, path, sizeof(path))) { FATAL1("This path points to an invalid file : %s\n", short_path); } /* slashify the dirname */ for (fp = path; fp && *fp; fp++) if (IS_DIR_SEP(*fp)) *fp = DIR_SEP; /* sdir will be the directory of the executable, ie: c:/TeX/bin */ sdir = xdirname(path); program_invocation_name = xstrdup(xbasename(path)); } #elif defined(__DJGPP__) /* DJGPP programs support long filenames on Windows 95, but ARGV0 there is always made with the short 8+3 aliases of all the pathname elements. If long names are supported, we need to convert that to a long name. All we really need is to call `_truename', but most of the code below is required to deal with the special case of networked drives. */ if (pathconf (argv0, _PC_NAME_MAX) > 12) { char long_progname[PATH_MAX]; if (_truename (argv0, long_progname)) { char *fp; if (long_progname[1] != ':') { /* A complication: `_truename' returns network-specific string at the beginning of `long_progname' when the program resides on a networked drive, and DOS calls cannot grok such pathnames. We need to convert the filesystem name back to a drive letter. */ char rootname[PATH_MAX], rootdir[4]; if (argv0[0] && argv0[1] == ':') rootdir[0] = argv0[0]; /* explicit drive in `argv0' */ else rootdir[0] = getdisk () + 'A'; rootdir[1] = ':'; rootdir[2] = '\\'; rootdir[3] = '\0'; if (_truename (rootdir, rootname)) { /* Find out where `rootname' ends in `long_progname' and replace it with the drive letter. */ int root_len = strlen (rootname); if (IS_DIR_SEP (rootname[root_len - 1])) root_len--; /* keep the trailing slash */ long_progname[0] = rootdir[0]; long_progname[1] = ':'; memmove (long_progname + 2, long_progname + root_len, strlen (long_progname + root_len) + 1); } } /* Convert everything to canonical form. */ if (long_progname[0] >= 'A' && long_progname[0] <= 'Z') long_progname[0] += 'a' - 'A'; /* make drive lower case, for beauty */ for (fp = long_progname; *fp; fp++) if (IS_DIR_SEP (*fp)) *fp = DIR_SEP; program_invocation_name = xstrdup (long_progname); } else /* If `_truename' failed, God help them, because we won't... */ program_invocation_name = xstrdup (argv0); } else program_invocation_name = xstrdup (argv0); #else /* !WIN32 && !__DJGPP__ */ program_invocation_name = xstrdup (argv0); #endif #endif /* not HAVE_PROGRAM_INVOCATION_NAME */ /* We need to find SELFAUTOLOC *before* removing the ".exe" suffix from the program_name, otherwise the PATH search inside selfdir will fail, since `prog' doesn't exists as a file, there's `prog.exe' instead. */ #ifndef WIN32 sdir = selfdir (program_invocation_name); #endif /* SELFAUTODIR is actually the parent of the invocation directory, and SELFAUTOPARENT the grandparent. This is how teTeX did it. */ xputenv ("SELFAUTOLOC", sdir); sdir_parent = xdirname (sdir); xputenv ("SELFAUTODIR", sdir_parent); sdir_grandparent = xdirname (sdir_parent); xputenv ("SELFAUTOPARENT", sdir_grandparent); free (sdir); free (sdir_parent); free (sdir_grandparent); #ifndef HAVE_PROGRAM_INVOCATION_NAME program_invocation_short_name = (string)xbasename (program_invocation_name); #endif if (progname) { kpse_program_name = xstrdup (progname); } else { /* If configured --enable-shared and running from the build directory with the wrapper scripts (e.g., for make check), the binaries will be named foo.exe instead of foo. Or possibly if we're running on a DOSISH system. */ ext = find_suffix (program_invocation_short_name); if (ext && FILESTRCASEEQ (ext, "exe")) { kpse_program_name = remove_suffix (program_invocation_short_name); } else { kpse_program_name = xstrdup (program_invocation_short_name); } } xputenv("progname", kpse_program_name); }