static char * ATTRIBUTE_WARN_UNUSED_RESULT human_time (struct timespec t) { /* STR must be at least this big, either because localtime_rz fails, or because the time zone is truly outlandish so that %z expands to a long string. */ enum { intmax_bufsize = INT_BUFSIZE_BOUND (intmax_t) }; static char str[intmax_bufsize + INT_STRLEN_BOUND (int) /* YYYY */ + 1 /* because YYYY might equal INT_MAX + 1900 */ + sizeof "-MM-DD HH:MM:SS.NNNNNNNNN +"]; static timezone_t tz; if (!tz) tz = tzalloc (getenv ("TZ")); struct tm tm; int ns = t.tv_nsec; if (localtime_rz (tz, &t.tv_sec, &tm)) nstrftime (str, sizeof str, "%Y-%m-%d %H:%M:%S.%N %z", &tm, tz, ns); else { char secbuf[INT_BUFSIZE_BOUND (intmax_t)]; sprintf (str, "%s.%09d", timetostr (t.tv_sec, secbuf), ns); } return str; }
int main (int argc, char **argv) { char limit[1 + MAX (INT_BUFSIZE_BOUND (intmax_t), INT_BUFSIZE_BOUND (uintmax_t))]; initialize_main (&argc, &argv); set_program_name (argv[0]); setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); initialize_exit_failure (EXIT_FAILURE); atexit (close_stdout); parse_long_options (argc, argv, PROGRAM_NAME, PACKAGE_NAME, VERSION, usage, AUTHORS, (char const *) NULL); #define print_int(TYPE) \ sprintf (limit + 1, "%"PRIuMAX, (uintmax_t) TYPE##_MAX); \ printf (#TYPE"_MAX=%s\n", limit + 1); \ printf (#TYPE"_OFLOW=%s\n", decimal_absval_add_one (limit)); \ if (TYPE##_MIN) \ { \ sprintf (limit + 1, "%"PRIdMAX, (intmax_t) TYPE##_MIN); \ printf (#TYPE"_MIN=%s\n", limit + 1); \ printf (#TYPE"_UFLOW=%s\n", decimal_absval_add_one (limit)); \ } #define print_float(TYPE) \ printf (#TYPE"_MIN=%Le\n", (long double)TYPE##_MIN); \ printf (#TYPE"_MAX=%Le\n", (long double)TYPE##_MAX); /* Variable sized ints */ print_int (CHAR); print_int (SCHAR); print_int (UCHAR); print_int (SHRT); print_int (INT); print_int (UINT); print_int (LONG); print_int (ULONG); print_int (SIZE); print_int (SSIZE); print_int (TIME_T); print_int (UID_T); print_int (GID_T); print_int (PID_T); print_int (OFF_T); print_int (INTMAX); print_int (UINTMAX); /* Variable sized floats */ print_float (FLT); print_float (DBL); print_float (LDBL); }
static char * mpz_get_str (char const *str, int base, mpz_t z) { char buf[INT_BUFSIZE_BOUND (intmax_t)]; (void) str; (void) base; return xstrdup (imaxtostr (z[0], buf)); }
static int mpz_out_str (FILE *stream, int base, mpz_t z) { char buf[INT_BUFSIZE_BOUND (intmax_t)]; (void) base; return fputs (imaxtostr (z[0], buf), stream) != EOF; }
static bool check_sparse_region (struct tar_sparse_file *file, off_t beg, off_t end) { if (!lseek_or_error (file, beg)) return false; while (beg < end) { size_t bytes_read; size_t rdsize = BLOCKSIZE < end - beg ? BLOCKSIZE : end - beg; char diff_buffer[BLOCKSIZE]; bytes_read = safe_read (file->fd, diff_buffer, rdsize); if (bytes_read == SAFE_READ_ERROR) { read_diag_details (file->stat_info->orig_file_name, beg, rdsize); return false; } if (!zero_block_p (diff_buffer, bytes_read)) { char begbuf[INT_BUFSIZE_BOUND (off_t)]; report_difference (file->stat_info, _("File fragment at %s is not a hole"), offtostr (beg, begbuf)); return false; } beg += bytes_read; } return true; }
int virPidFileWritePath(const char *pidfile, pid_t pid) { int rc; int fd; char pidstr[INT_BUFSIZE_BOUND(pid)]; if ((fd = open(pidfile, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) < 0) { rc = -errno; goto cleanup; } snprintf(pidstr, sizeof(pidstr), "%lld", (long long) pid); if (safewrite(fd, pidstr, strlen(pidstr)) < 0) { rc = -errno; VIR_FORCE_CLOSE(fd); goto cleanup; } rc = 0; cleanup: if (VIR_CLOSE(fd) < 0) rc = -errno; return rc; }
static void read_negative_num (FILE *fp, intmax_t min_val, intmax_t *pval) { int c; size_t i; char buf[INT_BUFSIZE_BOUND (intmax_t)]; char *ep; buf[0] = '-'; for (i = 1; ISDIGIT (c = getc (fp)); i++) { if (i == sizeof buf - 1) FATAL_ERROR ((0, 0, _("Field too long while reading snapshot file"))); buf[i] = c; } if (c < 0) { if (ferror (fp)) FATAL_ERROR ((0, errno, _("Read error in snapshot file"))); else FATAL_ERROR ((0, 0, _("Unexpected EOF in snapshot file"))); } buf[i] = 0; errno = 0; *pval = strtoimax (buf, &ep, 10); if (c || errno || *pval < min_val) FATAL_ERROR ((0, errno, _("Unexpected field value in snapshot file"))); }
/* Read incremental snapshot format 2 */ static void read_incr_db_2 (void) { struct obstack stk; char offbuf[INT_BUFSIZE_BOUND (off_t)]; obstack_init (&stk); read_timespec (listed_incremental_stream, &newer_mtime_option); for (;;) { intmax_t i; struct timespec mtime; dev_t dev; ino_t ino; bool nfs; char *name; char *content; size_t s; if (! read_num (listed_incremental_stream, "nfs", 0, 1, &i)) return; /* Normal return */ nfs = i; read_timespec (listed_incremental_stream, &mtime); if (! read_num (listed_incremental_stream, "dev", TYPE_MINIMUM (dev_t), TYPE_MAXIMUM (dev_t), &i)) break; dev = i; if (! read_num (listed_incremental_stream, "ino", TYPE_MINIMUM (ino_t), TYPE_MAXIMUM (ino_t), &i)) break; ino = i; if (read_obstack (listed_incremental_stream, &stk, &s)) break; name = obstack_finish (&stk); while (read_obstack (listed_incremental_stream, &stk, &s) == 0 && s > 1) ; if (getc (listed_incremental_stream) != 0) FATAL_ERROR ((0, 0, _("%s: byte %s: %s"), quotearg_colon (listed_incremental_option), offtostr (ftello (listed_incremental_stream), offbuf), _("Missing record terminator"))); content = obstack_finish (&stk); note_directory (name, mtime, dev, ino, nfs, false, content); obstack_free (&stk, content); } FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Unexpected EOF in snapshot file"))); }
extern char * uid_to_name (uid_t uid) { char buf[INT_BUFSIZE_BOUND (intmax_t)]; struct passwd *pwd = getpwuid (uid); return xstrdup (pwd ? pwd->pw_name : TYPE_SIGNED (uid_t) ? imaxtostr (uid, buf) : umaxtostr (uid, buf)); }
extern char * gid_to_name (gid_t gid) { char buf[INT_BUFSIZE_BOUND (intmax_t)]; struct group *grp = getgrgid (gid); return xstrdup (grp ? grp->gr_name : TYPE_SIGNED (gid_t) ? imaxtostr (gid, buf) : umaxtostr (gid, buf)); }
static char * ATTRIBUTE_WARN_UNUSED_RESULT human_time (struct timespec t) { static char str[MAX (INT_BUFSIZE_BOUND (intmax_t), (INT_STRLEN_BOUND (int) /* YYYY */ + 1 /* because YYYY might equal INT_MAX + 1900 */ + sizeof "-MM-DD HH:MM:SS.NNNNNNNNN +ZZZZ"))]; struct tm const *tm = localtime (&t.tv_sec); if (tm == NULL) return timetostr (t.tv_sec, str); nstrftime (str, sizeof str, "%Y-%m-%d %H:%M:%S.%N %z", tm, 0, t.tv_nsec); return str; }
static void out_of_range_header (char const *keyword, char const *value, intmax_t minval, uintmax_t maxval) { char minval_buf[INT_BUFSIZE_BOUND (intmax_t)]; char maxval_buf[UINTMAX_STRSIZE_BOUND]; char *minval_string = imaxtostr (minval, minval_buf); char *maxval_string = umaxtostr (maxval, maxval_buf); /* TRANSLATORS: The first %s is the pax extended header keyword (atime, gid, etc.). */ ERROR ((0, 0, _("Extended header %s=%s is out of range %s..%s"), keyword, value, minval_string, maxval_string)); }
/* * Bridge parameters can be set via sysfs on newish kernels, * or by ioctl on older kernels. Perhaps we could just use * ioctl for every kernel, but its not clear what the long * term lifespan of the ioctl interface is... */ static int virNetDevBridgeSet(const char *brname, const char *paramname, /* sysfs param name */ unsigned long value, /* new value */ int fd, /* control socket */ struct ifreq *ifr) /* pre-filled bridge name */ { char *path = NULL; int ret = -1; if (virAsprintf(&path, "%s/%s/bridge/%s", SYSFS_NET_DIR, brname, paramname) < 0) { virReportOOMError(); return -1; } if (virFileExists(path)) { char valuestr[INT_BUFSIZE_BOUND(value)]; snprintf(valuestr, sizeof(valuestr), "%lu", value); if (virFileWriteStr(path, valuestr, 0) < 0) { virReportSystemError(errno, _("Unable to set bridge %s %s"), brname, paramname); goto cleanup; } } else { unsigned long paramid; if (STREQ(paramname, "stp_state")) { paramid = BRCTL_SET_BRIDGE_STP_STATE; } else if (STREQ(paramname, "forward_delay")) { paramid = BRCTL_SET_BRIDGE_FORWARD_DELAY; } else { virReportSystemError(EINVAL, _("Unable to set bridge %s %s"), brname, paramname); goto cleanup; } unsigned long args[] = { paramid, value, 0, 0 }; ifr->ifr_data = (char*)&args; if (ioctl(fd, SIOCDEVPRIVATE, ifr) < 0) { virReportSystemError(errno, _("Unable to set bridge %s %s"), brname, paramname); goto cleanup; } } ret = 0; cleanup: VIR_FREE(path); return ret; }
/* Return the positive decimal contents of the given * DIR/cpu%u/FILE, or -1 on error. If MISSING_OK and the * file could not be found, return 1 instead of an error; this is * because some machines cannot hot-unplug cpu0, or because * hot-unplugging is disabled. */ static int virNodeGetCpuValue(const char *dir, unsigned int cpu, const char *file, bool missing_ok) { char *path; FILE *pathfp; int value = -1; char value_str[INT_BUFSIZE_BOUND(value)]; char *tmp; if (virAsprintf(&path, "%s/cpu%u/%s", dir, cpu, file) < 0) { virReportOOMError(); return -1; } pathfp = fopen(path, "r"); if (pathfp == NULL) { if (missing_ok && errno == ENOENT) value = 1; else virReportSystemError(errno, _("cannot open %s"), path); goto cleanup; } if (fgets(value_str, sizeof(value_str), pathfp) == NULL) { virReportSystemError(errno, _("cannot read from %s"), path); goto cleanup; } if (virStrToLong_i(value_str, &tmp, 10, &value) < 0) { nodeReportError(VIR_ERR_INTERNAL_ERROR, _("could not convert '%s' to an integer"), value_str); goto cleanup; } cleanup: VIR_FORCE_FCLOSE(pathfp); VIR_FREE(path); return value; }
int virPidFileReadPath(const char *path, pid_t *pid) { int fd; int rc; ssize_t bytes; long long pid_value = 0; char pidstr[INT_BUFSIZE_BOUND(pid_value)]; char *endptr = NULL; *pid = 0; if ((fd = open(path, O_RDONLY)) < 0) { rc = -errno; goto cleanup; } bytes = saferead(fd, pidstr, sizeof(pidstr)); if (bytes < 0) { rc = -errno; VIR_FORCE_CLOSE(fd); goto cleanup; } pidstr[bytes] = '\0'; if (virStrToLong_ll(pidstr, &endptr, 10, &pid_value) < 0 || !(*endptr == '\0' || c_isspace(*endptr)) || (pid_t) pid_value != pid_value) { rc = -1; goto cleanup; } *pid = pid_value; rc = 0; cleanup: if (VIR_CLOSE(fd) < 0) rc = -errno; return rc; }
static int build_policy (pskc_key_t * kp, xmlNodePtr keyp) { int keyusage_p; int keyusages = pskc_get_key_policy_keyusages (kp, &keyusage_p); const struct tm *startdate = pskc_get_key_policy_startdate (kp); const struct tm *expirydate = pskc_get_key_policy_expirydate (kp); const char *pinkeyid = pskc_get_key_policy_pinkeyid (kp); int pinusagemode_p; pskc_pinusagemode pinusagemode = pskc_get_key_policy_pinusagemode (kp, &pinusagemode_p); int attempts_p; uint32_t attempts = pskc_get_key_policy_pinmaxfailedattempts (kp, &attempts_p); int pinmin_p; uint32_t pinmin = pskc_get_key_policy_pinminlength (kp, &pinmin_p); int pinmax_p; uint32_t pinmax = pskc_get_key_policy_pinmaxlength (kp, &pinmax_p); int pinencoding_p; pskc_valueformat pinencoding = pskc_get_key_policy_pinencoding (kp, &pinencoding_p); int numberoftransactions_p; uint64_t numberoftransactions = pskc_get_key_policy_numberoftransactions (kp, &numberoftransactions_p); xmlNodePtr policy, pinpolicy; if (!keyusage_p && !startdate && !expirydate && !pinkeyid && !pinusagemode_p && !attempts_p && !pinmin_p && !pinmax_p && !pinencoding_p) return PSKC_OK; policy = xmlNewChild (keyp, NULL, BAD_CAST "Policy", NULL); if (startdate) { char t[100]; strftime (t, sizeof (t), "%Y-%m-%dT%H:%M:%SZ", startdate); xmlNewTextChild (policy, NULL, BAD_CAST "StartDate", BAD_CAST t); } if (expirydate) { char t[100]; strftime (t, sizeof (t), "%Y-%m-%dT%H:%M:%SZ", expirydate); xmlNewTextChild (policy, NULL, BAD_CAST "ExpiryDate", BAD_CAST t); } if (pinkeyid || pinusagemode_p || attempts_p || pinmin_p || pinmax_p || pinencoding_p) { pinpolicy = xmlNewChild (policy, NULL, BAD_CAST "PINPolicy", NULL); if (pinkeyid) xmlNewProp (pinpolicy, BAD_CAST "PINKeyId", BAD_CAST pinkeyid); if (pinusagemode_p) xmlNewProp (pinpolicy, BAD_CAST "PINUsageMode", BAD_CAST pskc_pinusagemode2str (pinusagemode)); if (attempts_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (attempts, buf); xmlNewProp (pinpolicy, BAD_CAST "MaxFailedAttempts", BAD_CAST p); } if (pinmin_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (pinmin, buf); xmlNewProp (pinpolicy, BAD_CAST "MinLength", BAD_CAST p); } if (pinmax_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (pinmax, buf); xmlNewProp (pinpolicy, BAD_CAST "MaxLength", BAD_CAST p); } if (pinencoding_p) xmlNewProp (pinpolicy, BAD_CAST "PINEncoding", BAD_CAST pskc_valueformat2str (pinencoding)); } if (keyusage_p) { int i; for (i = 1; i <= PSKC_KEYUSAGE_LAST; i = i << 1) { const char *keyusage_str = pskc_keyusage2str (i); if (keyusages & i) xmlNewTextChild (policy, NULL, BAD_CAST "KeyUsage", BAD_CAST keyusage_str); } } if (numberoftransactions_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (numberoftransactions, buf); xmlNewTextChild (policy, NULL, BAD_CAST "NumberOfTransactions", BAD_CAST p); } return PSKC_OK; }
static bool read_num (FILE *fp, char const *fieldname, intmax_t min_val, uintmax_t max_val, intmax_t *pval) { int i; char buf[INT_BUFSIZE_BOUND (intmax_t)]; char offbuf[INT_BUFSIZE_BOUND (off_t)]; char minbuf[INT_BUFSIZE_BOUND (intmax_t)]; char maxbuf[INT_BUFSIZE_BOUND (intmax_t)]; int conversion_errno; int c = getc (fp); bool negative = c == '-'; for (i = 0; (i == 0 && negative) || ISDIGIT (c); i++) { buf[i] = c; if (i == sizeof buf - 1) FATAL_ERROR ((0, 0, _("%s: byte %s: %s %.*s... too long"), quotearg_colon (listed_incremental_option), offtostr (ftello (fp), offbuf), fieldname, i + 1, buf)); c = getc (fp); } buf[i] = 0; if (c < 0) { if (ferror (fp)) read_fatal (listed_incremental_option); if (i != 0) FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (listed_incremental_option), _("Unexpected EOF in snapshot file"))); return false; } if (c) { unsigned uc = c; FATAL_ERROR ((0, 0, _("%s: byte %s: %s %s followed by invalid byte 0x%02x"), quotearg_colon (listed_incremental_option), offtostr (ftello (fp), offbuf), fieldname, buf, uc)); } *pval = strtosysint (buf, NULL, min_val, max_val); conversion_errno = errno; switch (conversion_errno) { case ERANGE: FATAL_ERROR ((0, conversion_errno, _("%s: byte %s: (valid range %s..%s)\n\t%s %s"), quotearg_colon (listed_incremental_option), offtostr (ftello (fp), offbuf), imaxtostr (min_val, minbuf), umaxtostr (max_val, maxbuf), fieldname, buf)); default: FATAL_ERROR ((0, conversion_errno, _("%s: byte %s: %s %s"), quotearg_colon (listed_incremental_option), offtostr (ftello (fp), offbuf), fieldname, buf)); case 0: break; } return true; }
static char const * parse_with_separator (char const *spec, char const *separator, uid_t *uid, gid_t *gid, char **username, char **groupname) { static const char *E_invalid_user = N_("invalid user"); static const char *E_invalid_group = N_("invalid group"); static const char *E_bad_spec = N_("invalid spec"); const char *error_msg; struct passwd *pwd; struct group *grp; char *u; char const *g; char *gname = NULL; uid_t unum = *uid; gid_t gnum = *gid; error_msg = NULL; *username = *groupname = NULL; /* Set U and G to nonzero length strings corresponding to user and group specifiers or to NULL. If U is not NULL, it is a newly allocated string. */ u = NULL; if (separator == NULL) { if (*spec) u = xstrdup (spec); } else { size_t ulen = separator - spec; if (ulen != 0) { u = xmemdup (spec, ulen + 1); u[ulen] = '\0'; } } g = (separator == NULL || *(separator + 1) == '\0' ? NULL : separator + 1); #ifdef __DJGPP__ /* Pretend that we are the user U whose group is G. This makes pwd and grp functions ``know'' about the UID and GID of these. */ if (u && !is_number (u)) setenv ("USER", u, 1); if (g && !is_number (g)) setenv ("GROUP", g, 1); #endif if (u != NULL) { /* If it starts with "+", skip the look-up. */ pwd = (*u == '+' ? NULL : getpwnam (u)); if (pwd == NULL) { bool use_login_group = (separator != NULL && g == NULL); if (use_login_group) { /* If there is no group, then there may not be a trailing ":", either. */ error_msg = E_bad_spec; } else { unsigned long int tmp; if (xstrtoul (u, NULL, 10, &tmp, "") == LONGINT_OK && tmp <= MAXUID && (uid_t) tmp != (uid_t) -1) unum = tmp; else error_msg = E_invalid_user; } } else { unum = pwd->pw_uid; if (g == NULL && separator != NULL) { /* A separator was given, but a group was not specified, so get the login group. */ char buf[INT_BUFSIZE_BOUND (uintmax_t)]; gnum = pwd->pw_gid; grp = getgrgid (gnum); gname = xstrdup (grp ? grp->gr_name : umaxtostr (gnum, buf)); endgrent (); } } endpwent (); } if (g != NULL && error_msg == NULL) { /* Explicit group. */ /* If it starts with "+", skip the look-up. */ grp = (*g == '+' ? NULL : getgrnam (g)); if (grp == NULL) { unsigned long int tmp; if (xstrtoul (g, NULL, 10, &tmp, "") == LONGINT_OK && tmp <= MAXGID && (gid_t) tmp != (gid_t) -1) gnum = tmp; else error_msg = E_invalid_group; } else gnum = grp->gr_gid; endgrent (); /* Save a file descriptor. */ gname = xstrdup (g); } if (error_msg == NULL) { *uid = unum; *gid = gnum; *username = u; *groupname = gname; u = NULL; } else free (gname); free (u); return _(error_msg); }
int linuxNodeGetCPUStats(FILE *procstat, int cpuNum, virNodeCPUStatsPtr params, int *nparams) { int ret = -1; char line[1024]; unsigned long long usr, ni, sys, idle, iowait; unsigned long long irq, softirq, steal, guest, guest_nice; char cpu_header[3 + INT_BUFSIZE_BOUND(cpuNum)]; if ((*nparams) == 0) { /* Current number of cpu stats supported by linux */ *nparams = LINUX_NB_CPU_STATS; ret = 0; goto cleanup; } if ((*nparams) != LINUX_NB_CPU_STATS) { nodeReportError(VIR_ERR_INVALID_ARG, "%s", _("Invalid parameter count")); goto cleanup; } if (cpuNum == VIR_NODE_CPU_STATS_ALL_CPUS) { strcpy(cpu_header, "cpu"); } else { snprintf(cpu_header, sizeof(cpu_header), "cpu%d", cpuNum); } while (fgets(line, sizeof(line), procstat) != NULL) { char *buf = line; if (STRPREFIX(buf, cpu_header)) { /* aka logical CPU time */ int i; if (sscanf(buf, "%*s %llu %llu %llu %llu %llu" // user ~ iowait "%llu %llu %llu %llu %llu", // irq ~ guest_nice &usr, &ni, &sys, &idle, &iowait, &irq, &softirq, &steal, &guest, &guest_nice) < 4) { continue; } for (i = 0; i < *nparams; i++) { virNodeCPUStatsPtr param = ¶ms[i]; switch (i) { case 0: /* fill kernel cpu time here */ if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_KERNEL) == NULL) { nodeReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Field kernel cpu time too long for destination")); goto cleanup; } param->value = (sys + irq + softirq) * TICK_TO_NSEC; break; case 1: /* fill user cpu time here */ if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_USER) == NULL) { nodeReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Field kernel cpu time too long for destination")); goto cleanup; } param->value = (usr + ni) * TICK_TO_NSEC; break; case 2: /* fill idle cpu time here */ if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_IDLE) == NULL) { nodeReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Field kernel cpu time too long for destination")); goto cleanup; } param->value = idle * TICK_TO_NSEC; break; case 3: /* fill iowait cpu time here */ if (virStrcpyStatic(param->field, VIR_NODE_CPU_STATS_IOWAIT) == NULL) { nodeReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Field kernel cpu time too long for destination")); goto cleanup; } param->value = iowait * TICK_TO_NSEC; break; default: break; /* should not hit here */ } } ret = 0; goto cleanup; } } nodeReportError(VIR_ERR_INVALID_ARG, "%s", _("Invalid cpu number")); cleanup: return ret; }
/* Convert a gid_t to string. Do not use this function directly. Instead, use it via the gidtostr macro. Beware that it returns a pointer to static storage. */ static char * gidtostr_ptr (gid_t const *gid) { static char buf[INT_BUFSIZE_BOUND (uintmax_t)]; return umaxtostr (*gid, buf); }
static int build_data (pskc_key_t * kp, xmlNodePtr keyp) { const char *b64secret = pskc_get_key_data_b64secret (kp); int counter_p; uint64_t counter = pskc_get_key_data_counter (kp, &counter_p); int t_p; uint32_t t = pskc_get_key_data_time (kp, &t_p); int tinterval_p; uint32_t tinterval = pskc_get_key_data_timeinterval (kp, &tinterval_p); int tdrift_p; uint32_t tdrift = pskc_get_key_data_timedrift (kp, &tdrift_p); xmlNodePtr data, sub; if (!b64secret && !counter_p && !t_p && !tinterval_p && !tdrift_p) return PSKC_OK; data = xmlNewChild (keyp, NULL, BAD_CAST "Data", NULL); if (b64secret) { sub = xmlNewChild (data, NULL, BAD_CAST "Secret", NULL); xmlNewTextChild (sub, NULL, BAD_CAST "PlainValue", BAD_CAST b64secret); } if (counter_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (counter, buf); sub = xmlNewChild (data, NULL, BAD_CAST "Counter", NULL); xmlNewTextChild (sub, NULL, BAD_CAST "PlainValue", BAD_CAST p); } if (t_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (t, buf); sub = xmlNewChild (data, NULL, BAD_CAST "Time", NULL); xmlNewTextChild (sub, NULL, BAD_CAST "PlainValue", BAD_CAST p); } if (tinterval_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (tinterval, buf); sub = xmlNewChild (data, NULL, BAD_CAST "TimeInterval", NULL); xmlNewTextChild (sub, NULL, BAD_CAST "PlainValue", BAD_CAST p); } if (tdrift_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (tdrift, buf); sub = xmlNewChild (data, NULL, BAD_CAST "TimeDrift", NULL); xmlNewTextChild (sub, NULL, BAD_CAST "PlainValue", BAD_CAST p); } return PSKC_OK; }
int virPidFileAcquirePath(const char *path, pid_t pid) { int fd = -1; char pidstr[INT_BUFSIZE_BOUND(pid)]; if (path[0] == '\0') return 0; while (1) { struct stat a, b; if ((fd = open(path, O_WRONLY|O_CREAT, 0644)) < 0) { virReportSystemError(errno, _("Failed to open pid file '%s'"), path); return -1; } if (virSetCloseExec(fd) < 0) { virReportSystemError(errno, _("Failed to set close-on-exec flag '%s'"), path); VIR_FORCE_CLOSE(fd); return -1; } if (fstat(fd, &b) < 0) { virReportSystemError(errno, _("Unable to check status of pid file '%s'"), path); VIR_FORCE_CLOSE(fd); return -1; } if (virFileLock(fd, false, 0, 1) < 0) { virReportSystemError(errno, _("Failed to acquire pid file '%s'"), path); VIR_FORCE_CLOSE(fd); return -1; } /* Now make sure the pidfile we locked is the same * one that now exists on the filesystem */ if (stat(path, &a) < 0) { char ebuf[1024] ATTRIBUTE_UNUSED; VIR_DEBUG("Pid file '%s' disappeared: %s", path, virStrerror(errno, ebuf, sizeof(ebuf))); VIR_FORCE_CLOSE(fd); /* Someone else must be racing with us, so try agin */ continue; } if (a.st_ino == b.st_ino) break; VIR_DEBUG("Pid file '%s' was recreated", path); VIR_FORCE_CLOSE(fd); /* Someone else must be racing with us, so try agin */ }
int virHostCPUGetStatsLinux(FILE *procstat, int cpuNum, virNodeCPUStatsPtr params, int *nparams) { int ret = -1; char line[1024]; unsigned long long usr, ni, sys, idle, iowait; unsigned long long irq, softirq, steal, guest, guest_nice; char cpu_header[4 + INT_BUFSIZE_BOUND(cpuNum)]; if ((*nparams) == 0) { /* Current number of cpu stats supported by linux */ *nparams = LINUX_NB_CPU_STATS; ret = 0; goto cleanup; } if ((*nparams) != LINUX_NB_CPU_STATS) { virReportInvalidArg(*nparams, _("nparams in %s must be equal to %d"), __FUNCTION__, LINUX_NB_CPU_STATS); goto cleanup; } if (cpuNum == VIR_NODE_CPU_STATS_ALL_CPUS) { strcpy(cpu_header, "cpu "); } else { snprintf(cpu_header, sizeof(cpu_header), "cpu%d ", cpuNum); } while (fgets(line, sizeof(line), procstat) != NULL) { char *buf = line; if (STRPREFIX(buf, cpu_header)) { /* aka logical CPU time */ if (sscanf(buf, "%*s %llu %llu %llu %llu %llu" // user ~ iowait "%llu %llu %llu %llu %llu", // irq ~ guest_nice &usr, &ni, &sys, &idle, &iowait, &irq, &softirq, &steal, &guest, &guest_nice) < 4) { continue; } if (virHostCPUStatsAssign(¶ms[0], VIR_NODE_CPU_STATS_KERNEL, (sys + irq + softirq) * TICK_TO_NSEC) < 0) goto cleanup; if (virHostCPUStatsAssign(¶ms[1], VIR_NODE_CPU_STATS_USER, (usr + ni) * TICK_TO_NSEC) < 0) goto cleanup; if (virHostCPUStatsAssign(¶ms[2], VIR_NODE_CPU_STATS_IDLE, idle * TICK_TO_NSEC) < 0) goto cleanup; if (virHostCPUStatsAssign(¶ms[3], VIR_NODE_CPU_STATS_IOWAIT, iowait * TICK_TO_NSEC) < 0) goto cleanup; ret = 0; goto cleanup; } } virReportInvalidArg(cpuNum, _("Invalid cpuNum in %s"), __FUNCTION__); cleanup: return ret; }
static int build_algparm (pskc_key_t * kp, xmlNodePtr keyp) { const char *suite = pskc_get_key_algparm_suite (kp); int chall_encoding_p; pskc_valueformat chall_encoding = pskc_get_key_algparm_chall_encoding (kp, &chall_encoding_p); int chall_min_p; uint32_t chall_min = pskc_get_key_algparm_chall_min (kp, &chall_min_p); int chall_max_p; uint32_t chall_max = pskc_get_key_algparm_chall_max (kp, &chall_max_p); int chall_checkdigits_p; int chall_checkdigits = pskc_get_key_algparm_chall_checkdigits (kp, &chall_checkdigits_p); int resp_encoding_p; pskc_valueformat resp_encoding = pskc_get_key_algparm_resp_encoding (kp, &resp_encoding_p); int resp_length_p; uint32_t resp_length = pskc_get_key_algparm_resp_length (kp, &resp_length_p); int resp_checkdigits_p; int resp_checkdigits = pskc_get_key_algparm_resp_checkdigits (kp, &resp_checkdigits_p); xmlNodePtr algparm; if (!suite && !chall_encoding_p && !chall_min_p && !chall_max_p && !chall_checkdigits_p && !resp_encoding_p && !resp_length_p && !resp_checkdigits_p) return PSKC_OK; algparm = xmlNewChild (keyp, NULL, BAD_CAST "AlgorithmParameters", NULL); if (suite) xmlNewTextChild (algparm, NULL, BAD_CAST "Suite", BAD_CAST suite); if (chall_encoding_p || chall_min_p || chall_max_p || resp_checkdigits_p) { xmlNodePtr chall; chall = xmlNewChild (algparm, NULL, BAD_CAST "ChallengeFormat", NULL); if (chall_encoding_p) xmlNewProp (chall, BAD_CAST "Encoding", BAD_CAST pskc_valueformat2str (chall_encoding)); if (chall_min_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (chall_min, buf); xmlNewProp (chall, BAD_CAST "Min", BAD_CAST p); } if (chall_max_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (chall_max, buf); xmlNewProp (chall, BAD_CAST "Max", BAD_CAST p); } if (chall_checkdigits_p && chall_checkdigits) xmlNewProp (chall, BAD_CAST "CheckDigits", BAD_CAST "true"); } if (resp_encoding_p || resp_length_p || resp_checkdigits_p) { xmlNodePtr resp; resp = xmlNewChild (algparm, NULL, BAD_CAST "ResponseFormat", NULL); if (resp_encoding_p) xmlNewProp (resp, BAD_CAST "Encoding", BAD_CAST pskc_valueformat2str (resp_encoding)); if (resp_length_p) { char buf[INT_BUFSIZE_BOUND (uintmax_t)]; char *p = umaxtostr (resp_length, buf); xmlNewProp (resp, BAD_CAST "Length", BAD_CAST p); } if (resp_checkdigits_p && resp_checkdigits) xmlNewProp (resp, BAD_CAST "CheckDigits", BAD_CAST "true"); } return PSKC_OK; }