size_t UserPatcher::mapAddresses(const char *mapBuf, MapEntry *mapEntries, size_t nentries) { if (nentries == 0 || !mapBuf) return 0; size_t nfound = 0; const char *ptr = mapBuf; while (*ptr) { size_t i = 1; if (*ptr == '\n') { MapEntry *currEntry = nullptr; for (size_t j = 0; j < nentries; j++) { if (!mapEntries[j].filename) continue; if (!strncmp(&ptr[i], mapEntries[j].filename, mapEntries[j].length)) { currEntry = &mapEntries[j]; i += mapEntries[j].length; break; } } if (currEntry) { const char *text = strstr(&ptr[i], "__TEXT", strlen("__TEXT")); if (text) { i += strlen("__TEXT"); const char *arrow = strstr(&ptr[i], "->", strlen("->")); if (arrow) { currEntry->startTEXT = strtouq(text + strlen("__TEXT") + 1, nullptr, 16); currEntry->endTEXT = strtouq(arrow + strlen("->") + 1, nullptr, 16); const char *data = strstr(&ptr[i], "__DATA", strlen("__DATA")); if (data) { i += strlen("__DATA"); arrow = strstr(&ptr[i], "->", strlen("->")); if (arrow) { currEntry->startDATA = strtouq(data + strlen("__DATA") + 1, nullptr, 16); currEntry->endDATA = strtouq(arrow + strlen("->") + 1, nullptr, 16); } } nfound++; } } } } ptr += i; } return nfound; }
static int vfs_getrealpath(const char * path, char * realpath, size_t bufsize, vfs_context_t ctx) { vnode_t vp; struct mount *mp = NULL; char *str; char ch; uint32_t id; ino64_t ino; int error; int length; /* Get file system id and move str to next component. */ id = strtoul(path, &str, 10); if (id == 0 || str[0] != '/') { return (EINVAL); } while (*str == '/') { str++; } ch = *str; mp = mount_lookupby_volfsid(id, 1); if (mp == NULL) { return (EINVAL); /* unexpected failure */ } /* Check for an alias to a file system root. */ if (ch == '@' && str[1] == '\0') { ino = 2; str++; } else { /* Get file id and move str to next component. */ ino = strtouq(str, &str, 10); } /* Get the target vnode. */ if (ino == 2) { error = VFS_ROOT(mp, &vp, ctx); } else { error = VFS_VGET(mp, ino, &vp, ctx); } vfs_unbusy(mp); if (error) { goto out; } realpath[0] = '\0'; /* Get the absolute path to this vnode. */ error = build_path(vp, realpath, bufsize, &length, 0, ctx); vnode_put(vp); if (error == 0 && *str != '\0') { int attempt = strlcat(realpath, str, MAXPATHLEN); if (attempt > MAXPATHLEN){ error = ENAMETOOLONG; } } out: return (error); }
Bool StrUtil_StrToSizet(size_t *out, // OUT: The output value const char *str) // IN : String to parse { char *ptr; ASSERT(out); ASSERT(str); errno = 0; #if defined VM_X86_64 ASSERT_ON_COMPILE(sizeof *out == sizeof(uint64)); # if defined(_WIN32) *out = _strtoui64(str, &ptr, 0); # elif defined(__FreeBSD__) *out = strtouq(str, &ptr, 0); # else *out = strtoull(str, &ptr, 0); # endif #else ASSERT_ON_COMPILE(sizeof *out == sizeof(uint32)); *out = strtoul(str, &ptr, 0); #endif return *ptr == '\0' && errno != ERANGE; }
/* * Convert a string to an unsigned quad integer. */ uint64_t __wt_strtouq(const char *nptr, char **endptr, int base) { #if defined(HAVE_STRTOUQ) return (strtouq(nptr, endptr, base)); #else STATIC_ASSERT(sizeof(uint64_t) == sizeof(unsigned long long)); return (strtoull(nptr, endptr, base)); #endif }
/** * eva_strtoull: * @str: the string to parse a longlong unsigned integer (guint64) from. * @endp: optional place to store the character right past * the number in @str. If *endp == @str, then you may assume an error * occurred. * @base: the assumed base for the number to parse. eg "2" to * parse a binary, "8" for octal, "10" for decimal, "16" for hexidecimal. * Also, "0" is autodetects the C-style base. * * Like strtol, but for 64-bit unsigned integers. * * returns: the parsed unsigned integer. */ guint64 eva_strtoull (const char *str, char **endp, int base) { #if HAVE_STRTOUQ return strtouq (str, endp, base); #elif HAVE_STRTOULL return strtoull (str, endp, base); #else return strtoul (str, endp, base); #endif }
/* * Convert string after @@ (@@ not included) to TID. Returns 0 on success, * EINVAL on failure. * * If this function fails *ispfs, *tidp, and *localizationp will not * be modified. */ int hammer_str_to_tid(const char *str, int *ispfsp, hammer_tid_t *tidp, u_int32_t *localizationp) { hammer_tid_t tid; u_int32_t localization; char *ptr; int ispfs; int n; /* * Forms allowed for TID: "0x%016llx" * "-1" */ tid = strtouq(str, &ptr, 0); n = ptr - str; if (n == 2 && str[0] == '-' && str[1] == '1') { /* ok */ } else if (n == 18 && str[0] == '0' && (str[1] | 0x20) == 'x') { /* ok */ } else { return(EINVAL); } /* * Forms allowed for PFS: ":%05d" (i.e. "...:0" would be illegal). */ str = ptr; if (*str == ':') { localization = strtoul(str + 1, &ptr, 10) << 16; if (ptr - str != 6) return(EINVAL); str = ptr; ispfs = 1; } else { localization = *localizationp; ispfs = 0; } /* * Any trailing junk invalidates special extension handling. */ if (*str) return(EINVAL); *tidp = tid; *localizationp = localization; *ispfsp = ispfs; return(0); }
/* * Convert an expression of the following forms to a uintmax_t. * 1) A positive decimal number. * 2) A positive decimal number followed by a 'b' or 'B' (mult by 512). * 3) A positive decimal number followed by a 'k' or 'K' (mult by 1 << 10). * 4) A positive decimal number followed by a 'm' or 'M' (mult by 1 << 20). * 5) A positive decimal number followed by a 'g' or 'G' (mult by 1 << 30). * 5) A positive decimal number followed by a 'w' or 'W' (mult by sizeof int). * 6) Two or more positive decimal numbers (with/without [BbKkMmGgWw]) * separated by 'x' or 'X' (also '*' for backwards compatibility), * specifying the product of the indicated values. */ static uintmax_t get_num(const char *val) { uintmax_t num, mult, prevnum; char *expr; errno = 0; num = strtouq(val, &expr, 0); if (errno != 0) /* Overflow or underflow. */ err(1, "%s", oper); if (expr == val) /* No valid digits. */ errx(1, "%s: illegal numeric value", oper); mult = postfix_to_mult(*expr); if (mult != 0) { prevnum = num; num *= mult; /* Check for overflow. */ if (num / mult != prevnum) goto erange; expr++; } switch (*expr) { case '\0': break; case '*': /* Backward compatible. */ case 'X': case 'x': mult = get_num(expr + 1); prevnum = num; num *= mult; if (num / mult == prevnum) break; erange: errx(1, "%s: %s", oper, strerror(ERANGE)); default: errx(1, "%s: illegal numeric value", oper); } return (num); }
Bool StrUtil_StrToUint64(uint64 *out, // OUT: The output value const char *str) // IN : String to parse { char *ptr; ASSERT(out); ASSERT(str); errno = 0; #if defined(_WIN32) *out = _strtoui64(str, &ptr, 0); #elif defined(__FreeBSD__) *out = strtouq(str, &ptr, 0); #else *out = strtoull(str, &ptr, 0); #endif return ptr[0] == '\0' && errno != ERANGE && errno != EINVAL; }
inline ir_code s_strtocode(char *val) { ir_code code=0; char *endptr; errno=0; # ifdef LONG_IR_CODE code=strtouq(val,&endptr,0); if((code==(unsigned long long) -1 && errno==ERANGE) || strlen(endptr)!=0 || strlen(val)==0) { logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"\"%s\": must be a valid (unsigned long " "long) number",val); parse_error=1; return(0); } # else code=strtoul(val,&endptr,0); if(code==ULONG_MAX && errno==ERANGE) { logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"code is out of range"); logprintf(LOG_ERR,"try compiling lircd with the LONG_IR_CODE " "option"); parse_error=1; return(0); } else if(strlen(endptr)!=0 || strlen(val)==0) { logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"\"%s\": must be a valid (unsigned long) " "number",val); parse_error=1; return(0); } # endif return(code); }
/* * str2recno -- * Convert a string to a record number. */ static int str2recno(WT_SESSION_IMPL *session, const char *p, uint64_t *recnop) { uint64_t recno; char *endptr; /* * strtouq takes lots of things like hex values, signs and so on and so * forth -- none of them are OK with us. Check the string starts with * digit, that turns off the special processing. */ if (!isdigit(p[0])) goto format; errno = 0; recno = strtouq(p, &endptr, 0); if (recno == ULLONG_MAX && errno == ERANGE) WT_RET_MSG(session, ERANGE, "%s: invalid record number", p); if (endptr[0] != '\0') format: WT_RET_MSG(session, EINVAL, "%s: invalid record number", p); *recnop = recno; return (0); }
/* * Parse a name into a MIB entry. * Lookup and print out the MIB entry if it exists. * Set a new value if requested. */ static void parse(const char *string) { size_t len; int i, j; void *newval = NULL; int intval; unsigned int uintval; long longval; unsigned long ulongval; size_t newsize = 0; quad_t quadval; u_quad_t uquadval; int mib[CTL_MAXNAME]; char *cp, fmt[BUFSIZ]; const char *name; char *name_allocated = NULL; u_int kind; if ((cp = strchr(string, '=')) != NULL) { if ((name_allocated = malloc(cp - string + 1)) == NULL) err(1, "malloc failed"); strlcpy(name_allocated, string, cp - string + 1); name = name_allocated; while (isspace(*++cp)) ; newval = cp; newsize = strlen(cp); } else { name = string; } len = CTL_MAXNAME; if (sysctlnametomib(name, mib, &len) < 0) { if (errno == ENOENT) { errx(1, "unknown oid '%s'", name); } else { err(1, "sysctlnametomib(\"%s\")", name); } } if (oidfmt(mib, len, fmt, &kind)) err(1, "couldn't find format of oid '%s'", name); if (newval == NULL) { if ((kind & CTLTYPE) == CTLTYPE_NODE) { sysctl_all(mib, len); } else { i = show_var(mib, len); if (!i && !bflag) putchar('\n'); } } else { if ((kind & CTLTYPE) == CTLTYPE_NODE) errx(1, "oid '%s' isn't a leaf node", name); if (!(kind&CTLFLAG_WR)) errx(1, "oid '%s' is read only", name); switch (kind & CTLTYPE) { case CTLTYPE_INT: if (!(strcmp(fmt, "IK") == 0)) { if (!set_IK(newval, &intval)) errx(1, "invalid value '%s'", (char *)newval); } else intval = (int) strtol(newval, NULL, 0); newval = &intval; newsize = sizeof(intval); break; case CTLTYPE_UINT: uintval = (int) strtoul(newval, NULL, 0); newval = &uintval; newsize = sizeof uintval; break; case CTLTYPE_LONG: longval = strtol(newval, NULL, 0); newval = &longval; newsize = sizeof longval; break; case CTLTYPE_ULONG: ulongval = strtoul(newval, NULL, 0); newval = &ulongval; newsize = sizeof ulongval; break; case CTLTYPE_STRING: break; case CTLTYPE_QUAD: quadval = strtoq(newval, NULL, 0); newval = &quadval; newsize = sizeof(quadval); break; case CTLTYPE_UQUAD: uquadval = strtouq(newval, NULL, 0); newval = &uquadval; newsize = sizeof(uquadval); break; case CTLTYPE_OPAQUE: if (strcmp(fmt, "T,dev_t") == 0 || strcmp(fmt, "T,udev_t") == 0 ) { set_T_dev_t((char*)newval, &newval, &newsize); break; } /* FALLTHROUGH */ default: errx(1, "oid '%s' is type %d," " cannot set that", name, kind & CTLTYPE); } i = show_var(mib, len); if (sysctl(mib, len, 0, 0, newval, newsize) == -1) { if (!i && !bflag) putchar('\n'); switch (errno) { case EOPNOTSUPP: errx(1, "%s: value is not available", string); case ENOTDIR: errx(1, "%s: specification is incomplete", string); case ENOMEM: errx(1, "%s: type is unknown to this program", string); default: warn("%s", string); return; } } if (!bflag) printf(" -> "); i = nflag; nflag = 1; j = show_var(mib, len); if (!j && !bflag) putchar('\n'); nflag = i; } if (name_allocated != NULL) free(name_allocated); }
int vsscanf(const char *inp, char const *fmt0, va_list ap) { int inr; const u_char *fmt = (const u_char *)fmt0; int c; /* character from format, or conversion */ size_t width; /* field width, or 0 */ char *p; /* points into all kinds of strings */ int n; /* handy integer */ int flags; /* flags as defined above */ char *p0; /* saves original value of p when necessary */ int nassigned; /* number of fields assigned */ int nconversions; /* number of conversions */ int nread; /* number of characters consumed from fp */ int base; /* base argument to conversion function */ char ccltab[256]; /* character class table for %[...] */ char buf[BUF]; /* buffer for numeric conversions */ /* `basefix' is used to avoid `if' tests in the integer scanner */ static short basefix[17] = { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; inr = strlen(inp); nassigned = 0; nconversions = 0; nread = 0; base = 0; /* XXX just to keep gcc happy */ for (;;) { c = *fmt++; if (c == 0) return (nassigned); if (isspace(c)) { while (inr > 0 && isspace(*inp)) nread++, inr--, inp++; continue; } if (c != '%') goto literal; width = 0; flags = 0; /* * switch on the format. continue if done; * break once format type is derived. */ again: c = *fmt++; switch (c) { case '%': literal: if (inr <= 0) goto input_failure; if (*inp != c) goto match_failure; inr--, inp++; nread++; continue; case '*': flags |= SUPPRESS; goto again; case 'l': if (flags & LONG) { flags &= ~LONG; flags |= LONGLONG; } else flags |= LONG; goto again; case 'q': flags |= LONGLONG; /* not quite */ goto again; case 'h': if (flags & SHORT) { flags &= ~SHORT; flags |= SHORTSHORT; } else flags |= SHORT; goto again; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': width = width * 10 + c - '0'; goto again; /* * Conversions. */ case 'd': c = CT_INT; base = 10; break; case 'i': c = CT_INT; base = 0; break; case 'o': c = CT_INT; flags |= UNSIGNED; base = 8; break; case 'u': c = CT_INT; flags |= UNSIGNED; base = 10; break; case 'X': case 'x': flags |= PFXOK; /* enable 0x prefixing */ c = CT_INT; flags |= UNSIGNED; base = 16; break; case 's': c = CT_STRING; break; case '[': fmt = __sccl(ccltab, fmt); flags |= NOSKIP; c = CT_CCL; break; case 'c': flags |= NOSKIP; c = CT_CHAR; break; case 'p': /* pointer format is like hex */ flags |= POINTER | PFXOK; c = CT_INT; flags |= UNSIGNED; base = 16; break; case 'n': nconversions++; if (flags & SUPPRESS) /* ??? */ continue; if (flags & SHORTSHORT) *va_arg(ap, char *) = nread; else if (flags & SHORT) *va_arg(ap, short *) = nread; else if (flags & LONG) *va_arg(ap, long *) = nread; else if (flags & LONGLONG) *va_arg(ap, long long *) = nread; else *va_arg(ap, int *) = nread; continue; } /* * We have a conversion that requires input. */ if (inr <= 0) goto input_failure; /* * Consume leading white space, except for formats * that suppress this. */ if ((flags & NOSKIP) == 0) { while (isspace(*inp)) { nread++; if (--inr > 0) inp++; else goto input_failure; } /* * Note that there is at least one character in * the buffer, so conversions that do not set NOSKIP * can no longer result in an input failure. */ } /* * Do the conversion. */ switch (c) { case CT_CHAR: /* scan arbitrary characters (sets NOSKIP) */ if (width == 0) width = 1; if (flags & SUPPRESS) { size_t sum = 0; for (;;) { if ((n = inr) < (int)width) { sum += n; width -= n; inp += n; if (sum == 0) goto input_failure; break; } else { sum += width; inr -= width; inp += width; break; } } nread += sum; } else { bcopy(inp, va_arg(ap, char *), width); inr -= width; inp += width; nread += width; nassigned++; } nconversions++; break; case CT_CCL: /* scan a (nonempty) character class (sets NOSKIP) */ if (width == 0) width = (size_t)~0; /* `infinity' */ /* take only those things in the class */ if (flags & SUPPRESS) { n = 0; while (ccltab[(unsigned char)*inp]) { n++, inr--, inp++; if (--width == 0) break; if (inr <= 0) { if (n == 0) goto input_failure; break; } } if (n == 0) goto match_failure; } else { p0 = p = va_arg(ap, char *); while (ccltab[(unsigned char)*inp]) { inr--; *p++ = *inp++; if (--width == 0) break; if (inr <= 0) { if (p == p0) goto input_failure; break; } } n = p - p0; if (n == 0) goto match_failure; *p = 0; nassigned++; } nread += n; nconversions++; break; case CT_STRING: /* like CCL, but zero-length string OK, & no NOSKIP */ if (width == 0) width = (size_t)~0; if (flags & SUPPRESS) { n = 0; while (!isspace(*inp)) { n++, inr--, inp++; if (--width == 0) break; if (inr <= 0) break; } nread += n; } else { p0 = p = va_arg(ap, char *); while (!isspace(*inp)) { inr--; *p++ = *inp++; if (--width == 0) break; if (inr <= 0) break; } *p = 0; nread += p - p0; nassigned++; } nconversions++; continue; case CT_INT: /* scan an integer as if by the conversion function */ #ifdef hardway if (width == 0 || width > sizeof(buf) - 1) width = sizeof(buf) - 1; #else /* size_t is unsigned, hence this optimisation */ if (--width > sizeof(buf) - 2) width = sizeof(buf) - 2; width++; #endif flags |= SIGNOK | NDIGITS | NZDIGITS; for (p = buf; width; width--) { c = *inp; /* * Switch on the character; `goto ok' * if we accept it as a part of number. */ switch (c) { /* * The digit 0 is always legal, but is * special. For %i conversions, if no * digits (zero or nonzero) have been * scanned (only signs), we will have * base==0. In that case, we should set * it to 8 and enable 0x prefixing. * Also, if we have not scanned zero digits * before this, do not turn off prefixing * (someone else will turn it off if we * have scanned any nonzero digits). */ case '0': if (base == 0) { base = 8; flags |= PFXOK; } if (flags & NZDIGITS) flags &= ~(SIGNOK|NZDIGITS|NDIGITS); else flags &= ~(SIGNOK|PFXOK|NDIGITS); goto ok; /* 1 through 7 always legal */ case '1': case '2': case '3': case '4': case '5': case '6': case '7': base = basefix[base]; flags &= ~(SIGNOK | PFXOK | NDIGITS); goto ok; /* digits 8 and 9 ok iff decimal or hex */ case '8': case '9': base = basefix[base]; if (base <= 8) break; /* not legal here */ flags &= ~(SIGNOK | PFXOK | NDIGITS); goto ok; /* letters ok iff hex */ case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': /* no need to fix base here */ if (base <= 10) break; /* not legal here */ flags &= ~(SIGNOK | PFXOK | NDIGITS); goto ok; /* sign ok only as first character */ case '+': case '-': if (flags & SIGNOK) { flags &= ~SIGNOK; goto ok; } break; /* x ok iff flag still set & 2nd char */ case 'x': case 'X': if (flags & PFXOK && p == buf + 1) { base = 16; /* if %i */ flags &= ~PFXOK; goto ok; } break; } /* * If we got here, c is not a legal character * for a number. Stop accumulating digits. */ break; ok: /* * c is legal: store it and look at the next. */ *p++ = c; if (--inr > 0) inp++; else break; /* end of input */ } /* * If we had only a sign, it is no good; push * back the sign. If the number ends in `x', * it was [sign] '0' 'x', so push back the x * and treat it as [sign] '0'. */ if (flags & NDIGITS) { if (p > buf) { inp--; inr++; } goto match_failure; } c = ((u_char *)p)[-1]; if (c == 'x' || c == 'X') { --p; inp--; inr++; } if ((flags & SUPPRESS) == 0) { u_quad_t res; *p = 0; if ((flags & UNSIGNED) == 0) res = strtoq(buf, (char **)NULL, base); else res = strtouq(buf, (char **)NULL, base); if (flags & POINTER) *va_arg(ap, void **) = (void *)(uintptr_t)res; else if (flags & SHORTSHORT) *va_arg(ap, char *) = res; else if (flags & SHORT) *va_arg(ap, short *) = res; else if (flags & LONG) *va_arg(ap, long *) = res; else if (flags & LONGLONG) *va_arg(ap, long long *) = res; else *va_arg(ap, int *) = res; nassigned++; } nread += p - buf; nconversions++; break; } } input_failure: return (nconversions != 0 ? nassigned : -1); match_failure: return (nassigned); }
int main(int argc, char *argv[]) { u_int64_t val; int ch; char *p, buf[100]; /* > max number of digits. */ if (pledge("stdio", NULL) == -1) err(1, "pledge"); while ((ch = getopt(argc, argv, "h")) != -1) { switch (ch) { case 'h': default: usage(); } } argc -= optind; argv += optind; /* No args supplied, read numbers from stdin. */ if (argc == 0) { for (;;) { if (fgets(buf, sizeof(buf), stdin) == NULL) { if (ferror(stdin)) err(1, "stdin"); return 0; } buf[strcspn(buf, "\n")] = '\0'; for (p = buf; isblank((unsigned char)*p); ++p) ; if (*p == '\0') continue; if (*p == '-') errx(1, "negative numbers aren't permitted."); errno = 0; val = strtouq(buf, &p, 10); if (errno) err(1, "%s", buf); for (; isblank((unsigned char)*p); ++p) ; if (*p != '\0') errx(1, "%s: illegal numeric format.", buf); pr_fact(val); } /* Factor the arguments. */ } else { for (; *argv != NULL; ++argv) { if (argv[0][0] == '-') errx(1, "negative numbers aren't permitted."); errno = 0; val = strtouq(argv[0], &p, 10); if (errno) err(1, "%s", argv[0]); if (*p != '\0') errx(1, "%s: illegal numeric format.", argv[0]); pr_fact(val); } } return 0; }
static void set(char *t, NODE *ip) { int type; char *kw, *val = NULL; struct group *gr; struct passwd *pw; void *m; int value; u_int32_t fset, fclr; char *ep; size_t len; for (; (kw = strtok(t, "= \t\n")); t = NULL) { ip->flags |= type = parsekey(kw, &value); if (value && (val = strtok(NULL, " \t\n")) == NULL) error("missing value"); switch(type) { case F_CKSUM: ip->cksum = strtoul(val, &ep, 10); if (*ep) error("invalid checksum %s", val); break; case F_MD5: ip->md5digest = strdup(val); if (!ip->md5digest) error("%s", strerror(errno)); break; case F_FLAGS: if (!strcmp(val, "none")) { ip->file_flags = 0; break; } if (strtofflags(&val, &fset, &fclr)) error("%s", strerror(errno)); ip->file_flags = fset; break; case F_GID: ip->st_gid = strtoul(val, &ep, 10); if (*ep) error("invalid gid %s", val); break; case F_GNAME: if ((gr = getgrnam(val)) == NULL) error("unknown group %s", val); ip->st_gid = gr->gr_gid; break; case F_IGN: /* just set flag bit */ break; case F_MODE: if ((m = setmode(val)) == NULL) error("invalid file mode %s", val); ip->st_mode = getmode(m, 0); free(m); break; case F_NLINK: ip->st_nlink = strtoul(val, &ep, 10); if (*ep) error("invalid link count %s", val); break; case F_RMD160: ip->rmd160digest = strdup(val); if (!ip->rmd160digest) error("%s", strerror(errno)); break; case F_SHA1: ip->sha1digest = strdup(val); if (!ip->sha1digest) error("%s", strerror(errno)); break; case F_SIZE: ip->st_size = strtouq(val, &ep, 10); if (*ep) error("invalid size %s", val); break; case F_SLINK: len = strlen(val) + 1; if ((ip->slink = malloc(len)) == NULL) error("%s", strerror(errno)); if (strunvis(ip->slink, val) == -1) { fprintf(stderr, "mtree: filename (%s) encoded incorrectly\n", val); strlcpy(ip->slink, val, len); } break; case F_TIME: ip->st_mtimespec.tv_sec = strtoul(val, &ep, 10); if (*ep != '.') error("invalid time %s", val); val = ep + 1; ip->st_mtimespec.tv_nsec = strtoul(val, &ep, 10); if (*ep) error("invalid time %s", val); break; case F_TYPE: switch(*val) { case 'b': if (!strcmp(val, "block")) ip->type = F_BLOCK; break; case 'c': if (!strcmp(val, "char")) ip->type = F_CHAR; break; case 'd': if (!strcmp(val, "dir")) ip->type = F_DIR; break; case 'f': if (!strcmp(val, "file")) ip->type = F_FILE; if (!strcmp(val, "fifo")) ip->type = F_FIFO; break; case 'l': if (!strcmp(val, "link")) ip->type = F_LINK; break; case 's': if (!strcmp(val, "socket")) ip->type = F_SOCK; break; default: error("unknown file type %s", val); } break; case F_UID: ip->st_uid = strtoul(val, &ep, 10); if (*ep) error("invalid uid %s", val); break; case F_UNAME: if ((pw = getpwnam(val)) == NULL) error("unknown user %s", val); ip->st_uid = pw->pw_uid; break; } } }
int osm_db_restore(IN osm_db_domain_t * p_domain) { osm_log_t *p_log = p_domain->p_db->p_log; osm_db_domain_imp_t *p_domain_imp = (osm_db_domain_imp_t *) p_domain->p_domain_imp; FILE *p_file; int status; char sLine[OSM_DB_MAX_LINE_LEN]; boolean_t before_key; char *p_first_word, *p_rest_of_line, *p_last; char *p_key = NULL; char *p_prev_val, *p_accum_val = NULL; char *endptr = NULL; unsigned int line_num; OSM_LOG_ENTER(p_log); /* take the lock on the domain */ cl_spinlock_acquire(&p_domain_imp->lock); /* open the file - read mode */ p_file = fopen(p_domain_imp->file_name, "r"); if (!p_file) { OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6103: " "Failed to open the db file:%s\n", p_domain_imp->file_name); status = 1; goto Exit; } /* parse the file allocating new hash tables as required */ /* states: before_key (0) -> in_key (1) before_key: if a word on the first byte - it is the key. state=in_key the rest of the line is start of the value. in_key: unless the line is empty - add it (with newlines) to the value. if empty: state=before_key */ status = 0; before_key = TRUE; line_num = 0; /* if we got to EOF in the middle of a key we add a last newline */ while ((fgets(sLine, OSM_DB_MAX_LINE_LEN, p_file) != NULL) || ((before_key == FALSE) && strcpy(sLine, "\n")) ) { line_num++; if (before_key) { if ((sLine[0] != ' ') && (sLine[0] != '\t') && (sLine[0] != '\n')) { /* we got a new key */ before_key = FALSE; /* handle the key */ p_first_word = strtok_r(sLine, " \t\n", &p_last); if (!p_first_word) { OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6104: " "Failed to get key from line:%u : %s (file:%s)\n", line_num, sLine, p_domain_imp->file_name); status = 1; goto EndParsing; } if (strlen(p_first_word) > OSM_DB_MAX_GUID_LEN) { OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 610A: " "Illegal key from line:%u : %s (file:%s)\n", line_num, sLine, p_domain_imp->file_name); status = 1; goto EndParsing; } p_key = (char *)malloc(sizeof(char) * (strlen(p_first_word) + 1)); strcpy(p_key, p_first_word); p_rest_of_line = strtok_r(NULL, "\n", &p_last); if (p_rest_of_line != NULL) { p_accum_val = (char *)malloc(sizeof(char) * (strlen (p_rest_of_line) + 1)); strcpy(p_accum_val, p_rest_of_line); } else { p_accum_val = (char *)malloc(2); strcpy(p_accum_val, "\0"); } } else if (sLine[0] != '\n') { OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6105: " "How did we get here? line:%u : %s (file:%s)\n", line_num, sLine, p_domain_imp->file_name); status = 1; goto EndParsing; } } /* before key */ else { /* we already have a key */ if (sLine[0] == '\n') { /* got an end of key */ before_key = TRUE; /* make sure the key was not previously used */ if (st_lookup(p_domain_imp->p_hash, (st_data_t) p_key, (void *) & p_prev_val)) { OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6106: " "Key:%s already exists in:%s with value:%s." " Removing it\n", p_key, p_domain_imp->file_name, p_prev_val); } else { p_prev_val = NULL; } OSM_LOG(p_log, OSM_LOG_DEBUG, "Got key:%s value:%s\n", p_key, p_accum_val); /* check that the key is a number */ if (!strtouq(p_key, &endptr, 0) && *endptr != '\0') { OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 610B: " "Key:%s is invalid\n", p_key); } else { /* store our key and value */ st_insert(p_domain_imp->p_hash, (st_data_t) p_key, (st_data_t) p_accum_val); } } else { /* accumulate into the value */ p_prev_val = p_accum_val; p_accum_val = (char *)malloc(strlen(p_prev_val) + strlen(sLine) + 1); strcpy(p_accum_val, p_prev_val); free(p_prev_val); strcat(p_accum_val, sLine); } } /* in key */ } /* while lines or last line */ EndParsing: fclose(p_file); Exit: cl_spinlock_release(&p_domain_imp->lock); OSM_LOG_EXIT(p_log); return status; }
BOOLEAN DepositValue( IN PCHAR AsciiValue, IN ULONG Address ) /*++ Routine Description: This routine writes the converted value to the specified address. DataSize is set to the size of the data to be written. Arguments: AsciiValue - Supplies a pointer to a string that contains an hexadecimal value. Address - Supplies the address where the value is to be written to. Return Value: TRUE if the value is successfully converted. FALSE otherwise. --*/ { // ULONG Value; ULONGLONG Value; PCHAR Terminator; // // Convert value to integer // Value = strtouq(AsciiValue,&Terminator,16); if (*Terminator != '\0') { // // Not the whole string was converted. // FwPrint(Terminator); FwPrint(MON_INVALID_VALUE_MSG); return FALSE; } else { // // Store the value. // switch (DataSize) { case BYTE:*(PUCHAR)Address = (UCHAR)Value; break; case HALF:*(PUSHORT)Address = (USHORT)Value; break; case MON_LONGWORD:*(PULONG)Address = (ULONG)Value; break; case MON_QUAD:*(PULONGLONG)Address = (ULONGLONG)Value; break; } } return TRUE; }