int process_config_line(Options *options, const char *host, char *line, const char *filename, int linenum, int *activep) { char *s, **charptr, *endofnumber, *keyword, *arg, *arg2; char **cpptr, fwdarg[256]; u_int *uintptr, max_entries = 0; int negated, opcode, *intptr, value, value2, scale; LogLevel *log_level_ptr; long long orig, val64; size_t len; Forward fwd; /* Strip trailing whitespace */ for (len = strlen(line) - 1; len > 0; len--) { if (strchr(WHITESPACE, line[len]) == NULL) break; line[len] = '\0'; } s = line; /* Get the keyword. (Each line is supposed to begin with a keyword). */ if ((keyword = strdelim(&s)) == NULL) return 0; /* Ignore leading whitespace. */ if (*keyword == '\0') keyword = strdelim(&s); if (keyword == NULL || !*keyword || *keyword == '\n' || *keyword == '#') return 0; opcode = parse_token(keyword, filename, linenum); switch (opcode) { case oBadOption: /* don't panic, but count bad options */ return -1; /* NOTREACHED */ case oConnectTimeout: intptr = &options->connection_timeout; parse_time: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%s line %d: missing time value.", filename, linenum); if ((value = convtime(arg)) == -1) fatal("%s line %d: invalid time value.", filename, linenum); if (*activep && *intptr == -1) *intptr = value; break; case oForwardAgent: intptr = &options->forward_agent; parse_flag: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing yes/no argument.", filename, linenum); value = 0; /* To avoid compiler warning... */ if (strcmp(arg, "yes") == 0 || strcmp(arg, "true") == 0) value = 1; else if (strcmp(arg, "no") == 0 || strcmp(arg, "false") == 0) value = 0; else fatal("%.200s line %d: Bad yes/no argument.", filename, linenum); if (*activep && *intptr == -1) *intptr = value; break; case oForwardX11: intptr = &options->forward_x11; goto parse_flag; case oForwardX11Trusted: intptr = &options->forward_x11_trusted; goto parse_flag; case oForwardX11Timeout: intptr = &options->forward_x11_timeout; goto parse_time; case oGatewayPorts: intptr = &options->gateway_ports; goto parse_flag; case oExitOnForwardFailure: intptr = &options->exit_on_forward_failure; goto parse_flag; case oUsePrivilegedPort: intptr = &options->use_privileged_port; goto parse_flag; case oPasswordAuthentication: intptr = &options->password_authentication; goto parse_flag; case oZeroKnowledgePasswordAuthentication: intptr = &options->zero_knowledge_password_authentication; goto parse_flag; case oKbdInteractiveAuthentication: intptr = &options->kbd_interactive_authentication; goto parse_flag; case oKbdInteractiveDevices: charptr = &options->kbd_interactive_devices; goto parse_string; case oPubkeyAuthentication: intptr = &options->pubkey_authentication; goto parse_flag; case oRSAAuthentication: intptr = &options->rsa_authentication; goto parse_flag; case oRhostsRSAAuthentication: intptr = &options->rhosts_rsa_authentication; goto parse_flag; case oHostbasedAuthentication: intptr = &options->hostbased_authentication; goto parse_flag; case oChallengeResponseAuthentication: intptr = &options->challenge_response_authentication; goto parse_flag; #if defined(KRB4) || defined(KRB5) case oKerberosAuthentication: intptr = &options->kerberos_authentication; goto parse_flag; #endif #if defined(AFS) || defined(KRB5) case oKerberosTgtPassing: intptr = &options->kerberos_tgt_passing; goto parse_flag; #endif case oGssAuthentication: intptr = &options->gss_authentication; goto parse_flag; #ifdef AFS case oAFSTokenPassing: intptr = &options->afs_token_passing; goto parse_flag; #endif case oGssDelegateCreds: intptr = &options->gss_deleg_creds; goto parse_flag; case oBatchMode: intptr = &options->batch_mode; goto parse_flag; case oCheckHostIP: intptr = &options->check_host_ip; goto parse_flag; case oNoneEnabled: intptr = &options->none_enabled; goto parse_flag; /* we check to see if the command comes from the */ /* command line or not. If it does then enable it */ /* otherwise fail. NONE should never be a default configuration */ case oNoneSwitch: if(strcmp(filename,"command-line")==0) { intptr = &options->none_switch; goto parse_flag; } else { error("NoneSwitch is found in %.200s.\nYou may only use this configuration option from the command line", filename); error("Continuing..."); debug("NoneSwitch directive found in %.200s.", filename); return 0; } case oHPNDisabled: intptr = &options->hpn_disabled; goto parse_flag; case oHPNBufferSize: intptr = &options->hpn_buffer_size; goto parse_int; case oTcpRcvBufPoll: intptr = &options->tcp_rcv_buf_poll; goto parse_flag; case oVerifyHostKeyDNS: intptr = &options->verify_host_key_dns; goto parse_yesnoask; case oStrictHostKeyChecking: intptr = &options->strict_host_key_checking; parse_yesnoask: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing yes/no/ask argument.", filename, linenum); value = 0; /* To avoid compiler warning... */ if (strcmp(arg, "yes") == 0 || strcmp(arg, "true") == 0) value = 1; else if (strcmp(arg, "no") == 0 || strcmp(arg, "false") == 0) value = 0; else if (strcmp(arg, "ask") == 0) value = 2; else fatal("%.200s line %d: Bad yes/no/ask argument.", filename, linenum); if (*activep && *intptr == -1) *intptr = value; break; case oCompression: intptr = &options->compression; goto parse_flag; case oTCPKeepAlive: intptr = &options->tcp_keep_alive; goto parse_flag; case oNoHostAuthenticationForLocalhost: intptr = &options->no_host_authentication_for_localhost; goto parse_flag; case oNumberOfPasswordPrompts: intptr = &options->number_of_password_prompts; goto parse_int; case oCompressionLevel: intptr = &options->compression_level; goto parse_int; case oRekeyLimit: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (arg[0] < '0' || arg[0] > '9') fatal("%.200s line %d: Bad number.", filename, linenum); orig = val64 = strtoll(arg, &endofnumber, 10); if (arg == endofnumber) fatal("%.200s line %d: Bad number.", filename, linenum); switch (toupper((unsigned char)*endofnumber)) { case '\0': scale = 1; break; case 'K': scale = 1<<10; break; case 'M': scale = 1<<20; break; case 'G': scale = 1<<30; break; default: scale = 0; fatal("%.200s line %d: Invalid RekeyLimit suffix", filename, linenum); } val64 *= scale; /* detect integer wrap and too-large limits */ if ((val64 / scale) != orig || val64 > UINT_MAX) fatal("%.200s line %d: RekeyLimit too large", filename, linenum); if (val64 < 16) fatal("%.200s line %d: RekeyLimit too small", filename, linenum); if (*activep && options->rekey_limit == -1) options->rekey_limit = (u_int32_t)val64; break; case oIdentityFile: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (*activep) { intptr = &options->num_identity_files; if (*intptr >= SSH_MAX_IDENTITY_FILES) fatal("%.200s line %d: Too many identity files specified (max %d).", filename, linenum, SSH_MAX_IDENTITY_FILES); charptr = &options->identity_files[*intptr]; *charptr = xstrdup(arg); *intptr = *intptr + 1; } break; case oXAuthLocation: charptr=&options->xauth_location; goto parse_string; case oUser: charptr = &options->user; parse_string: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (*activep && *charptr == NULL) *charptr = xstrdup(arg); break; case oGlobalKnownHostsFile: cpptr = (char **)&options->system_hostfiles; uintptr = &options->num_system_hostfiles; max_entries = SSH_MAX_HOSTS_FILES; parse_char_array: if (*activep && *uintptr == 0) { while ((arg = strdelim(&s)) != NULL && *arg != '\0') { if ((*uintptr) >= max_entries) fatal("%s line %d: " "too many authorized keys files.", filename, linenum); cpptr[(*uintptr)++] = xstrdup(arg); } } return 0; case oUserKnownHostsFile: cpptr = (char **)&options->user_hostfiles; uintptr = &options->num_user_hostfiles; max_entries = SSH_MAX_HOSTS_FILES; goto parse_char_array; case oHostName: charptr = &options->hostname; goto parse_string; case oHostKeyAlias: charptr = &options->host_key_alias; goto parse_string; case oPreferredAuthentications: charptr = &options->preferred_authentications; goto parse_string; case oBindAddress: charptr = &options->bind_address; goto parse_string; case oPKCS11Provider: charptr = &options->pkcs11_provider; goto parse_string; case oProxyCommand: charptr = &options->proxy_command; parse_command: if (s == NULL) fatal("%.200s line %d: Missing argument.", filename, linenum); len = strspn(s, WHITESPACE "="); if (*activep && *charptr == NULL) *charptr = xstrdup(s + len); return 0; case oPort: intptr = &options->port; parse_int: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (arg[0] < '0' || arg[0] > '9') fatal("%.200s line %d: Bad number.", filename, linenum); /* Octal, decimal, or hex format? */ value = strtol(arg, &endofnumber, 0); if (arg == endofnumber) fatal("%.200s line %d: Bad number.", filename, linenum); if (*activep && *intptr == -1) *intptr = value; break; case oConnectionAttempts: intptr = &options->connection_attempts; goto parse_int; case oTcpRcvBuf: intptr = &options->tcp_rcv_buf; goto parse_int; case oCipher: intptr = &options->cipher; arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); value = cipher_number(arg); if (value == -1) fatal("%.200s line %d: Bad cipher '%s'.", filename, linenum, arg ? arg : "<NONE>"); if (*activep && *intptr == -1) *intptr = value; break; case oCiphers: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (!ciphers_valid(arg)) fatal("%.200s line %d: Bad SSH2 cipher spec '%s'.", filename, linenum, arg ? arg : "<NONE>"); if (*activep && options->ciphers == NULL) options->ciphers = xstrdup(arg); break; case oMacs: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (!mac_valid(arg)) fatal("%.200s line %d: Bad SSH2 Mac spec '%s'.", filename, linenum, arg ? arg : "<NONE>"); if (*activep && options->macs == NULL) options->macs = xstrdup(arg); break; case oKexAlgorithms: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (!kex_names_valid(arg)) fatal("%.200s line %d: Bad SSH2 KexAlgorithms '%s'.", filename, linenum, arg ? arg : "<NONE>"); if (*activep && options->kex_algorithms == NULL) options->kex_algorithms = xstrdup(arg); break; case oHostKeyAlgorithms: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); if (!key_names_valid2(arg)) fatal("%.200s line %d: Bad protocol 2 host key algorithms '%s'.", filename, linenum, arg ? arg : "<NONE>"); if (*activep && options->hostkeyalgorithms == NULL) options->hostkeyalgorithms = xstrdup(arg); break; case oProtocol: intptr = &options->protocol; arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); value = proto_spec(arg); if (value == SSH_PROTO_UNKNOWN) fatal("%.200s line %d: Bad protocol spec '%s'.", filename, linenum, arg ? arg : "<NONE>"); if (*activep && *intptr == SSH_PROTO_UNKNOWN) *intptr = value; break; case oLogLevel: log_level_ptr = &options->log_level; arg = strdelim(&s); value = log_level_number(arg); if (value == SYSLOG_LEVEL_NOT_SET) fatal("%.200s line %d: unsupported log level '%s'", filename, linenum, arg ? arg : "<NONE>"); if (*activep && *log_level_ptr == SYSLOG_LEVEL_NOT_SET) *log_level_ptr = (LogLevel) value; break; case oLocalForward: case oRemoteForward: case oDynamicForward: arg = strdelim(&s); if (arg == NULL || *arg == '\0') fatal("%.200s line %d: Missing port argument.", filename, linenum); if (opcode == oLocalForward || opcode == oRemoteForward) { arg2 = strdelim(&s); if (arg2 == NULL || *arg2 == '\0') fatal("%.200s line %d: Missing target argument.", filename, linenum); /* construct a string for parse_forward */ snprintf(fwdarg, sizeof(fwdarg), "%s:%s", arg, arg2); } else if (opcode == oDynamicForward) { strlcpy(fwdarg, arg, sizeof(fwdarg)); } if (parse_forward(&fwd, fwdarg, opcode == oDynamicForward ? 1 : 0, opcode == oRemoteForward ? 1 : 0) == 0) fatal("%.200s line %d: Bad forwarding specification.", filename, linenum); if (*activep) { if (opcode == oLocalForward || opcode == oDynamicForward) add_local_forward(options, &fwd); else if (opcode == oRemoteForward) add_remote_forward(options, &fwd); } break; case oClearAllForwardings: intptr = &options->clear_forwardings; goto parse_flag; case oHost: *activep = 0; arg2 = NULL; while ((arg = strdelim(&s)) != NULL && *arg != '\0') { negated = *arg == '!'; if (negated) arg++; if (match_pattern(host, arg)) { if (negated) { debug("%.200s line %d: Skipping Host " "block because of negated match " "for %.100s", filename, linenum, arg); *activep = 0; break; } if (!*activep) arg2 = arg; /* logged below */ *activep = 1; } } if (*activep) debug("%.200s line %d: Applying options for %.100s", filename, linenum, arg2); /* Avoid garbage check below, as strdelim is done. */ return 0; case oEscapeChar: intptr = &options->escape_char; arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); value = 0; /* To avoid compiler warning... */ if (arg[0] == '^' && arg[2] == 0 && (u_char) arg[1] >= 64 && (u_char) arg[1] < 128) value = (u_char) arg[1] & 31; else if (strlen(arg) == 1) value = (u_char) arg[0]; else if (strcmp(arg, "none") == 0) value = SSH_ESCAPECHAR_NONE; else { fatal("%.200s line %d: Bad escape character.", filename, linenum); /* NOTREACHED */ value = 0; /* Avoid compiler warning. */ } if (*activep && *intptr == -1) *intptr = value; break; case oAddressFamily: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%s line %d: missing address family.", filename, linenum); intptr = &options->address_family; value = 0; /* To avoid compiler warning... */ if (strcasecmp(arg, "inet") == 0) value = AF_INET; else if (strcasecmp(arg, "inet6") == 0) value = AF_INET6; else if (strcasecmp(arg, "any") == 0) value = AF_UNSPEC; else fatal("Unsupported AddressFamily \"%s\"", arg); if (*activep && *intptr == -1) *intptr = value; break; case oEnableSSHKeysign: intptr = &options->enable_ssh_keysign; goto parse_flag; case oIdentitiesOnly: intptr = &options->identities_only; goto parse_flag; case oServerAliveInterval: intptr = &options->server_alive_interval; goto parse_time; case oServerAliveCountMax: intptr = &options->server_alive_count_max; goto parse_int; case oSendEnv: while ((arg = strdelim(&s)) != NULL && *arg != '\0') { if (strchr(arg, '=') != NULL) fatal("%s line %d: Invalid environment name.", filename, linenum); if (!*activep) continue; if (options->num_send_env >= MAX_SEND_ENV) fatal("%s line %d: too many send env.", filename, linenum); options->send_env[options->num_send_env++] = xstrdup(arg); } break; case oControlPath: charptr = &options->control_path; goto parse_string; case oControlMaster: intptr = &options->control_master; arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing ControlMaster argument.", filename, linenum); value = 0; /* To avoid compiler warning... */ if (strcmp(arg, "yes") == 0 || strcmp(arg, "true") == 0) value = SSHCTL_MASTER_YES; else if (strcmp(arg, "no") == 0 || strcmp(arg, "false") == 0) value = SSHCTL_MASTER_NO; else if (strcmp(arg, "auto") == 0) value = SSHCTL_MASTER_AUTO; else if (strcmp(arg, "ask") == 0) value = SSHCTL_MASTER_ASK; else if (strcmp(arg, "autoask") == 0) value = SSHCTL_MASTER_AUTO_ASK; else fatal("%.200s line %d: Bad ControlMaster argument.", filename, linenum); if (*activep && *intptr == -1) *intptr = value; break; case oControlPersist: /* no/false/yes/true, or a time spec */ intptr = &options->control_persist; arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing ControlPersist" " argument.", filename, linenum); value = 0; value2 = 0; /* timeout */ if (strcmp(arg, "no") == 0 || strcmp(arg, "false") == 0) value = 0; else if (strcmp(arg, "yes") == 0 || strcmp(arg, "true") == 0) value = 1; else if ((value2 = convtime(arg)) >= 0) value = 1; else fatal("%.200s line %d: Bad ControlPersist argument.", filename, linenum); if (*activep && *intptr == -1) { *intptr = value; options->control_persist_timeout = value2; } break; case oHashKnownHosts: intptr = &options->hash_known_hosts; goto parse_flag; case oTunnel: intptr = &options->tun_open; arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%s line %d: Missing yes/point-to-point/" "ethernet/no argument.", filename, linenum); value = 0; /* silence compiler */ if (strcasecmp(arg, "ethernet") == 0) value = SSH_TUNMODE_ETHERNET; else if (strcasecmp(arg, "point-to-point") == 0) value = SSH_TUNMODE_POINTOPOINT; else if (strcasecmp(arg, "yes") == 0) value = SSH_TUNMODE_DEFAULT; else if (strcasecmp(arg, "no") == 0) value = SSH_TUNMODE_NO; else fatal("%s line %d: Bad yes/point-to-point/ethernet/" "no argument: %s", filename, linenum, arg); if (*activep) *intptr = value; break; case oTunnelDevice: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%.200s line %d: Missing argument.", filename, linenum); value = a2tun(arg, &value2); if (value == SSH_TUNID_ERR) fatal("%.200s line %d: Bad tun device.", filename, linenum); if (*activep) { options->tun_local = value; options->tun_remote = value2; } break; case oLocalCommand: charptr = &options->local_command; goto parse_command; case oPermitLocalCommand: intptr = &options->permit_local_command; goto parse_flag; case oVisualHostKey: intptr = &options->visual_host_key; goto parse_flag; case oIPQoS: arg = strdelim(&s); if ((value = parse_ipqos(arg)) == -1) fatal("%s line %d: Bad IPQoS value: %s", filename, linenum, arg); arg = strdelim(&s); if (arg == NULL) value2 = value; else if ((value2 = parse_ipqos(arg)) == -1) fatal("%s line %d: Bad IPQoS value: %s", filename, linenum, arg); if (*activep) { options->ip_qos_interactive = value; options->ip_qos_bulk = value2; } break; case oUseRoaming: intptr = &options->use_roaming; goto parse_flag; case oRequestTTY: arg = strdelim(&s); if (!arg || *arg == '\0') fatal("%s line %d: missing argument.", filename, linenum); intptr = &options->request_tty; if (strcasecmp(arg, "yes") == 0) value = REQUEST_TTY_YES; else if (strcasecmp(arg, "no") == 0) value = REQUEST_TTY_NO; else if (strcasecmp(arg, "force") == 0) value = REQUEST_TTY_FORCE; else if (strcasecmp(arg, "auto") == 0) value = REQUEST_TTY_AUTO; else fatal("Unsupported RequestTTY \"%s\"", arg); if (*activep && *intptr == -1) *intptr = value; break; case oDeprecated: debug("%s line %d: Deprecated option \"%s\"", filename, linenum, keyword); return 0; case oUnsupported: error("%s line %d: Unsupported option \"%s\"", filename, linenum, keyword); return 0; default: fatal("process_config_line: Unimplemented opcode %d", opcode); } /* Check that there is no garbage at end of line. */ if ((arg = strdelim(&s)) != NULL && *arg != '\0') { fatal("%.200s line %d: garbage at end of line; \"%.200s\".", filename, linenum, arg); } return 0; }
int main(int argc, char *argv[]) { char *buf; size_t bufsiz; const char *format; int ch; setprogname(argv[0]); (void)setlocale(LC_ALL, ""); while ((ch = getopt(argc, argv, "ad:jnr:u")) != -1) { switch (ch) { case 'a': /* adjust time slowly */ aflag = 1; nflag = 1; break; case 'd': rflag = 1; tval = parsedate(optarg, NULL, NULL); if (tval == -1) errx(1, "Cannot parse `%s'", optarg); break; case 'j': /* don't set time */ jflag = 1; break; case 'n': /* don't set network */ nflag = 1; break; case 'r': /* user specified seconds */ rflag = 1; tval = strtoll(optarg, NULL, 0); break; case 'u': /* do everything in UTC */ (void)putenv("TZ=UTC0"); break; default: usage(); } } argc -= optind; argv += optind; if (!rflag && time(&tval) == -1) err(EXIT_FAILURE, "time"); format = "%a %b %e %H:%M:%S %Z %Y"; /* allow the operands in any order */ if (*argv && **argv == '+') { format = *argv + 1; ++argv; } if (*argv) { setthetime(*argv); ++argv; } if (*argv && **argv == '+') format = *argv + 1; if ((buf = malloc(bufsiz = 1024)) == NULL) goto bad; while (strftime(buf, bufsiz, format, localtime(&tval)) == 0) if ((buf = realloc(buf, bufsiz <<= 1)) == NULL) goto bad; (void)printf("%s\n", buf); free(buf); return 0; bad: err(1, "Cannot allocate format buffer"); }
int main(int argc, char ** argv) { struct stat statbuf; struct swap_header_v1_2 *hdr; int i; unsigned long long maxpages; unsigned long long goodpages; unsigned long long sz; off_t offset; int force = 0; int version = 1; char *block_count = 0; char *pp; char *opt_label = NULL; unsigned char *uuid = NULL; #ifdef HAVE_LIBUUID const char *opt_uuid = NULL; uuid_t uuid_dat; #endif program_name = (argc && *argv) ? argv[0] : "mkswap"; if ((pp = strrchr(program_name, '/')) != NULL) program_name = pp+1; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); if (argc == 2 && (!strcmp(argv[1], "-V") || !strcmp(argv[1], "--version"))) { printf(_("%s (%s)\n"), program_name, PACKAGE_STRING); exit(0); } for (i=1; i<argc; i++) { if (argv[i][0] == '-') { switch (argv[i][1]) { case 'c': check=1; break; case 'f': force=1; break; case 'p': pp = argv[i]+2; if (!*pp && i+1 < argc) pp = argv[++i]; if (isnzdigit(*pp)) user_pagesize = atoi(pp); else usage(); break; case 'L': pp = argv[i]+2; if (!*pp && i+1 < argc) pp = argv[++i]; opt_label = pp; break; case 'v': version = atoi(argv[i]+2); break; case 'U': #ifdef HAVE_LIBUUID opt_uuid = argv[i]+2; if (!*opt_uuid && i+1 < argc) opt_uuid = argv[++i]; #else fprintf(stderr, _("%1$s: warning: ignore -U (UUIDs are unsupported by %1$s)\n"), program_name); #endif break; default: usage(); } } else if (!device_name) { device_name = argv[i]; } else if (!block_count) { block_count = argv[i]; } else usage(); } if (version != 1) { fprintf(stderr, _("%s: does not support swapspace version %d.\n"), program_name, version); exit(EXIT_FAILURE); } #ifdef HAVE_LIBUUID if(opt_uuid) { if (uuid_parse(opt_uuid, uuid_dat) != 0) die(_("error: UUID parsing failed")); } else uuid_generate(uuid_dat); uuid = uuid_dat; #endif init_signature_page(); /* get pagesize */ atexit(deinit_signature_page); if (!device_name) { fprintf(stderr, _("%s: error: Nowhere to set up swap on?\n"), program_name); usage(); } if (block_count) { /* this silly user specified the number of blocks explicitly */ char *tmp = NULL; long long blks; errno = 0; blks = strtoll(block_count, &tmp, 0); if ((tmp == block_count) || (tmp && *tmp) || (errno != 0 && (blks == LLONG_MAX || blks == LLONG_MIN)) || blks < 0) usage(); PAGES = blks / (pagesize / 1024); } sz = get_size(device_name); if (!PAGES) { PAGES = sz; } else if (PAGES > sz && !force) { fprintf(stderr, _("%s: error: " "size %llu KiB is larger than device size %llu KiB\n"), program_name, PAGES*(pagesize/1024), sz*(pagesize/1024)); exit(1); } if (PAGES < MIN_GOODPAGES) { fprintf(stderr, _("%s: error: swap area needs to be at least %ld KiB\n"), program_name, (long)(MIN_GOODPAGES * pagesize/1024)); usage(); } #ifdef __linux__ if (get_linux_version() >= KERNEL_VERSION(2,3,4)) maxpages = UINT_MAX + 1ULL; else if (get_linux_version() >= KERNEL_VERSION(2,2,1)) maxpages = V1_MAX_PAGES; else #endif maxpages = V1_OLD_MAX_PAGES; if (PAGES > maxpages) { PAGES = maxpages; fprintf(stderr, _("%s: warning: truncating swap area to %llu KiB\n"), program_name, PAGES * pagesize / 1024); } if (stat(device_name, &statbuf) < 0) { perror(device_name); exit(EXIT_FAILURE); } if (S_ISBLK(statbuf.st_mode)) DEV = open(device_name, O_RDWR | O_EXCL); else DEV = open(device_name, O_RDWR); if (DEV < 0) { perror(device_name); exit(1); } /* Want a block device. Probably not /dev/hda or /dev/hdb. */ if (!S_ISBLK(statbuf.st_mode)) check=0; else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) { fprintf(stderr, _("%s: error: " "will not try to make swapdevice on '%s'\n"), program_name, device_name); exit(1); } else if (check_mount()) { fprintf(stderr, _("%s: error: " "%s is mounted; will not make swapspace.\n"), program_name, device_name); exit(1); } if (check) check_blocks(); zap_bootbits(DEV, device_name, force, S_ISBLK(statbuf.st_mode)); hdr = (struct swap_header_v1_2 *) signature_page; hdr->version = 1; hdr->last_page = PAGES - 1; hdr->nr_badpages = badpages; if (badpages > PAGES - MIN_GOODPAGES) die(_("Unable to set up swap-space: unreadable")); goodpages = PAGES - badpages - 1; printf(_("Setting up swapspace version 1, size = %llu KiB\n"), goodpages * pagesize / 1024); write_signature("SWAPSPACE2"); write_uuid_and_label(uuid, opt_label); offset = 1024; if (lseek(DEV, offset, SEEK_SET) != offset) die(_("unable to rewind swap-device")); if (write_all(DEV, (char *) signature_page + offset, pagesize - offset) == -1) { fprintf(stderr, _("%s: %s: unable to write signature page: %s"), program_name, device_name, strerror(errno)); exit(1); } /* * A subsequent swapon() will fail if the signature * is not actually on disk. (This is a kernel bug.) */ #ifdef HAVE_FSYNC if (fsync(DEV)) die(_("fsync failed")); #endif #ifdef HAVE_LIBSELINUX if (S_ISREG(statbuf.st_mode) && is_selinux_enabled() > 0) { security_context_t context_string; security_context_t oldcontext; context_t newcontext; if (fgetfilecon(DEV, &oldcontext) < 0) { if (errno != ENODATA) { fprintf(stderr, _("%s: %s: unable to obtain selinux file label: %s\n"), program_name, device_name, strerror(errno)); exit(1); } if (matchpathcon(device_name, statbuf.st_mode, &oldcontext)) die(_("unable to matchpathcon()")); } if (!(newcontext = context_new(oldcontext))) die(_("unable to create new selinux context")); if (context_type_set(newcontext, SELINUX_SWAPFILE_TYPE)) die(_("couldn't compute selinux context")); context_string = context_str(newcontext); if (strcmp(context_string, oldcontext)!=0) { if (fsetfilecon(DEV, context_string)) { fprintf(stderr, _("%s: unable to relabel %s to %s: %s\n"), program_name, device_name, context_string, strerror(errno)); exit(1); } } context_free(newcontext); freecon(oldcontext); } #endif return 0; }
int main(int argc, char *argv[]) { int r; int fd; struct stat sb; char *addr; u64 gcov_list_addr; printf("sizes: %zu %zu %zu %zu\n", sizeof(gcov_unsigned_int), sizeof(struct gcov_ctr_info), sizeof(struct gcov_fn_info), sizeof(struct gcov_info)); if (argc < 3) { fprintf(stderr, "Usage:\n" "\t%s skiboot.dump gcov_offset\n\n", argv[0]); return -1; } /* argv[1] = skiboot.dump */ fd = open(argv[1], O_RDONLY); if (fd < 0) { fprintf(stderr, "Cannot open dump: %s (error %d %s)\n", argv[1], errno, strerror(errno)); exit(-1); } r = fstat(fd, &sb); if (r < 0) { fprintf(stderr, "Cannot stat dump, %d %s\n", errno, strerror(errno)); exit(-1); } addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0); assert(addr != NULL); skiboot_dump_size = sb.st_size; printf("Skiboot memory dump %p - %p\n", (void*)SKIBOOT_OFFSET, (void*)SKIBOOT_OFFSET+sb.st_size); gcov_list_addr = strtoll(argv[2], NULL, 0); gcov_list_addr = (u64)(addr + (gcov_list_addr - SKIBOOT_OFFSET)); gcov_list_addr = be64toh(*(u64*)gcov_list_addr); printf("Skiboot gcov_info_list at %p\n", (void*)gcov_list_addr); do { gcov_info_list = (struct gcov_info *)(addr + (gcov_list_addr - SKIBOOT_OFFSET)); write_gcda(addr, gcov_info_list); gcov_list_addr = be64toh((u64)gcov_info_list->next); } while(gcov_list_addr); munmap(addr, sb.st_size); close(fd); return 0; }
// //========================================================================= // int main(int argc, char **argv) { int j; // Set sane defaults modesInitConfig(); signal(SIGINT, sigintHandler); // Define Ctrl/C handler (exit program) // Parse the command line options for (j = 1; j < argc; j++) { int more = j+1 < argc; // There are more arguments if (!strcmp(argv[j],"--device-index") && more) { Modes.dev_index = verbose_device_search(argv[++j]); } else if (!strcmp(argv[j],"--gain") && more) { Modes.gain = (int) atof(argv[++j])*10; // Gain is in tens of DBs } else if (!strcmp(argv[j],"--enable-agc")) { Modes.enable_agc++; } else if (!strcmp(argv[j],"--freq") && more) { Modes.freq = (int) strtoll(argv[++j],NULL,10); } else if (!strcmp(argv[j],"--ifile") && more) { Modes.filename = strdup(argv[++j]); } else if (!strcmp(argv[j],"--fix")) { Modes.nfix_crc = 1; } else if (!strcmp(argv[j],"--no-fix")) { Modes.nfix_crc = 0; } else if (!strcmp(argv[j],"--no-crc-check")) { Modes.check_crc = 0; } else if (!strcmp(argv[j],"--phase-enhance")) { Modes.phase_enhance = 1; } else if (!strcmp(argv[j],"--raw")) { Modes.raw = 1; } else if (!strcmp(argv[j],"--net")) { Modes.net = 1; } else if (!strcmp(argv[j],"--modeac")) { Modes.mode_ac = 1; } else if (!strcmp(argv[j],"--net-beast")) { Modes.beast = 1; } else if (!strcmp(argv[j],"--net-only")) { Modes.net = 1; Modes.net_only = 1; } else if (!strcmp(argv[j],"--net-heartbeat") && more) { Modes.net_heartbeat_rate = atoi(argv[++j]) * 15; } else if (!strcmp(argv[j],"--net-ro-size") && more) { Modes.net_output_raw_size = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-ro-rate") && more) { Modes.net_output_raw_rate = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-ro-port") && more) { if (Modes.beast) // Required for legacy backward compatibility {Modes.net_output_beast_port = atoi(argv[++j]);;} else {Modes.net_output_raw_port = atoi(argv[++j]);} } else if (!strcmp(argv[j],"--net-ri-port") && more) { Modes.net_input_raw_port = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-bo-port") && more) { Modes.net_output_beast_port = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-bi-port") && more) { Modes.net_input_beast_port = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-http-port") && more) { Modes.net_http_port = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-sbs-port") && more) { Modes.net_output_sbs_port = atoi(argv[++j]); } else if (!strcmp(argv[j],"--net-buffer") && more) { Modes.net_sndbuf_size = atoi(argv[++j]); } else if (!strcmp(argv[j],"--onlyaddr")) { Modes.onlyaddr = 1; } else if (!strcmp(argv[j],"--metric")) { Modes.metric = 1; } else if (!strcmp(argv[j],"--aggressive")) { Modes.nfix_crc = MODES_MAX_BITERRORS; } else if (!strcmp(argv[j],"--interactive")) { Modes.interactive = 1; } else if (!strcmp(argv[j],"--interactive-rows") && more) { Modes.interactive_rows = atoi(argv[++j]); } else if (!strcmp(argv[j],"--interactive-ttl") && more) { Modes.interactive_display_ttl = atoi(argv[++j]); } else if (!strcmp(argv[j],"--lat") && more) { Modes.fUserLat = atof(argv[++j]); } else if (!strcmp(argv[j],"--lon") && more) { Modes.fUserLon = atof(argv[++j]); } else if (!strcmp(argv[j],"--debug") && more) { char *f = argv[++j]; while(*f) { switch(*f) { case 'D': Modes.debug |= MODES_DEBUG_DEMOD; break; case 'd': Modes.debug |= MODES_DEBUG_DEMODERR; break; case 'C': Modes.debug |= MODES_DEBUG_GOODCRC; break; case 'c': Modes.debug |= MODES_DEBUG_BADCRC; break; case 'p': Modes.debug |= MODES_DEBUG_NOPREAMBLE; break; case 'n': Modes.debug |= MODES_DEBUG_NET; break; case 'j': Modes.debug |= MODES_DEBUG_JS; break; default: fprintf(stderr, "Unknown debugging flag: %c\n", *f); exit(1); break; } f++; } } else if (!strcmp(argv[j],"--stats")) { Modes.stats = 1; } else if (!strcmp(argv[j],"--snip") && more) { snipMode(atoi(argv[++j])); exit(0); } else if (!strcmp(argv[j],"--help")) { showHelp(); exit(0); } else if (!strcmp(argv[j],"--ppm") && more) { Modes.ppm_error = atoi(argv[++j]); } else if (!strcmp(argv[j],"--quiet")) { Modes.quiet = 1; } else if (!strcmp(argv[j],"--mlat")) { Modes.mlat = 1; } else if (!strcmp(argv[j],"--interactive-rtl1090")) { Modes.interactive = 1; Modes.interactive_rtl1090 = 1; } else { fprintf(stderr, "Unknown or not enough arguments for option '%s'.\n\n", argv[j]); showHelp(); exit(1); } } #ifdef _WIN32 // Try to comply with the Copyright license conditions for binary distribution if (!Modes.quiet) {showCopyright();} #endif #ifndef _WIN32 // Setup for SIGWINCH for handling lines if (Modes.interactive) {signal(SIGWINCH, sigWinchCallback);} #endif // Initialization modesInit(); if (Modes.net_only) { fprintf(stderr,"Net-only mode, no RTL device or file open.\n"); } else if (Modes.filename == NULL) { modesInitRTLSDR(); } else { if (Modes.filename[0] == '-' && Modes.filename[1] == '\0') { Modes.fd = STDIN_FILENO; } else if ((Modes.fd = open(Modes.filename,O_RDONLY)) == -1) { perror("Opening data file"); exit(1); } } if (Modes.net) modesInitNet(); // If the user specifies --net-only, just run in order to serve network // clients without reading data from the RTL device while (Modes.net_only) { if (Modes.exit) exit(0); // If we exit net_only nothing further in main() backgroundTasks(); usleep(100000); } // Create the thread that will read the data from the device. pthread_create(&Modes.reader_thread, NULL, readerThreadEntryPoint, NULL); pthread_mutex_lock(&Modes.data_mutex); while (Modes.exit == 0) { if (Modes.iDataReady == 0) { pthread_cond_wait(&Modes.data_cond,&Modes.data_mutex); // This unlocks Modes.data_mutex, and waits for Modes.data_cond continue; // Once (Modes.data_cond) occurs, it locks Modes.data_mutex } // Modes.data_mutex is Locked, and (Modes.iDataReady != 0) if (Modes.iDataReady) { // Check we have new data, just in case!! Modes.iDataOut &= (MODES_ASYNC_BUF_NUMBER-1); // Just incase // Translate the next lot of I/Q samples into Modes.magnitude computeMagnitudeVector(Modes.pData[Modes.iDataOut]); Modes.stSystemTimeBlk = Modes.stSystemTimeRTL[Modes.iDataOut]; // Update the input buffer pointer queue Modes.iDataOut = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataOut + 1); Modes.iDataReady = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataIn - Modes.iDataOut); // If we lost some blocks, correct the timestamp if (Modes.iDataLost) { Modes.timestampBlk += (MODES_ASYNC_BUF_SAMPLES * 6 * Modes.iDataLost); Modes.iDataLost = 0; } // It's safe to release the lock now pthread_cond_signal (&Modes.data_cond); pthread_mutex_unlock(&Modes.data_mutex); // Process data after releasing the lock, so that the capturing // thread can read data while we perform computationally expensive // stuff at the same time. detectModeS(Modes.magnitude, MODES_ASYNC_BUF_SAMPLES); // Update the timestamp ready for the next block Modes.timestampBlk += (MODES_ASYNC_BUF_SAMPLES*6); } else { pthread_cond_signal (&Modes.data_cond); pthread_mutex_unlock(&Modes.data_mutex); } backgroundTasks(); pthread_mutex_lock(&Modes.data_mutex); } // If --stats were given, print statistics if (Modes.stats) { printf("\n\n"); if (Modes.interactive) interactiveShowData(); printf("%d ModeA/C detected\n", Modes.stat_ModeAC); printf("%d valid Mode-S preambles\n", Modes.stat_valid_preamble); printf("%d DF-?? fields corrected for length\n", Modes.stat_DF_Len_Corrected); printf("%d DF-?? fields corrected for type\n", Modes.stat_DF_Type_Corrected); printf("%d demodulated with 0 errors\n", Modes.stat_demodulated0); printf("%d demodulated with 1 error\n", Modes.stat_demodulated1); printf("%d demodulated with 2 errors\n", Modes.stat_demodulated2); printf("%d demodulated with > 2 errors\n", Modes.stat_demodulated3); printf("%d with good crc\n", Modes.stat_goodcrc); printf("%d with bad crc\n", Modes.stat_badcrc); printf("%d errors corrected\n", Modes.stat_fixed); for (j = 0; j < MODES_MAX_BITERRORS; j++) { printf(" %d with %d bit %s\n", Modes.stat_bit_fix[j], j+1, (j==0)?"error":"errors"); } if (Modes.phase_enhance) { printf("%d phase enhancement attempts\n", Modes.stat_out_of_phase); printf("%d phase enhanced demodulated with 0 errors\n", Modes.stat_ph_demodulated0); printf("%d phase enhanced demodulated with 1 error\n", Modes.stat_ph_demodulated1); printf("%d phase enhanced demodulated with 2 errors\n", Modes.stat_ph_demodulated2); printf("%d phase enhanced demodulated with > 2 errors\n", Modes.stat_ph_demodulated3); printf("%d phase enhanced with good crc\n", Modes.stat_ph_goodcrc); printf("%d phase enhanced with bad crc\n", Modes.stat_ph_badcrc); printf("%d phase enhanced errors corrected\n", Modes.stat_ph_fixed); for (j = 0; j < MODES_MAX_BITERRORS; j++) { printf(" %d with %d bit %s\n", Modes.stat_ph_bit_fix[j], j+1, (j==0)?"error":"errors"); } } printf("%d total usable messages\n", Modes.stat_goodcrc + Modes.stat_ph_goodcrc + Modes.stat_fixed + Modes.stat_ph_fixed); } if (Modes.filename == NULL) { rtlsdr_cancel_async(Modes.dev); // Cancel rtlsdr_read_async will cause data input thread to terminate cleanly rtlsdr_close(Modes.dev); } pthread_cond_destroy(&Modes.data_cond); // Thread cleanup pthread_mutex_destroy(&Modes.data_mutex); pthread_join(Modes.reader_thread,NULL); // Wait on reader thread exit #ifndef _WIN32 pthread_exit(0); #else return (0); #endif }
// Converts the default value in string "str" into "d". Passes a ref on str. // Returns true on success. static bool parse_default(char *str, upb_fielddef *f) { bool success = true; char *end; switch (upb_fielddef_type(f)) { case UPB_TYPE_INT32: { long val = strtol(str, &end, 0); if (val > INT32_MAX || val < INT32_MIN || errno == ERANGE || *end) success = false; else upb_fielddef_setdefaultint32(f, val); break; } case UPB_TYPE_INT64: { long long val = strtoll(str, &end, 0); if (val > INT64_MAX || val < INT64_MIN || errno == ERANGE || *end) success = false; else upb_fielddef_setdefaultint64(f, val); break; } case UPB_TYPE_UINT32: { long val = strtoul(str, &end, 0); if (val > UINT32_MAX || errno == ERANGE || *end) success = false; else upb_fielddef_setdefaultuint32(f, val); break; } case UPB_TYPE_UINT64: { unsigned long long val = strtoull(str, &end, 0); if (val > UINT64_MAX || errno == ERANGE || *end) success = false; else upb_fielddef_setdefaultuint64(f, val); break; } case UPB_TYPE_DOUBLE: { double val = strtod(str, &end); if (errno == ERANGE || *end) success = false; else upb_fielddef_setdefaultdouble(f, val); break; } case UPB_TYPE_FLOAT: { float val = strtof(str, &end); if (errno == ERANGE || *end) success = false; else upb_fielddef_setdefaultfloat(f, val); break; } case UPB_TYPE_BOOL: { if (strcmp(str, "false") == 0) upb_fielddef_setdefaultbool(f, false); else if (strcmp(str, "true") == 0) upb_fielddef_setdefaultbool(f, true); else success = false; break; } default: abort(); } return success; }
/* Convert a string to a long long int. */ long long int atoll (const char *nptr) { return strtoll (nptr, (char **) NULL, 10); }
int main( int i_argc, char **pp_argv ) { const char *psz_network_name = "DVBlast - http://www.videolan.org/projects/dvblast.html"; char *p_network_name_tmp = NULL; size_t i_network_name_tmp_size; char *psz_dup_config = NULL; mtime_t i_poll_timeout = MAX_POLL_TIMEOUT; struct sched_param param; int i_error; int c; struct sigaction sa; sigset_t set; int b_enable_syslog = 0; if ( i_argc == 1 ) usage(); /* * The only short options left are: 346789 * Use them wisely. */ static const struct option long_options[] = { { "config-file", required_argument, NULL, 'c' }, { "remote-socket", required_argument, NULL, 'r' }, { "ttl", required_argument, NULL, 't' }, { "rtp-output", required_argument, NULL, 'o' }, { "priority", required_argument, NULL, 'i' }, { "adapter", required_argument, NULL, 'a' }, { "frontend-number", required_argument, NULL, 'n' }, { "delsys", required_argument, NULL, '5' }, { "frequency", required_argument, NULL, 'f' }, { "fec-inner", required_argument, NULL, 'F' }, { "rolloff", required_argument, NULL, 'R' }, { "symbol-rate", required_argument, NULL, 's' }, { "diseqc", required_argument, NULL, 'S' }, { "uncommitted", required_argument, NULL, 'k' }, { "voltage", required_argument, NULL, 'v' }, { "force-pulse", no_argument, NULL, 'p' }, { "bandwidth", required_argument, NULL, 'b' }, { "inversion", required_argument, NULL, 'I' }, { "modulation", required_argument, NULL, 'm' }, { "pilot", required_argument, NULL, 'P' }, { "multistream-id", required_argument, NULL, '1' }, { "fec-lp", required_argument, NULL, 'K' }, { "guard", required_argument, NULL, 'G' }, { "hierarchy", required_argument, NULL, 'H' }, { "transmission", required_argument, NULL, 'X' }, { "lock-timeout", required_argument, NULL, 'O' }, { "budget-mode", no_argument, NULL, 'u' }, { "select-pmts", no_argument, NULL, 'w' }, { "udp", no_argument, NULL, 'U' }, { "unique-ts-id", no_argument, NULL, 'T' }, { "latency", required_argument, NULL, 'L' }, { "retention", required_argument, NULL, 'E' }, { "duplicate", required_argument, NULL, 'd' }, { "rtp-input", required_argument, NULL, 'D' }, { "asi-adapter", required_argument, NULL, 'A' }, { "any-type", no_argument, NULL, 'z' }, { "dvb-compliance", no_argument, NULL, 'C' }, { "emm-passthrough", no_argument, NULL, 'W' }, { "ecm-passthrough", no_argument, NULL, 'Y' }, { "epg-passthrough", no_argument, NULL, 'e' }, { "network-name", no_argument, NULL, 'M' }, { "network-id", no_argument, NULL, 'N' }, { "system-charset", required_argument, NULL, 'j' }, { "dvb-charset", required_argument, NULL, 'J' }, { "provider-name", required_argument, NULL, 'B' }, { "logger", no_argument, NULL, 'l' }, { "logger-ident", required_argument, NULL, 'g' }, { "print", required_argument, NULL, 'x' }, { "quit-timeout", required_argument, NULL, 'Q' }, { "quiet", no_argument, NULL, 'q' }, { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'V' }, { "mrtg-file", required_argument, NULL, 'Z' }, { "ca-number", required_argument, NULL, 'y' }, { "pidmap", required_argument, NULL, '0' }, { "dvr-buf-size", required_argument, NULL, '2' }, { 0, 0, 0, 0 } }; while ( (c = getopt_long(i_argc, pp_argv, "q::c:r:t:o:i:a:n:5:f:F:R:s:S:k:v:pb:I:m:P:K:G:H:X:O:uwUTL:E:d:D:A:lg:zCWYeM:N:j:J:B:x:Q:hVZ:y:0:1:2:", long_options, NULL)) != -1 ) { switch ( c ) { case 'q': if ( optarg ) { if ( *optarg == 'q' ) /* e.g. -qqq */ { i_verbose--; while ( *optarg == 'q' ) { i_verbose--; optarg++; } } else { i_verbose -= atoi( optarg ); /* e.g. -q2 */ } } else { i_verbose--; /* -q */ } break; case 'c': psz_conf_file = optarg; /* * When configuration file is used it is reasonable to assume that * services may be added/removed. If b_select_pmts is not set dvblast * is unable to start streaming newly added services in the config. */ b_select_pmts = 1; break; case 'r': psz_srv_socket = optarg; break; case 't': i_ttl_global = strtol( optarg, NULL, 0 ); break; case 'o': { struct in_addr maddr; if ( !inet_aton( optarg, &maddr ) ) usage(); memcpy( pi_ssrc_global, &maddr.s_addr, 4 * sizeof(uint8_t) ); break; } case 'i': i_priority = strtol( optarg, NULL, 0 ); break; case 'a': i_adapter = strtol( optarg, NULL, 0 ); break; case 'n': i_fenum = strtol( optarg, NULL, 0 ); break; case 'y': i_canum = strtol( optarg, NULL, 0 ); break; case '5': psz_delsys = optarg; break; case 'f': if (optarg && optarg[0] != '-') i_frequency = strtol( optarg, NULL, 0 ); if ( pf_Open != NULL ) usage(); #ifdef HAVE_DVB_SUPPORT pf_Open = dvb_Open; pf_Read = dvb_Read; pf_Reset = dvb_Reset; pf_SetFilter = dvb_SetFilter; pf_UnsetFilter = dvb_UnsetFilter; #else msg_Err( NULL, "DVBlast is compiled without DVB support."); exit(1); #endif break; case 'F': i_fec = strtol( optarg, NULL, 0 ); break; case 'R': i_rolloff = strtol( optarg, NULL, 0 ); break; case 's': i_srate = strtol( optarg, NULL, 0 ); break; case 'S': i_satnum = strtol( optarg, NULL, 16 ); break; case 'k': i_uncommitted = strtol( optarg, NULL, 16 ); break; case 'v': i_voltage = strtol( optarg, NULL, 0 ); break; case 'p': b_tone = 1; break; case 'b': i_bandwidth = strtol( optarg, NULL, 0 ); break; case 'I': i_inversion = strtol( optarg, NULL, 0 ); break; case 'm': psz_modulation = optarg; break; case 'P': i_pilot = strtol( optarg, NULL, 0 ); break; case '1': i_mis = strtol( optarg, NULL, 0 ); break; case 'K': i_fec_lp = strtol( optarg, NULL, 0 ); break; case 'G': i_guard = strtol( optarg, NULL, 0 ); break; case 'X': i_transmission = strtol( optarg, NULL, 0 ); break; case 'O': i_frontend_timeout_duration = strtoll( optarg, NULL, 0 ) * 1000; break; case 'H': i_hierarchy = strtol( optarg, NULL, 0 ); break; case 'u': b_budget_mode = 1; break; case 'w': b_select_pmts = 1; //!b_select_pmts; break; case 'U': b_udp_global = true; break; case 'L': i_latency_global = strtoll( optarg, NULL, 0 ) * 1000; break; case 'E': i_retention_global = strtoll( optarg, NULL, 0 ) * 1000; break; case 'd': psz_dup_config = optarg; break; case 'D': psz_udp_src = optarg; if ( pf_Open != NULL ) usage(); pf_Open = udp_Open; pf_Read = udp_Read; pf_Reset = udp_Reset; pf_SetFilter = udp_SetFilter; pf_UnsetFilter = udp_UnsetFilter; break; case 'A': #ifdef HAVE_ASI_SUPPORT if ( pf_Open != NULL ) usage(); if ( strncmp(optarg, "deltacast:", 10) == 0) { #ifdef HAVE_ASI_DELTACAST_SUPPORT i_asi_adapter = strtol( optarg+10, NULL, 0 ); pf_Open = asi_deltacast_Open; pf_Read = asi_deltacast_Read; pf_Reset = asi_deltacast_Reset; pf_SetFilter = asi_deltacast_SetFilter; pf_UnsetFilter = asi_deltacast_UnsetFilter; #else msg_Err( NULL, "DVBlast is compiled without Deltacast ASI support."); exit(1); #endif } else { i_asi_adapter = strtol( optarg, NULL, 0 ); pf_Open = asi_Open; pf_Read = asi_Read; pf_Reset = asi_Reset; pf_SetFilter = asi_SetFilter; pf_UnsetFilter = asi_UnsetFilter; } #else msg_Err( NULL, "DVBlast is compiled without ASI support."); exit(1); #endif break; case 'z': b_any_type = 1; break; case 'C': b_dvb_global = true; break; case 'W': b_enable_emm = true; break; case 'Y': b_enable_ecm = true; break; case 'e': b_epg_global = true; break; case 'M': psz_network_name = optarg; break; case 'N': i_network_id = strtoul( optarg, NULL, 0 ); break; case 'T': b_random_tsid = 1; break; case 'j': psz_native_charset = optarg; break; case 'J': psz_dvb_charset = optarg; break; case 'B': psz_provider_name = optarg; break; case 'l': b_enable_syslog = 1; break; case 'g': psz_syslog_ident = optarg; break; case 'x': b_print_enabled = true; if ( !strcmp(optarg, "text") ) i_print_type = PRINT_TEXT; else if ( !strcmp(optarg, "xml") ) i_print_type = PRINT_XML; else { b_print_enabled = false; msg_Warn( NULL, "unrecognized print type %s", optarg ); } /* Make stdout line-buffered */ setvbuf(stdout, NULL, _IOLBF, 0); break; case 'Q': i_quit_timeout_duration = strtoll( optarg, NULL, 0 ) * 1000; break; case 'V': DisplayVersion(); exit(0); break; case 'Z': psz_mrtg_file = optarg; break; case '0': { /* We expect a comma separated list of numbers. Put them into the pi_newpids array as they appear */ char *str1; char *saveptr = NULL; char *tok = NULL; int i, i_newpid; for (i = 0, str1 = optarg; i < N_MAP_PIDS; i++, str1 = NULL) { tok = strtok_r(str1, ",", &saveptr); if ( !tok ) break; i_newpid = strtoul(tok, NULL, 0); if ( !i_newpid ) { msg_Err( NULL, "Invalid pidmap string" ); usage(); } pi_newpids[i] = i_newpid; } b_do_remap = true; break; } #ifdef HAVE_DVB_SUPPORT case '2': i_dvr_buffer_size = strtol( optarg, NULL, 0 ); if (!i_dvr_buffer_size) usage(); // it exits /* roundup to packet size */ i_dvr_buffer_size += TS_SIZE - 1; i_dvr_buffer_size /= TS_SIZE; i_dvr_buffer_size *= TS_SIZE; break; #endif case 'h': default: usage(); } } if ( optind < i_argc || pf_Open == NULL ) usage(); if ( b_enable_syslog ) msg_Connect( psz_syslog_ident ? psz_syslog_ident : pp_argv[0] ); if ( i_verbose ) DisplayVersion(); msg_Warn( NULL, "restarting" ); switch (i_print_type) { case PRINT_XML: printf("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"); printf("<TS>\n"); break; default: break; } if ( b_udp_global ) { msg_Warn( NULL, "raw UDP output is deprecated. Please consider using RTP." ); msg_Warn( NULL, "for DVB-IP compliance you should use RTP." ); } if ( b_epg_global && !b_dvb_global ) { msg_Dbg( NULL, "turning on DVB compliance, required by EPG information" ); b_dvb_global = true; } memset( &output_dup, 0, sizeof(output_dup) ); if ( psz_dup_config != NULL ) { output_config_t config; config_Defaults( &config ); if ( !config_ParseHost( &config, psz_dup_config ) ) msg_Err( NULL, "Invalid target address for -d switch" ); else { output_Init( &output_dup, &config ); output_Change( &output_dup, &config ); } config_Free( &config ); } if ( strcasecmp( psz_native_charset, psz_dvb_charset ) ) { #ifdef HAVE_ICONV iconv_t iconv_system = iconv_open( psz_dvb_charset, psz_native_charset ); if ( iconv_system != (iconv_t)-1 ) { size_t i = strlen( psz_network_name ); char *p, *psz_string; i_network_name_tmp_size = i * 6; p = psz_string = malloc(i_network_name_tmp_size); if ( iconv( iconv_system, (char **)&psz_network_name, &i, &p, &i_network_name_tmp_size ) == -1 ) free( psz_string ); else { p_network_name_tmp = psz_string; i_network_name_tmp_size = p - psz_string; } iconv_close( iconv_system ); } #else msg_Warn( NULL, "unable to convert from %s to %s (iconv is not available)", psz_native_charset, psz_dvb_charset ); #endif } if ( p_network_name_tmp == NULL ) { p_network_name_tmp = strdup(psz_network_name); i_network_name_tmp_size = strlen(psz_network_name); } p_network_name = dvb_string_set( (uint8_t *)p_network_name_tmp, i_network_name_tmp_size, psz_dvb_charset, &i_network_name_size ); free( p_network_name_tmp ); /* Set signal handlers */ memset( &sa, 0, sizeof(struct sigaction) ); sa.sa_handler = SigHandler; sigfillset( &set ); if ( sigaction( SIGHUP, &sa, NULL ) == -1 || sigaction( SIGINT, &sa, NULL ) == -1 ) { msg_Err( NULL, "couldn't set signal handler: %s", strerror(errno) ); exit(EXIT_FAILURE); } srand( time(NULL) * getpid() ); demux_Open(); // init the mrtg logfile mrtgInit(psz_mrtg_file); if ( i_priority > 0 ) { memset( ¶m, 0, sizeof(struct sched_param) ); param.sched_priority = i_priority; if ( (i_error = pthread_setschedparam( pthread_self(), SCHED_RR, ¶m )) ) { msg_Warn( NULL, "couldn't set thread priority: %s", strerror(i_error) ); } } config_ReadFile( psz_conf_file ); if ( psz_srv_socket != NULL ) comm_Open(); for ( ; ; ) { block_t *p_ts; if ( b_exit_now ) { msg_Info( NULL, "Shutdown was requested." ); break; } if ( b_conf_reload ) { b_conf_reload = 0; msg_Info( NULL, "Configuration reload was requested." ); config_ReadFile( psz_conf_file ); } if ( i_quit_timeout && i_quit_timeout <= i_wallclock ) { switch (i_print_type) { case PRINT_XML: printf("</TS>\n"); break; default: break; } exit(EXIT_SUCCESS); } p_ts = pf_Read( i_poll_timeout ); if ( p_ts != NULL ) { mrtgAnalyse(p_ts); demux_Run( p_ts ); } i_poll_timeout = output_Send(); if ( i_poll_timeout == -1 || i_poll_timeout > MAX_POLL_TIMEOUT ) i_poll_timeout = MAX_POLL_TIMEOUT; } mrtgClose(); outputs_Close( i_nb_outputs ); demux_Close(); free( p_network_name ); if ( b_enable_syslog ) msg_Disconnect(); if ( psz_srv_socket && i_comm_fd > -1 ) unlink( psz_srv_socket ); return EXIT_SUCCESS; }
static void parse_options(int argc, char *argv[]) { enum { OPT_MAX_BACKOFF = UCHAR_MAX + 1, OPT_MFR_DESC, OPT_HW_DESC, OPT_SW_DESC, OPT_SERIAL_NUM, OPT_BOOTSTRAP_CA_CERT }; static struct option long_options[] = { {"interfaces", required_argument, 0, 'i'}, {"datapath-id", required_argument, 0, 'd'}, {"max-backoff", required_argument, 0, OPT_MAX_BACKOFF}, {"listen", required_argument, 0, 'l'}, {"verbose", optional_argument, 0, 'v'}, {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'V'}, {"mfr-desc", required_argument, 0, OPT_MFR_DESC}, {"hw-desc", required_argument, 0, OPT_HW_DESC}, {"sw-desc", required_argument, 0, OPT_SW_DESC}, {"serial_num", required_argument, 0, OPT_SERIAL_NUM}, DAEMON_LONG_OPTIONS, #ifdef HAVE_OPENSSL VCONN_SSL_LONG_OPTIONS {"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT}, #endif {0, 0, 0, 0}, }; char *short_options = long_options_to_short_options(long_options); for (;;) { int indexptr; int c; c = getopt_long(argc, argv, short_options, long_options, &indexptr); if (c == -1) { break; } switch (c) { case 'd': if (strlen(optarg) != 12 || strspn(optarg, "0123456789abcdefABCDEF") != 12) { ofp_fatal(0, "argument to -d or --datapath-id must be " "exactly 12 hex digits"); } dpid = strtoll(optarg, NULL, 16); if (!dpid) { ofp_fatal(0, "argument to -d or --datapath-id must " "be nonzero"); } break; case 'h': usage(); case 'V': printf("%s %s compiled "__DATE__" "__TIME__"\n", program_name, VERSION BUILDNR); exit(EXIT_SUCCESS); case 'v': vlog_set_verbosity(optarg); break; case 'i': if (!port_list) { port_list = optarg; } else { port_list = xasprintf("%s,%s", port_list, optarg); } break; case OPT_MAX_BACKOFF: max_backoff = atoi(optarg); if (max_backoff < 1) { ofp_fatal(0, "--max-backoff argument must be at least 1"); } else if (max_backoff > 3600) { max_backoff = 3600; } break; case OPT_MFR_DESC: strncpy(mfr_desc, optarg, sizeof mfr_desc); break; case OPT_HW_DESC: strncpy(hw_desc, optarg, sizeof hw_desc); break; case OPT_SW_DESC: strncpy(sw_desc, optarg, sizeof sw_desc); break; case OPT_SERIAL_NUM: strncpy(serial_num, optarg, sizeof serial_num); break; case 'l': if (listen_pvconn_name) { ofp_fatal(0, "-l or --listen may be only specified once"); } listen_pvconn_name = optarg; break; DAEMON_OPTION_HANDLERS #ifdef HAVE_OPENSSL VCONN_SSL_OPTION_HANDLERS case OPT_BOOTSTRAP_CA_CERT: vconn_ssl_set_ca_cert_file(optarg, true); break; #endif case '?': exit(EXIT_FAILURE); default: abort(); } } free(short_options); }
static void postgres_ingest_stats(postgres_check_info_t *ci) { if(ci->rv == PGRES_TUPLES_OK) { /* metrics */ int nrows, ncols, i, j; nrows = PQntuples(ci->result); ncols = PQnfields(ci->result); noit_stats_set_metric(&ci->current, "row_count", METRIC_INT32, &nrows); for (i=0; i<nrows; i++) { noitL(nldeb, "postgres: row %d [%d cols]:\n", i, ncols); if(ncols<2) continue; if(PQgetisnull(ci->result, i, 0)) continue; for (j=1; j<ncols; j++) { Oid coltype; int iv, *piv; int64_t lv, *plv; double dv, *pdv; char *sv; char mname[128]; snprintf(mname, sizeof(mname), "%s`%s", PQgetvalue(ci->result, i, 0), PQfname(ci->result, j)); coltype = PQftype(ci->result, j); noitL(nldeb, "postgres: col %d (%s) type %d: %s\n", j, mname, coltype, PQgetisnull(ci->result, i, j) ? "[[null]]" : PQgetvalue(ci->result, i, j)); switch(coltype) { case BOOLOID: if(PQgetisnull(ci->result, i, j)) piv = NULL; else { iv = strcmp(PQgetvalue(ci->result, i, j), "f") ? 1 : 0; piv = &iv; } noit_stats_set_metric(&ci->current, mname, METRIC_INT32, piv); break; case INT2OID: case INT4OID: case INT8OID: if(PQgetisnull(ci->result, i, j)) plv = NULL; else { lv = strtoll(PQgetvalue(ci->result, i, j), NULL, 10); plv = &lv; } noit_stats_set_metric(&ci->current, mname, METRIC_INT64, plv); break; case FLOAT4OID: case FLOAT8OID: case NUMERICOID: if(PQgetisnull(ci->result, i, j)) pdv = NULL; else { dv = atof(PQgetvalue(ci->result, i, j)); pdv = &dv; } noit_stats_set_metric(&ci->current, mname, METRIC_DOUBLE, pdv); break; default: if(PQgetisnull(ci->result, i, j)) sv = NULL; else sv = PQgetvalue(ci->result, i, j); noit_stats_set_metric(&ci->current, mname, METRIC_GUESS, sv); break; } } } } }
bool config_ParseHost( output_config_t *p_config, char *psz_string ) { struct addrinfo *p_ai; int i_mtu; p_config->psz_displayname = strdup( psz_string ); p_ai = ParseNodeService( psz_string, &psz_string, DEFAULT_PORT ); if ( p_ai == NULL ) return false; memcpy( &p_config->connect_addr, p_ai->ai_addr, p_ai->ai_addrlen ); freeaddrinfo( p_ai ); p_config->i_family = p_config->connect_addr.ss_family; if ( p_config->i_family == AF_UNSPEC ) return false; if ( psz_string == NULL || !*psz_string ) goto end; if ( *psz_string == '@' ) { psz_string++; p_ai = ParseNodeService( psz_string, &psz_string, 0 ); if ( p_ai == NULL || p_ai->ai_family != p_config->i_family ) msg_Warn( NULL, "invalid bind address" ); else memcpy( &p_config->bind_addr, p_ai->ai_addr, p_ai->ai_addrlen ); freeaddrinfo( p_ai ); } while ( (psz_string = strchr( psz_string, '/' )) != NULL ) { *psz_string++ = '\0'; #define IS_OPTION( option ) (!strncasecmp( psz_string, option, strlen(option) )) #define ARG_OPTION( option ) (psz_string + strlen(option)) if ( IS_OPTION("udp") ) p_config->i_config |= OUTPUT_UDP; else if ( IS_OPTION("dvb") ) p_config->i_config |= OUTPUT_DVB; else if ( IS_OPTION("epg") ) p_config->i_config |= OUTPUT_EPG; else if ( IS_OPTION("tsid=") ) p_config->i_tsid = strtol( ARG_OPTION("tsid="), NULL, 0 ); else if ( IS_OPTION("retention=") ) p_config->i_max_retention = strtoll( ARG_OPTION("retention="), NULL, 0 ) * 1000; else if ( IS_OPTION("latency=") ) p_config->i_output_latency = strtoll( ARG_OPTION("latency="), NULL, 0 ) * 1000; else if ( IS_OPTION("ttl=") ) p_config->i_ttl = strtol( ARG_OPTION("ttl="), NULL, 0 ); else if ( IS_OPTION("tos=") ) p_config->i_tos = strtol( ARG_OPTION("tos="), NULL, 0 ); else if ( IS_OPTION("mtu=") ) p_config->i_mtu = strtol( ARG_OPTION("mtu="), NULL, 0 ); else if ( IS_OPTION("ifindex=") ) p_config->i_if_index_v6 = strtol( ARG_OPTION("ifindex="), NULL, 0 ); else if ( IS_OPTION("srvname=") ) { if ( p_config->psz_service_name ) free( p_config->psz_service_name ); p_config->psz_service_name = config_stropt( ARG_OPTION("srvname=") ); } else if ( IS_OPTION("srvprovider=") ) { if ( !p_config->psz_service_provider ) free( p_config->psz_service_provider ); p_config->psz_service_provider = config_stropt( ARG_OPTION("srvprovider=") ); } else if ( IS_OPTION("srcaddr=") ) { if ( p_config->i_family != AF_INET ) { msg_Err( NULL, "RAW sockets currently implemented for ipv4 only"); return false; } if ( !p_config->psz_srcaddr ) free( p_config->psz_srcaddr ); p_config->psz_srcaddr = config_stropt( ARG_OPTION("srcaddr=") ); p_config->i_config |= OUTPUT_RAW; } else if ( IS_OPTION("srcport=") ) p_config->i_srcport = strtol( ARG_OPTION("srcport="), NULL, 0 ); else if ( IS_OPTION("ssrc=") ) { in_addr_t i_addr = inet_addr( ARG_OPTION("ssrc=") ); memcpy( p_config->pi_ssrc, &i_addr, 4 * sizeof(uint8_t) ); } else if ( IS_OPTION("pidmap=") ) { char *str1; char *saveptr = NULL; char *tok = NULL; int i, i_newpid; for (i = 0, str1 = config_stropt( (ARG_OPTION("pidmap="))); i < N_MAP_PIDS; i++, str1 = NULL) { tok = strtok_r(str1, ",", &saveptr); if ( !tok ) break; i_newpid = strtoul(tok, NULL, 0); if ( !i_newpid ) { msg_Warn( NULL, "Invalid output pidmap setting" ); } p_config->pi_confpids[i] = i_newpid; } p_config->b_do_remap = true; } else msg_Warn( NULL, "unrecognized option %s", psz_string ); #undef IS_OPTION #undef ARG_OPTION } if ( !p_config->psz_service_provider && psz_provider_name ) p_config->psz_service_provider = strdup( psz_provider_name ); end: i_mtu = p_config->i_family == AF_INET6 ? DEFAULT_IPV6_MTU : DEFAULT_IPV4_MTU; if ( !p_config->i_mtu ) p_config->i_mtu = i_mtu; else if ( p_config->i_mtu < TS_SIZE + RTP_HEADER_SIZE ) { msg_Warn( NULL, "invalid MTU %d, setting %d", p_config->i_mtu, i_mtu ); p_config->i_mtu = i_mtu; } return true; }
static inline void parse(const char *nptr, char **endptr, signed long long &value) { value = strtoll(nptr, endptr, 0); }
static void sparc_cpu_parse_features(CPUState *cs, char *features, Error **errp) { SPARCCPU *cpu = SPARC_CPU(cs); sparc_def_t *cpu_def = cpu->env.def; char *featurestr; uint32_t plus_features = 0; uint32_t minus_features = 0; uint64_t iu_version; uint32_t fpu_version, mmu_version, nwindows; featurestr = features ? strtok(features, ",") : NULL; while (featurestr) { char *val; if (featurestr[0] == '+') { add_flagname_to_bitmaps(featurestr + 1, &plus_features); } else if (featurestr[0] == '-') { add_flagname_to_bitmaps(featurestr + 1, &minus_features); } else if ((val = strchr(featurestr, '='))) { *val = 0; val++; if (!strcmp(featurestr, "iu_version")) { char *err; iu_version = strtoll(val, &err, 0); if (!*val || *err) { error_setg(errp, "bad numerical value %s", val); return; } cpu_def->iu_version = iu_version; #ifdef DEBUG_FEATURES fprintf(stderr, "iu_version %" PRIx64 "\n", iu_version); #endif } else if (!strcmp(featurestr, "fpu_version")) { char *err; fpu_version = strtol(val, &err, 0); if (!*val || *err) { error_setg(errp, "bad numerical value %s", val); return; } cpu_def->fpu_version = fpu_version; #ifdef DEBUG_FEATURES fprintf(stderr, "fpu_version %x\n", fpu_version); #endif } else if (!strcmp(featurestr, "mmu_version")) { char *err; mmu_version = strtol(val, &err, 0); if (!*val || *err) { error_setg(errp, "bad numerical value %s", val); return; } cpu_def->mmu_version = mmu_version; #ifdef DEBUG_FEATURES fprintf(stderr, "mmu_version %x\n", mmu_version); #endif } else if (!strcmp(featurestr, "nwindows")) { char *err; nwindows = strtol(val, &err, 0); if (!*val || *err || nwindows > MAX_NWINDOWS || nwindows < MIN_NWINDOWS) { error_setg(errp, "bad numerical value %s", val); return; } cpu_def->nwindows = nwindows; #ifdef DEBUG_FEATURES fprintf(stderr, "nwindows %d\n", nwindows); #endif } else { error_setg(errp, "unrecognized feature %s", featurestr); return; } } else { error_setg(errp, "feature string `%s' not in format " "(+feature|-feature|feature=xyz)", featurestr); return; } featurestr = strtok(NULL, ","); } cpu_def->features |= plus_features; cpu_def->features &= ~minus_features; #ifdef DEBUG_FEATURES print_features(stderr, fprintf, cpu_def->features, NULL); #endif }
ValueHolderPtr parseIntLiteral(ModulePtr module, IntLiteral *x) { CompilerState* cst = module->cst; TypePtr defaultType = module->attrDefaultIntegerType.ptr(); if (defaultType == NULL) defaultType = cst->int32Type; char *ptr = const_cast<char *>(x->value.c_str()); char *end = ptr; int base = ishex(ptr) ? 16 : 10; ValueHolderPtr vh; if (typeSuffix(x->suffix, defaultType, "ss", cst->int8Type)) { long y = strtol(ptr, &end, base); if (*end != 0) error("invalid int8 literal"); if ((errno == ERANGE) || (y < SCHAR_MIN) || (y > SCHAR_MAX)) error("int8 literal out of range"); vh = new ValueHolder(cst->int8Type); *((char *)vh->buf) = (char)y; } else if (typeSuffix(x->suffix, defaultType, "s", cst->int16Type)) { long y = strtol(ptr, &end, base); if (*end != 0) error("invalid int16 literal"); if ((errno == ERANGE) || (y < SHRT_MIN) || (y > SHRT_MAX)) error("int16 literal out of range"); vh = new ValueHolder(cst->int16Type); *((short *)vh->buf) = (short)y; } else if (typeSuffix(x->suffix, defaultType, "i", cst->int32Type)) { long y = strtol(ptr, &end, base); if (*end != 0) error("invalid int32 literal"); if (errno == ERANGE || (y < INT_MIN) || (y > INT_MAX)) error("int32 literal out of range"); vh = new ValueHolder(cst->int32Type); *((int *)vh->buf) = (int)y; } else if (typeSuffix(x->suffix, defaultType, "l", cst->int64Type)) { long long y = strtoll(ptr, &end, base); if (*end != 0) error("invalid int64 literal"); if (errno == ERANGE) error("int64 literal out of range"); vh = new ValueHolder(cst->int64Type); *((long long *)vh->buf) = y; } else if (typeSuffix(x->suffix, defaultType, "ll", cst->int128Type)) { long long y = strtoll(ptr, &end, base); if (*end != 0) error("invalid int128 literal"); if (errno == ERANGE) error("int128 literal out of range"); vh = new ValueHolder(cst->int128Type); *((clay_int128 *)vh->buf) = y; } else if (typeSuffix(x->suffix, defaultType, "uss", cst->uint8Type)) { unsigned long y = strtoul(ptr, &end, base); if (*end != 0) error("invalid uint8 literal"); if ((errno == ERANGE) || (y > UCHAR_MAX)) error("uint8 literal out of range"); vh = new ValueHolder(cst->uint8Type); *((unsigned char *)vh->buf) = (unsigned char)y; } else if (typeSuffix(x->suffix, defaultType, "us", cst->uint16Type)) { unsigned long y = strtoul(ptr, &end, base); if (*end != 0) error("invalid uint16 literal"); if ((errno == ERANGE) || (y > USHRT_MAX)) error("uint16 literal out of range"); vh = new ValueHolder(cst->uint16Type); *((unsigned short *)vh->buf) = (unsigned short)y; } else if (typeSuffix(x->suffix, defaultType, "u", cst->uint32Type)) { unsigned long y = strtoul(ptr, &end, base); if (*end != 0) error("invalid uint32 literal"); if (errno == ERANGE) error("uint32 literal out of range"); vh = new ValueHolder(cst->uint32Type); *((unsigned int *)vh->buf) = (unsigned int)y; } else if (typeSuffix(x->suffix, defaultType, "ul", cst->uint64Type)) { unsigned long long y = strtoull(ptr, &end, base); if (*end != 0) error("invalid uint64 literal"); if (errno == ERANGE) error("uint64 literal out of range"); vh = new ValueHolder(cst->uint64Type); *((unsigned long long *)vh->buf) = y; } else if (typeSuffix(x->suffix, defaultType, "ull", cst->uint128Type)) { unsigned long long y = strtoull(ptr, &end, base); if (*end != 0) error("invalid uint128 literal"); if (errno == ERANGE) error("uint128 literal out of range"); vh = new ValueHolder(cst->uint128Type); *((clay_uint128 *)vh->buf) = y; } else if (x->suffix == "f") { float y = (float)clay_strtod(ptr, &end); if (*end != 0) error("invalid float32 literal"); if (errno == ERANGE) error("float32 literal out of range"); vh = new ValueHolder(cst->float32Type); *((float *)vh->buf) = y; } else if (x->suffix == "ff") { double y = clay_strtod(ptr, &end); if (*end != 0) error("invalid float64 literal"); if (errno == ERANGE) error("float64 literal out of range"); vh = new ValueHolder(cst->float64Type); *((double *)vh->buf) = y; } else if (x->suffix == "fl") { long double y = clay_strtold(ptr, &end); if (*end != 0) error("invalid float80 literal"); if (errno == ERANGE) error("float80 literal out of range"); vh = new ValueHolder(cst->float80Type); *((long double *)vh->buf) = y; } else if (x->suffix == "fj") { float y = (float)clay_strtod(ptr, &end); if (*end != 0) error("invalid imag32 literal"); if (errno == ERANGE) error("imag32 literal out of range"); vh = new ValueHolder(cst->imag32Type); *((float *)vh->buf) = y; } else if (x->suffix == "j" || x->suffix == "ffj") { double y = clay_strtod(ptr, &end); if (*end != 0) error("invalid imag64 literal"); if (errno == ERANGE) error("imag64 literal out of range"); vh = new ValueHolder(cst->imag64Type); *((double *)vh->buf) = y; } else if (x->suffix == "lj" || x->suffix == "flj") { long double y = clay_strtold(ptr, &end); if (*end != 0) error("invalid imag80 literal"); if (errno == ERANGE) error("imag80 literal out of range"); vh = new ValueHolder(cst->imag80Type); *((long double *)vh->buf) = y; } else { error("invalid literal suffix: " + x->suffix); } return vh; }
void HandleClient(int sock) { char buffer[BUFFSIZE]; char *tailptr; int received = -1; long long int respsize,sendsize; char* blockptr = malloc(BLOCKSIZE); memset(blockptr,0xaa,BLOCKSIZE); /* Receive message */ if ((received = recv(sock, buffer, BUFFSIZE-1, 0)) < 0) { Die("Failed to receive initial bytes from client"); } /* get the client request - for now, just expect a number which is the size of the expected response message */ buffer[received] = 0; /* parsing needs to know where the input string ends.... */ respsize = strtoll(buffer, &tailptr,10); fprintf(stderr, "client request (\"%s\")",buffer); if (errno) { Die("\nFailed to parse client request"); } else { switch ( *tailptr ) { case 'k' : case 'K' : respsize <<= 10; break; case 'm' : case 'M' : respsize <<= 20; break; case 'g' : case 'G' : respsize <<= 30; break; }; fprintf(stderr, ", parsed request as %lld bytes\n",respsize); } /* Send bytes and check for more incoming data in loop */ #ifdef ZEROCOPY char tmpn[] = "/tmp/XXXXXX" ; int tmpfd = mkstemp(tmpn); ftruncate(tmpfd,respsize); while (respsize > 0) { sendsize = respsize > MAX_RW_COUNT ? MAX_RW_COUNT : respsize; respsize -= sendsize; /* Send the next block */ if (sendfile(sock, tmpfd, 0, sendsize) != sendsize) { Die("Failed to send bytes to client"); } } close(tmpfd); unlink(tmpn); #else while (respsize > 0) { sendsize = respsize > BLOCKSIZE ? BLOCKSIZE : respsize; respsize -= sendsize; /* Send the next block */ if (send(sock, blockptr, sendsize, 0) != sendsize) { Die("Failed to send bytes to client"); } } #endif close(sock); }
// parse a @SQ line from the SAM file // start points at the first tag of the line bool ReadDataFile_SAM::parseReferenceSequenceLine(char *start) { char *seq_name = NULL; char *seq_len = NULL; char *delim; for(;;) { // look for the next delimiter delim = strchr(start, '\t'); // zero out the next delimiter if found if (delim) { *delim = 0; } if (strncmp(start, "SN:", strlen("SN:")) == 0) { if (seq_name != NULL) { log_warning(stderr, "SAM file warning (line %d): multiple SN tags in @SQ record\n", numLines); } else { seq_name = &start[3]; } } else if (strncmp(start, "LN:", strlen("LN:")) == 0) { if (seq_len != NULL) { log_warning(stderr, "SAM file warning (line %d): multiple LN tags in @SQ record\n", numLines); } else { seq_len = &start[3]; } } if (!delim) { // this was the last token break; } // advance to next token start = delim + 1; } if (seq_name == NULL || seq_len == NULL) { log_warning(stderr, "SAM file warning (line %d): missing required tags in @SQ record\n", numLines); return true; } char *endptr = NULL; #if WIN32 uint64 len = strtol(seq_len, &endptr, 10); #else uint64 len = strtoll(seq_len, &endptr, 10); #endif if (!endptr || endptr == seq_len || *endptr != '\0') { log_warning(stderr, "SAM file warning (line %d): invalid sequence length in @SQ record\n", numLines); } sq_names.push_back(std::string(seq_name)); sq_lengths.push_back(len); return true; }
static void primary_parser_package_start (PrimarySAXContext *ctx, const char *name, const char **attrs) { SAXContext *sctx = &ctx->sctx; Package *p = sctx->current_package; int i; const char *attr; const char *value; g_assert (p != NULL); sctx->want_text = TRUE; if (!strcmp (name, "format")) { ctx->state = PRIMARY_PARSER_FORMAT; } else if (!strcmp (name, "version")) { parse_version_info(attrs, p); } else if (!strcmp (name, "checksum")) { for (i = 0; attrs && attrs[i]; i++) { attr = attrs[i]; value = attrs[++i]; if (!strcmp (attr, "type")) p->checksum_type = g_string_chunk_insert (p->chunk, value); } } else if (!strcmp (name, "time")) { for (i = 0; attrs && attrs[i]; i++) { attr = attrs[i]; value = attrs[++i]; if (!strcmp (attr, "file")) p->time_file = strtol(value, NULL, 10); else if (!strcmp (attr, "build")) p->time_build = strtol(value, NULL, 10); } } else if (!strcmp (name, "size")) { for (i = 0; attrs && attrs[i]; i++) { attr = attrs[i]; value = attrs[++i]; if (!strcmp (attr, "package")) p->size_package = strtoll(value, NULL, 10); else if (!strcmp (attr, "installed")) p->size_installed = strtoll(value, NULL, 10); else if (!strcmp (attr, "archive")) p->size_archive = strtoll(value, NULL, 10); } } else if (!strcmp (name, "location")) { for (i = 0; attrs && attrs[i]; i++) { attr = attrs[i]; value = attrs[++i]; if (!strcmp (attr, "href")) p->location_href = g_string_chunk_insert (p->chunk, value); else if (!strcmp (attr, "xml:base")) p->location_base = g_string_chunk_insert (p->chunk, value); } } }
static int64 readLog(FILE *input, sqlite3 *db) { int64 eventCount = 0; /* declare statements for every event type */ EVENT_LIST(EVENT_TYPE_DECLARE_STATEMENT, X); /* prepare statements for every event type */ EVENT_LIST(EVENT_TYPE_PREPARE_STATEMENT, X); runStatement(db, "BEGIN", "Transaction start"); while (TRUE) { /* loop for each event */ char line[MAX_LOG_LINE_LENGTH]; char *p; char *q; int last_index=0; sqlite3_stmt *statement = NULL; int res; int64 clock_field; long code; p = fgets(line, MAX_LOG_LINE_LENGTH, input); if (!p) { if (feof(input)) break; else error("Couldn't read line after event %llu", eventCount); } eventCount++; clock_field = strtoll(p, &q, 16); if (q == p) error("event %llu clock field not a hex integer: %s", eventCount, p); if (*q != ' ') error("event %llu code field not preceded by ' ': %s", eventCount, q); while(*q == ' ') ++q; p = q; code = strtol(p, &q, 16); if (q == p) error("event %llu code field not an integer: %s", eventCount, p); p = q; /* Write event to SQLite. */ switch (code) { /* this macro sets statement and last_index */ EVENT_LIST(EVENT_TYPE_WRITE_SQL, X); default: error("Event %llu has Unknown event code %d", eventCount, code); } /* bind the fields we store for every event */ \ res = sqlite3_bind_int64(statement, last_index+1, logSerial); if (res != SQLITE_OK) sqlite_error(res, db, "Event %llu bind of log_serial failed.", eventCount); res = sqlite3_bind_int64(statement, last_index+2, clock_field); if (res != SQLITE_OK) sqlite_error(res, db, "Event %llu bind of clock failed.", eventCount); res = sqlite3_step(statement); if (res != SQLITE_DONE) sqlite_error(res, db, "insert of event %llu failed.", eventCount); res = sqlite3_reset(statement); if (res != SQLITE_OK) sqlite_error(res, db, "Couldn't reset insert statement of event %llu", eventCount); if (progress) { if ((eventCount % SMALL_TICK) == 0) { printf("."); fflush(stdout); if (((eventCount / SMALL_TICK) % BIG_TICK) == 0) { printf("\n"); fflush(stdout); evlog(LOG_SOMETIMES, "%lu events.", (unsigned long)eventCount); } } } } if (progress) { printf("\n"); fflush(stdout); } runStatement(db, "COMMIT", "Transaction finish"); logFileCompleted(db, eventCount); /* finalize all the statements */ EVENT_LIST(EVENT_TYPE_FINALIZE_STATEMENT, X); return eventCount; }
/* * Converts the number given in 'str', which may be given in a humanized * form (as described in humanize_number(3), but with some limitations), * to an int64_t without units. * In case of success, 0 is returned and *size holds the value. * Otherwise, -1 is returned and *size is untouched. * * TODO: Internationalization, SI units. */ int dehumanize_number(const char *str, int64_t *size) { char *ep, unit; const char *delimit; long multiplier; long long tmp, tmp2; size_t len; len = strlen(str); if (len == 0) { errno = EINVAL; return -1; } multiplier = 1; unit = str[len - 1]; if (isalpha((unsigned char)unit)) { switch (tolower((unsigned char)unit)) { case 'b': multiplier = 1; break; case 'k': multiplier = 1024; break; case 'm': multiplier = 1024 * 1024; break; case 'g': multiplier = 1024 * 1024 * 1024; break; default: errno = EINVAL; return -1; /* Invalid suffix. */ } delimit = &str[len - 1]; } else delimit = NULL; errno = 0; tmp = strtoll(str, &ep, 10); if (str[0] == '\0' || (ep != delimit && *ep != '\0')) return -1; /* Not a number. */ else if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN)) return -1; /* Out of range. */ tmp2 = tmp * multiplier; tmp2 = tmp2 / multiplier; if (tmp != tmp2) { errno = ERANGE; return -1; /* Out of range. */ } tmp *= multiplier; #ifdef _DIAGASSERT _DIAGASSERT(__type_fit(int64_t, tmp)); #endif *size = (int64_t)tmp; return 0; }
int main(int argc, char **argv) { int rval; char c; int n, i, cc; argc--, argv++; if (argc > 0) { debug = fopen(*argv, "w"); if (debug == 0) exit(1); (void)setbuf(debug, (char *)0); } top: errno = 0; rval = 0; if (read(STDIN_FILENO, &c, 1) != 1) exit(0); switch (c) { case 'O': if (tape >= 0) (void) close(tape); getstring(device); getstring(mode); DEBUG2("rmtd: O %s %s\n", device, mode); /* * XXX the rmt protocol does not provide a means to * specify the permission bits; allow rw for everyone, * as modified by the users umask */ tape = open(device, atoi(mode), 0666); if (tape < 0) goto ioerror; goto respond; case 'C': DEBUG("rmtd: C\n"); getstring(device); /* discard */ if (close(tape) < 0) goto ioerror; tape = -1; goto respond; case 'L': getstring(count); getstring(pos); DEBUG2("rmtd: L %s %s\n", count, pos); rval = lseek(tape, (off_t)strtoll(count, NULL, 10), atoi(pos)); if (rval < 0) goto ioerror; goto respond; case 'W': getstring(count); n = atoi(count); DEBUG1("rmtd: W %s\n", count); record = checkbuf(record, n); for (i = 0; i < n; i += cc) { cc = read(STDIN_FILENO, &record[i], n - i); if (cc <= 0) { DEBUG("rmtd: premature eof\n"); exit(2); } } rval = write(tape, record, n); if (rval < 0) goto ioerror; goto respond; case 'R': getstring(count); DEBUG1("rmtd: R %s\n", count); n = atoi(count); record = checkbuf(record, n); rval = read(tape, record, n); if (rval < 0) goto ioerror; (void)sprintf(resp, "A%d\n", rval); (void)write(STDOUT_FILENO, resp, strlen(resp)); (void)write(STDOUT_FILENO, record, rval); goto top; case 'I': getstring(op); getstring(count); DEBUG2("rmtd: I %s %s\n", op, count); { struct mtop mtop; mtop.mt_op = atoi(op); mtop.mt_count = atoi(count); if (ioctl(tape, MTIOCTOP, (char *)&mtop) < 0) goto ioerror; rval = mtop.mt_count; } goto respond; case 'S': /* status */ DEBUG("rmtd: S\n"); { struct mtget mtget; if (ioctl(tape, MTIOCGET, (char *)&mtget) < 0) goto ioerror; rval = sizeof (mtget); if (rval > 24) /* original mtget structure size */ rval = 24; (void)sprintf(resp, "A%d\n", rval); (void)write(STDOUT_FILENO, resp, strlen(resp)); (void)write(STDOUT_FILENO, (char *)&mtget, rval); goto top; } case 'V': /* version */ getstring(op); DEBUG1("rmtd: V %s\n", op); rval = 2; goto respond; default: DEBUG1("rmtd: garbage command %c\n", c); exit(3); } respond: DEBUG1("rmtd: A %d\n", rval); (void)sprintf(resp, "A%d\n", rval); (void)write(STDOUT_FILENO, resp, strlen(resp)); goto top; ioerror: error(errno); goto top; }
int put_str_one(void *buf,char *cp,T_PkgType *typ,char CURDLM) { int ret; register char *cp1; cp1=typ->offset+(char *)buf; ret=0; switch(typ->type) { case CH_CLOB: *(char **)cp1=cp; if(CURDLM) strcpy_esc(cp,cp,-1,CURDLM); //有问题 typ->len=strlen(cp); ret=1; break; case CH_BYTE: byte_cpy(cp1,cp,typ->len); ret=1; break; case CH_DATE: case CH_CNUM: case CH_CHAR: *cp1=0; strcpy_esc(cp1,cp,typ->len,CURDLM); ret=1; break; case CH_FLOAT: *(float *)cp1=strtof(cp,&cp);; ret=1; break; case CH_DOUBLE: *(double *)cp1=strtod(cp,&cp);; ret=1; break; case CH_LDOUBLE: *(long double *)cp1=strtold(cp,&cp); break; case CH_JUL: case CH_CJUL: if(!*cp) *(INT4 *)cp1=TIMENULL; else if(typ->format){ *(int *)cp1=rstrfmttojul(cp, typ->format); } else { *(int *)cp1= rstrjul(cp); } ret=1; break; case CH_MINUTS: case CH_CMINUTS: if(!*cp) *(INT4 *)cp1=TIMENULL; else if(typ->format){ *(INT4 *)cp1=rstrminfmt(cp,typ->format); } else *(INT4 *)cp1=rstrmin(cp); ret=1; break; case CH_TIME: case CH_CTIME: if(!*cp) *(INT64 *)cp1=INT64NULL; else if(typ->format){ *(INT64 *)cp1=rstrsecfmt(cp,typ->format); } else *(INT64 *)cp1=rstrsecfmt(cp,"YYYYMMDDHH24MISS"); ret=1; break; case CH_USEC: if(!*cp) *(INT64 *)cp1=INT64NULL; else if(typ->format){ *(INT64 *)cp1=rstrusecfmt(cp,typ->format); } else *(INT64 *)cp1=rstrusecfmt(cp,"YYYYMMDDHH24MISS.FF6"); ret=1; break; case CH_TINY: { int tmp; if(!*cp) { *cp1=TINYNULL; break; } tmp=atoi(cp); *cp1=(char)tmp; break; } case CH_SHORT: *(short *)cp1=SHORTNULL; ret=sscanf(cp,"%hd",(short *)cp1); ret=1; break; case CH_INT: if(!*cp) { *(int *)cp1=INTNULL; break; } *(int *)cp1=atoi(cp); break; case CH_LONG: if(!*cp) { *(long *)cp1=LONGNULL; break; } *(long *)cp1=strtol(cp,&cp,10); break; case CH_INT64: if(!*cp) { *(INT64 *)cp1=INT64NULL; break; } *(INT64 *)cp1=strtoll(cp,&cp,10); break; default: ret=0; break; } return ret; }
int main (int argc, char **argv) { rd_kafka_topic_t *rkt; char *brokers = "localhost:9092"; char mode = 'C'; char *topic = NULL; int partition = RD_KAFKA_PARTITION_UA; int opt; rd_kafka_conf_t *conf; rd_kafka_topic_conf_t *topic_conf; char errstr[512]; int64_t start_offset = 0; int report_offsets = 0; int do_conf_dump = 0; char tmp[16]; int64_t seek_offset = 0; int64_t tmp_offset = 0; int get_wmarks = 0; quiet = !isatty(STDIN_FILENO); /* Kafka configuration */ conf = rd_kafka_conf_new(); /* Set logger */ rd_kafka_conf_set_log_cb(conf, logger); /* Quick termination */ snprintf(tmp, sizeof(tmp), "%i", SIGIO); rd_kafka_conf_set(conf, "internal.termination.signal", tmp, NULL, 0); /* Topic configuration */ topic_conf = rd_kafka_topic_conf_new(); while ((opt = getopt(argc, argv, "PCLt:p:b:z:qd:o:eX:As:")) != -1) { switch (opt) { case 'P': case 'C': case 'L': mode = opt; break; case 't': topic = optarg; break; case 'p': partition = atoi(optarg); break; case 'b': brokers = optarg; break; case 'z': if (rd_kafka_conf_set(conf, "compression.codec", optarg, errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) { fprintf(stderr, "%% %s\n", errstr); exit(1); } break; case 'o': case 's': if (!strcmp(optarg, "end")) tmp_offset = RD_KAFKA_OFFSET_END; else if (!strcmp(optarg, "beginning")) tmp_offset = RD_KAFKA_OFFSET_BEGINNING; else if (!strcmp(optarg, "stored")) tmp_offset = RD_KAFKA_OFFSET_STORED; else if (!strcmp(optarg, "report")) report_offsets = 1; else if (!strcmp(optarg, "wmark")) get_wmarks = 1; else { tmp_offset = strtoll(optarg, NULL, 10); if (tmp_offset < 0) tmp_offset = RD_KAFKA_OFFSET_TAIL(-tmp_offset); } if (opt == 'o') start_offset = tmp_offset; else if (opt == 's') seek_offset = tmp_offset; break; case 'e': exit_eof = 1; break; case 'd': if (rd_kafka_conf_set(conf, "debug", optarg, errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) { fprintf(stderr, "%% Debug configuration failed: " "%s: %s\n", errstr, optarg); exit(1); } break; case 'q': quiet = 1; break; case 'A': output = OUTPUT_RAW; break; case 'X': { char *name, *val; rd_kafka_conf_res_t res; if (!strcmp(optarg, "list") || !strcmp(optarg, "help")) { rd_kafka_conf_properties_show(stdout); exit(0); } if (!strcmp(optarg, "dump")) { do_conf_dump = 1; continue; } name = optarg; if (!(val = strchr(name, '='))) { char dest[512]; size_t dest_size = sizeof(dest); /* Return current value for property. */ res = RD_KAFKA_CONF_UNKNOWN; if (!strncmp(name, "topic.", strlen("topic."))) res = rd_kafka_topic_conf_get( topic_conf, name+strlen("topic."), dest, &dest_size); if (res == RD_KAFKA_CONF_UNKNOWN) res = rd_kafka_conf_get( conf, name, dest, &dest_size); if (res == RD_KAFKA_CONF_OK) { printf("%s = %s\n", name, dest); exit(0); } else { fprintf(stderr, "%% %s property\n", res == RD_KAFKA_CONF_UNKNOWN ? "Unknown" : "Invalid"); exit(1); } } *val = '\0'; val++; res = RD_KAFKA_CONF_UNKNOWN; /* Try "topic." prefixed properties on topic * conf first, and then fall through to global if * it didnt match a topic configuration property. */ if (!strncmp(name, "topic.", strlen("topic."))) res = rd_kafka_topic_conf_set(topic_conf, name+ strlen("topic."), val, errstr, sizeof(errstr)); if (res == RD_KAFKA_CONF_UNKNOWN) res = rd_kafka_conf_set(conf, name, val, errstr, sizeof(errstr)); if (res != RD_KAFKA_CONF_OK) { fprintf(stderr, "%% %s\n", errstr); exit(1); } } break; default: goto usage; } } if (do_conf_dump) { const char **arr; size_t cnt; int pass; for (pass = 0 ; pass < 2 ; pass++) { int i; if (pass == 0) { arr = rd_kafka_conf_dump(conf, &cnt); printf("# Global config\n"); } else { printf("# Topic config\n"); arr = rd_kafka_topic_conf_dump(topic_conf, &cnt); } for (i = 0 ; i < (int)cnt ; i += 2) printf("%s = %s\n", arr[i], arr[i+1]); printf("\n"); rd_kafka_conf_dump_free(arr, cnt); } exit(0); } if (optind != argc || (mode != 'L' && !topic)) { usage: fprintf(stderr, "Usage: %s -C|-P|-L -t <topic> " "[-p <partition>] [-b <host1:port1,host2:port2,..>]\n" "\n" "librdkafka version %s (0x%08x)\n" "\n" " Options:\n" " -C | -P Consumer or Producer mode\n" " -L Metadata list mode\n" " -t <topic> Topic to fetch / produce\n" " -p <num> Partition (random partitioner)\n" " -b <brokers> Broker address (localhost:9092)\n" " -z <codec> Enable compression:\n" " none|gzip|snappy\n" " -o <offset> Start offset (consumer):\n" " beginning, end, NNNNN or -NNNNN\n" " wmark returns the current hi&lo " "watermarks.\n" " -o report Report message offsets (producer)\n" " -e Exit consumer when last message\n" " in partition has been received.\n" " -d [facs..] Enable debugging contexts:\n" " %s\n" " -q Be quiet\n" " -A Raw payload output (consumer)\n" " -X <prop=name> Set arbitrary librdkafka " "configuration property\n" " Properties prefixed with \"topic.\" " "will be set on topic object.\n" " -X list Show full list of supported " "properties.\n" " -X <prop> Get single property value\n" "\n" " In Consumer mode:\n" " writes fetched messages to stdout\n" " In Producer mode:\n" " reads messages from stdin and sends to broker\n" " In List mode:\n" " queries broker for metadata information, " "topic is optional.\n" "\n" "\n" "\n", argv[0], rd_kafka_version_str(), rd_kafka_version(), RD_KAFKA_DEBUG_CONTEXTS); exit(1); } signal(SIGINT, stop); signal(SIGUSR1, sig_usr1); if (mode == 'P') { /* * Producer */ char buf[2048]; int sendcnt = 0; /* Set up a message delivery report callback. * It will be called once for each message, either on successful * delivery to broker, or upon failure to deliver to broker. */ /* If offset reporting (-o report) is enabled, use the * richer dr_msg_cb instead. */ if (report_offsets) { rd_kafka_topic_conf_set(topic_conf, "produce.offset.report", "true", errstr, sizeof(errstr)); rd_kafka_conf_set_dr_msg_cb(conf, msg_delivered2); } else rd_kafka_conf_set_dr_cb(conf, msg_delivered); /* Create Kafka handle */ if (!(rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr)))) { fprintf(stderr, "%% Failed to create new producer: %s\n", errstr); exit(1); } rd_kafka_set_log_level(rk, LOG_DEBUG); /* Add brokers */ if (rd_kafka_brokers_add(rk, brokers) == 0) { fprintf(stderr, "%% No valid brokers specified\n"); exit(1); } /* Create topic */ rkt = rd_kafka_topic_new(rk, topic, topic_conf); topic_conf = NULL; /* Now owned by topic */ if (!quiet) fprintf(stderr, "%% Type stuff and hit enter to send\n"); while (run && fgets(buf, sizeof(buf), stdin)) { size_t len = strlen(buf); if (buf[len-1] == '\n') buf[--len] = '\0'; /* Send/Produce message. */ if (rd_kafka_produce(rkt, partition, RD_KAFKA_MSG_F_COPY, /* Payload and length */ buf, len, /* Optional key and its length */ NULL, 0, /* Message opaque, provided in * delivery report callback as * msg_opaque. */ NULL) == -1) { fprintf(stderr, "%% Failed to produce to topic %s " "partition %i: %s\n", rd_kafka_topic_name(rkt), partition, rd_kafka_err2str(rd_kafka_last_error())); /* Poll to handle delivery reports */ rd_kafka_poll(rk, 0); continue; } if (!quiet) fprintf(stderr, "%% Sent %zd bytes to topic " "%s partition %i\n", len, rd_kafka_topic_name(rkt), partition); sendcnt++; /* Poll to handle delivery reports */ rd_kafka_poll(rk, 0); } /* Poll to handle delivery reports */ rd_kafka_poll(rk, 0); /* Wait for messages to be delivered */ while (run && rd_kafka_outq_len(rk) > 0) rd_kafka_poll(rk, 100); /* Destroy topic */ rd_kafka_topic_destroy(rkt); /* Destroy the handle */ rd_kafka_destroy(rk); } else if (mode == 'C') { /* * Consumer */ /* Create Kafka handle */ if (!(rk = rd_kafka_new(RD_KAFKA_CONSUMER, conf, errstr, sizeof(errstr)))) { fprintf(stderr, "%% Failed to create new consumer: %s\n", errstr); exit(1); } rd_kafka_set_log_level(rk, LOG_DEBUG); /* Add brokers */ if (rd_kafka_brokers_add(rk, brokers) == 0) { fprintf(stderr, "%% No valid brokers specified\n"); exit(1); } if (get_wmarks) { int64_t lo, hi; rd_kafka_resp_err_t err; /* Only query for hi&lo partition watermarks */ if ((err = rd_kafka_query_watermark_offsets( rk, topic, partition, &lo, &hi, 5000))) { fprintf(stderr, "%% query_watermark_offsets() " "failed: %s\n", rd_kafka_err2str(err)); exit(1); } printf("%s [%d]: low - high offsets: " "%"PRId64" - %"PRId64"\n", topic, partition, lo, hi); rd_kafka_destroy(rk); exit(0); } /* Create topic */ rkt = rd_kafka_topic_new(rk, topic, topic_conf); topic_conf = NULL; /* Now owned by topic */ /* Start consuming */ if (rd_kafka_consume_start(rkt, partition, start_offset) == -1){ rd_kafka_resp_err_t err = rd_kafka_last_error(); fprintf(stderr, "%% Failed to start consuming: %s\n", rd_kafka_err2str(err)); if (err == RD_KAFKA_RESP_ERR__INVALID_ARG) fprintf(stderr, "%% Broker based offset storage " "requires a group.id, " "add: -X group.id=yourGroup\n"); exit(1); } while (run) { rd_kafka_message_t *rkmessage; rd_kafka_resp_err_t err; /* Poll for errors, etc. */ rd_kafka_poll(rk, 0); /* Consume single message. * See rdkafka_performance.c for high speed * consuming of messages. */ rkmessage = rd_kafka_consume(rkt, partition, 1000); if (!rkmessage) /* timeout */ continue; msg_consume(rkmessage, NULL); /* Return message to rdkafka */ rd_kafka_message_destroy(rkmessage); if (seek_offset) { err = rd_kafka_seek(rkt, partition, seek_offset, 2000); if (err) printf("Seek failed: %s\n", rd_kafka_err2str(err)); else printf("Seeked to %"PRId64"\n", seek_offset); seek_offset = 0; } } /* Stop consuming */ rd_kafka_consume_stop(rkt, partition); while (rd_kafka_outq_len(rk) > 0) rd_kafka_poll(rk, 10); /* Destroy topic */ rd_kafka_topic_destroy(rkt); /* Destroy handle */ rd_kafka_destroy(rk); } else if (mode == 'L') { rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR; /* Create Kafka handle */ if (!(rk = rd_kafka_new(RD_KAFKA_PRODUCER, conf, errstr, sizeof(errstr)))) { fprintf(stderr, "%% Failed to create new producer: %s\n", errstr); exit(1); } rd_kafka_set_log_level(rk, LOG_DEBUG); /* Add brokers */ if (rd_kafka_brokers_add(rk, brokers) == 0) { fprintf(stderr, "%% No valid brokers specified\n"); exit(1); } /* Create topic */ if (topic) { rkt = rd_kafka_topic_new(rk, topic, topic_conf); topic_conf = NULL; /* Now owned by topic */ } else rkt = NULL; while (run) { const struct rd_kafka_metadata *metadata; /* Fetch metadata */ err = rd_kafka_metadata(rk, rkt ? 0 : 1, rkt, &metadata, 5000); if (err != RD_KAFKA_RESP_ERR_NO_ERROR) { fprintf(stderr, "%% Failed to acquire metadata: %s\n", rd_kafka_err2str(err)); run = 0; break; } metadata_print(topic, metadata); rd_kafka_metadata_destroy(metadata); run = 0; } /* Destroy topic */ if (rkt) rd_kafka_topic_destroy(rkt); /* Destroy the handle */ rd_kafka_destroy(rk); if (topic_conf) rd_kafka_topic_conf_destroy(topic_conf); /* Exit right away, dont wait for background cleanup, we haven't * done anything important anyway. */ exit(err ? 2 : 0); } if (topic_conf) rd_kafka_topic_conf_destroy(topic_conf); /* Let background threads clean up and terminate cleanly. */ run = 5; while (run-- > 0 && rd_kafka_wait_destroyed(1000) == -1) printf("Waiting for librdkafka to decommission\n"); if (run <= 0) rd_kafka_dump(stdout, rk); return 0; }
/* main */ int main(int argc, void *argv[]) { long lOpStart, lOpEnd; int flength, oplistlength, totaltime, proflistlength; int samp_unknown, samp_blockend, samp_notcompiled, samp_wrappers, samp_flush; int i, j; FILE *pfIn; r4300op *pOpAddrTable; profilehit *pProfTable; char *pch, *pchSampleData; /* check arguments */ if (argc < 3) { printf("Usage: r4300prof r4300addr.dat x86profile.txt\n\n"); printf("r4300addr.dat - binary table of r4300 opcodes and corresponding x86 starting addresses\n"); printf("x86profile.txt - text file containing a list of profile sample counts by x86 address on the heap\n\n"); return 1; } /* open r4300 opcode/x86 address table generated from emulator run */ printf("Loading %s...\n", argv[1]); pfIn = fopen(argv[1], "rb"); if (pfIn == NULL) { printf("Couldn't open input file: %s\n", argv[1]); return 2; } /* get file length and calculate number of r4300op table entries */ fseek(pfIn, 0L, SEEK_END); flength = (int) ftell(pfIn); fseek(pfIn, 0L, SEEK_SET); oplistlength = flength / sizeof(r4300op); /* read the file */ pOpAddrTable = (r4300op *) malloc(flength); if (pOpAddrTable == NULL) { printf("Failed to allocate %i bytes for OpAddrTable!\n", flength); fclose(pfIn); return 3; } fread(pOpAddrTable, 1, flength, pfIn); fclose(pfIn); printf("%i r4300 instruction locations read.\n", oplistlength); /* sort the opcode/address table according to x86addr */ qsort(pOpAddrTable, oplistlength, sizeof(r4300op), AddrCompare); /* remove any 0-length r4300 instructions */ i = 0; j = 0; while (i < oplistlength) { pOpAddrTable[j].mipsop = pOpAddrTable[i].mipsop; pOpAddrTable[j].x86addr = pOpAddrTable[i].x86addr; i++; if (pOpAddrTable[j].x86addr != pOpAddrTable[i].x86addr) j++; } oplistlength = j; printf("%i non-empty MIPS instructions.\n", oplistlength); /* convert each r4300 opcode to an instruction type index */ for (i = 0; i < oplistlength; i++) if (pOpAddrTable[i].mipsop > 0 || pOpAddrTable[i].mipsop < -16) pOpAddrTable[i].mipsop = GetInstrType(pOpAddrTable[i].mipsop); /* open the profiling sample data file */ printf("Loading %s...\n", argv[2]); pfIn = fopen(argv[2], "rb"); if (pfIn == NULL) { printf("Couldn't open input file: %s\n", argv[2]); free(pOpAddrTable); return 4; } /* load it */ fseek(pfIn, 0L, SEEK_END); flength = (int) ftell(pfIn); fseek(pfIn, 0L, SEEK_SET); pchSampleData = (char *) malloc(flength + 16); if (pchSampleData == NULL) { printf("Failed to allocate %i bytes for pchSampleData!\n", flength + 16); fclose(pfIn); free(pOpAddrTable); return 5; } fread(pchSampleData, 1, flength, pfIn); pchSampleData[flength] = 0; fclose(pfIn); /* count the number of newlines in the ascii-formatted sample data file */ proflistlength = 1; pch = pchSampleData; while (pch = strchr(pch, '\n')) { proflistlength++; pch++; } printf("%i lines in sample data file.\n", proflistlength); /* extract text data into binary table */ pProfTable = (profilehit *) malloc(proflistlength * sizeof(profilehit)); if (pProfTable == NULL) { printf("Failed to allocate %i bytes for pProfTable!\n", proflistlength * sizeof(profilehit)); free(pOpAddrTable); free(pchSampleData); return 6; } pch = pchSampleData; j = 0; long long llOffset = 0; while (j < proflistlength) { long lAddress; int iSamples; float fPercentage; char *pchNext = strchr(pch, '\n'); if (pchNext != NULL) *pchNext++ = 0; // null-terminate this line if (strstr(pch, "range:0x") != NULL) // search for offset change { pch = strstr(pch, "range:0x") + 8; // extract hex value and update our offset char *pch2 = pch; while (isHex(*pch2)) pch2++; *pch2 = 0; llOffset = strtoll(pch, NULL, 16); } else // parse line for sample point { int rval = ParseProfLine(pch, &lAddress, &iSamples, &fPercentage); if (rval != 0) { pProfTable[j].x86addr = (unsigned long) (lAddress + llOffset); pProfTable[j].samples = iSamples; j++; } } pch = pchNext; if (pch == NULL) break; } free(pchSampleData); proflistlength = j; printf("Found %i profile hits.\n", proflistlength); /* clear r4300 instruction sample data table */ for (i = 0; i < 132; i++) instr_samples[i] = 0; /* calculate r4300 instruction profiling data by merging the tables */ samp_unknown = 0; samp_blockend = 0; samp_notcompiled = 0; samp_wrappers = 0; samp_flush = 0; i = 0; // i == OpAddrTable index lOpStart = pOpAddrTable[0].x86addr; lOpEnd = pOpAddrTable[1].x86addr; for (j = 0; j < proflistlength; j++) // j == pProfTable index { long lOpx86addr = pProfTable[j].x86addr; if (lOpx86addr >= lOpStart && lOpx86addr <= lOpEnd) /* these profile samples lie within current r4300 instruction */ { int instr = pOpAddrTable[i].mipsop; if (instr == -1) printf("%lx sample point lies between %i/%lx and %i/%lx\n", lOpx86addr, instr, lOpStart, pOpAddrTable[i+1].mipsop, lOpEnd); if (instr == -1) samp_unknown += pProfTable[j].samples; else if (instr == -2) samp_notcompiled += pProfTable[j].samples; else if (instr == -3) samp_blockend += pProfTable[j].samples; else if (instr == -4) samp_wrappers += pProfTable[j].samples; else if (instr == -5) samp_flush += pProfTable[j].samples; else instr_samples[instr] += pProfTable[j].samples; continue; } if (lOpx86addr < pOpAddrTable[0].x86addr || lOpx86addr >= pOpAddrTable[oplistlength-1].x86addr) { /* outside the range of all recompiled instructions */ samp_unknown += pProfTable[j].samples; continue; } if (lOpx86addr < lOpStart) /* discontinuity in profile list, go back to start */ { i = 0; lOpStart = pOpAddrTable[0].x86addr; lOpEnd = pOpAddrTable[1].x86addr; j--; continue; } /* this profile point is ahead of current r4300 instruction */ do /* race ahead in r4300 opcode list until we hit this profile sample point */ { i++; } while (i+1 < oplistlength && lOpx86addr > pOpAddrTable[i+1].x86addr); lOpStart = pOpAddrTable[i].x86addr; lOpEnd = pOpAddrTable[i+1].x86addr; if (lOpx86addr < lOpStart || lOpx86addr > lOpEnd) { printf("Error: lOpx86addr = %lx but lOpStart, lOpEnd = %lx, %lx\n", lOpx86addr, lOpStart, lOpEnd); return 7; } /* we have found the correct r4300 instruction corresponding to this profile point */ j--; } /* print the results */ unsigned int iTypeCount[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; printf("\nInstruction time (samples):\n"); totaltime = 0; for (i = 0; i < 131; i++) { printf("%8s: %08i ", instr_name[i], instr_samples[i]); if (i % 5 == 4) printf("\n"); iTypeCount[instr_type[i]] += instr_samples[i]; totaltime += instr_samples[i]; } int special = samp_flush + samp_wrappers + samp_notcompiled + samp_blockend; printf("\n\nSpecial code samples:\n"); printf(" Regcache flushing: %i\n", samp_flush); printf(" Jump wrappers: %i\n", samp_wrappers); printf(" NOTCOMPILED: %i\n", samp_notcompiled); printf(" block postfix & link samples: %i\n", samp_blockend); printf("\nUnaccounted samples: %i\n", samp_unknown); printf("Total accounted instruction samples: %i\n", totaltime + special); for (i = 0; i < 11; i++) { printf("%20s: %04.1f%% (%i)\n", instr_typename[i], (float) iTypeCount[i] * 100.0 / totaltime, iTypeCount[i]); } free(pOpAddrTable); free(pProfTable); return 0; }
static int /* O - Command status */ recv_print_job( const char *queue, /* I - Printer name */ int num_defaults, /* I - Number of default options */ cups_option_t *defaults) /* I - Default options */ { http_t *http; /* HTTP connection */ int i; /* Looping var */ int status; /* Command status */ int fd; /* Temporary file */ FILE *fp; /* File pointer */ char filename[1024]; /* Temporary filename */ ssize_t bytes; /* Bytes received */ size_t total; /* Total bytes */ char line[256], /* Line from file/stdin */ command, /* Command from line */ *count, /* Number of bytes */ *name; /* Name of file */ const char *job_sheets; /* Job sheets */ int num_data; /* Number of data files */ char control[1024], /* Control filename */ data[100][256], /* Data files */ temp[100][1024]; /* Temporary files */ char user[1024], /* User name */ title[1024], /* Job title */ docname[1024], /* Document name */ dest[256]; /* Printer/class queue */ int accepting, /* printer-is-accepting */ shared, /* printer-is-shared */ num_options; /* Number of options */ cups_option_t *options; /* Options */ int id; /* Job ID */ int docnumber, /* Current document number */ doccount; /* Count of documents */ /* * Connect to the server... */ http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption()); if (!http) { syslog(LOG_ERR, "Unable to connect to server: %s", strerror(errno)); putchar(1); return (1); } /* * See if the printer is available... */ num_options = get_printer(http, queue, dest, sizeof(dest), &options, &accepting, &shared, NULL); if (num_options < 0 || !accepting || !shared) { if (dest[0]) syslog(LOG_INFO, "Rejecting job because \"%s\" is not %s", dest, !accepting ? "accepting jobs" : "shared"); else syslog(LOG_ERR, "Unable to get printer information for \"%s\"", queue); httpClose(http); putchar(1); return (1); } putchar(0); /* OK so far... */ /* * Read the request... */ status = 0; num_data = 0; fd = -1; control[0] = '\0'; while (smart_gets(line, sizeof(line), stdin) != NULL) { if (strlen(line) < 2) { status = 1; break; } command = line[0]; count = line + 1; for (name = count + 1; *name && !isspace(*name & 255); name ++); while (isspace(*name & 255)) *name++ = '\0'; switch (command) { default : case 0x01 : /* Abort */ status = 1; break; case 0x02 : /* Receive control file */ if (strlen(name) < 2) { syslog(LOG_ERR, "Bad control file name \"%s\"", name); putchar(1); status = 1; break; } if (control[0]) { /* * Append to the existing control file - the LPD spec is * not entirely clear, but at least the OS/2 LPD code sends * multiple control files per connection... */ if ((fd = open(control, O_WRONLY)) < 0) { syslog(LOG_ERR, "Unable to append to temporary control file \"%s\" - %s", control, strerror(errno)); putchar(1); status = 1; break; } lseek(fd, 0, SEEK_END); } else { if ((fd = cupsTempFd(control, sizeof(control))) < 0) { syslog(LOG_ERR, "Unable to open temporary control file \"%s\" - %s", control, strerror(errno)); putchar(1); status = 1; break; } strlcpy(filename, control, sizeof(filename)); } break; case 0x03 : /* Receive data file */ if (strlen(name) < 2) { syslog(LOG_ERR, "Bad data file name \"%s\"", name); putchar(1); status = 1; break; } if (num_data >= (int)(sizeof(data) / sizeof(data[0]))) { /* * Too many data files... */ syslog(LOG_ERR, "Too many data files (%d)", num_data); putchar(1); status = 1; break; } strlcpy(data[num_data], name, sizeof(data[0])); if ((fd = cupsTempFd(temp[num_data], sizeof(temp[0]))) < 0) { syslog(LOG_ERR, "Unable to open temporary data file \"%s\" - %s", temp[num_data], strerror(errno)); putchar(1); status = 1; break; } strlcpy(filename, temp[num_data], sizeof(filename)); num_data ++; break; } putchar(status); if (status) break; /* * Copy the data or control file from the client... */ for (total = (size_t)strtoll(count, NULL, 10); total > 0; total -= (size_t)bytes) { if (total > sizeof(line)) bytes = (ssize_t)sizeof(line); else bytes = (ssize_t)total; if ((bytes = (ssize_t)fread(line, 1, (size_t)bytes, stdin)) > 0) bytes = write(fd, line, (size_t)bytes); if (bytes < 1) { syslog(LOG_ERR, "Error while reading file - %s", strerror(errno)); status = 1; break; } } /* * Read trailing nul... */ if (!status) { if (fread(line, 1, 1, stdin) < 1) { status = 1; syslog(LOG_ERR, "Error while reading trailing nul - %s", strerror(errno)); } else if (line[0]) { status = 1; syslog(LOG_ERR, "Trailing character after file is not nul (%02X)!", line[0]); } } /* * Close the file and send an acknowledgement... */ close(fd); putchar(status); if (status) break; } if (!status) { /* * Process the control file and print stuff... */ if ((fp = fopen(control, "rb")) == NULL) status = 1; else { /* * Copy the default options... */ for (i = 0; i < num_defaults; i ++) num_options = cupsAddOption(defaults[i].name, defaults[i].value, num_options, &options); /* * Grab the job information... */ title[0] = '\0'; user[0] = '\0'; docname[0] = '\0'; doccount = 0; while (smart_gets(line, sizeof(line), fp) != NULL) { /* * Process control lines... */ switch (line[0]) { case 'J' : /* Job name */ strlcpy(title, line + 1, sizeof(title)); break; case 'N' : /* Document name */ strlcpy(docname, line + 1, sizeof(docname)); break; case 'P' : /* User identification */ strlcpy(user, line + 1, sizeof(user)); break; case 'L' : /* Print banner page */ /* * If a banner was requested and it's not overridden by a * command line option and the destination's default is none * then add the standard banner... */ if (cupsGetOption("job-sheets", num_defaults, defaults) == NULL && ((job_sheets = cupsGetOption("job-sheets", num_options, options)) == NULL || !strcmp(job_sheets, "none,none"))) { num_options = cupsAddOption("job-sheets", "standard", num_options, &options); } break; case 'c' : /* Plot CIF file */ case 'd' : /* Print DVI file */ case 'f' : /* Print formatted file */ case 'g' : /* Plot file */ case 'l' : /* Print file leaving control characters (raw) */ case 'n' : /* Print ditroff output file */ case 'o' : /* Print PostScript output file */ case 'p' : /* Print file with 'pr' format (prettyprint) */ case 'r' : /* File to print with FORTRAN carriage control */ case 't' : /* Print troff output file */ case 'v' : /* Print raster file */ doccount ++; if (line[0] == 'l' && !cupsGetOption("document-format", num_options, options)) num_options = cupsAddOption("raw", "", num_options, &options); if (line[0] == 'p') num_options = cupsAddOption("prettyprint", "", num_options, &options); break; } if (status) break; } /* * Check that we have a username... */ if (!user[0]) { syslog(LOG_WARNING, "No username specified by client! " "Using \"anonymous\"..."); strlcpy(user, "anonymous", sizeof(user)); } /* * Create the job... */ if ((id = create_job(http, dest, title, docname, user, num_options, options)) < 0) status = 1; else { /* * Then print the job files... */ rewind(fp); docname[0] = '\0'; docnumber = 0; while (smart_gets(line, sizeof(line), fp) != NULL) { /* * Process control lines... */ switch (line[0]) { case 'N' : /* Document name */ strlcpy(docname, line + 1, sizeof(docname)); break; case 'c' : /* Plot CIF file */ case 'd' : /* Print DVI file */ case 'f' : /* Print formatted file */ case 'g' : /* Plot file */ case 'l' : /* Print file leaving control characters (raw) */ case 'n' : /* Print ditroff output file */ case 'o' : /* Print PostScript output file */ case 'p' : /* Print file with 'pr' format (prettyprint) */ case 'r' : /* File to print with FORTRAN carriage control */ case 't' : /* Print troff output file */ case 'v' : /* Print raster file */ /* * Figure out which file we are printing... */ for (i = 0; i < num_data; i ++) if (!strcmp(data[i], line + 1)) break; if (i >= num_data) { status = 1; break; } /* * Send the print file... */ docnumber ++; if (print_file(http, id, temp[i], docname, user, cupsGetOption("document-format", num_options, options), docnumber == doccount)) status = 1; else status = 0; break; } if (status) break; } } fclose(fp); } } cupsFreeOptions(num_options, options); httpClose(http); /* * Clean up all temporary files and return... */ unlink(control); for (i = 0; i < num_data; i ++) unlink(temp[i]); return (status); }
/** * parse_options */ static void parse_options(int argc, char *argv[]) { long long ll; char *s, *s2; int c; if (argc && *argv) EXEC_NAME = *argv; fprintf(stderr, "%s v%s (libntfs-3g)\n", EXEC_NAME, VERSION); while ((c = getopt(argc, argv, "fh?nqvVl")) != EOF) switch (c) { case 'f': opts.force = 1; break; case 'n': opts.no_action = 1; break; case 'q': opts.quiet = 1; ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET); break; case 'v': opts.verbose++; ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE); break; case 'V': /* Version number already printed, so just exit. */ exit(0); case 'l': copyright(); license(); exit(0); case 'h': case '?': default: usage(); } if (optind == argc) usage(); if (opts.verbose > 1) ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG | NTFS_LOG_LEVEL_TRACE | NTFS_LOG_LEVEL_VERBOSE | NTFS_LOG_LEVEL_QUIET); /* Get the device. */ dev_name = argv[optind++]; ntfs_log_verbose("device name = %s\n", dev_name); if (optind == argc) usage(); /* Get the inode. */ ll = strtoll(argv[optind++], &s, 0); if (*s || !ll || (ll >= LLONG_MAX && errno == ERANGE)) err_exit("Invalid inode number: %s\n", argv[optind - 1]); inode = ll; ntfs_log_verbose("inode = %lli\n", (long long)inode); if (optind == argc) usage(); /* Get the attribute type, if specified. */ s = argv[optind++]; if (optind == argc) { attr_type = AT_DATA; attr_name = AT_UNNAMED; attr_name_len = 0; } else { unsigned long ul; ul = strtoul(s, &s2, 0); if (*s2 || !ul || (ul >= ULONG_MAX && errno == ERANGE)) err_exit("Invalid attribute type %s: %s\n", s, strerror(errno)); attr_type = ul; /* Get the attribute name, if specified. */ s = argv[optind++]; if (optind != argc) { /* Convert the string to little endian Unicode. */ attr_name_len = ntfs_mbstoucs(s, &attr_name); if ((int)attr_name_len < 0) err_exit("Invalid attribute name \"%s\": %s\n", s, strerror(errno)); /* Keep hold of the original string. */ s2 = s; s = argv[optind++]; if (optind != argc) usage(); } else { attr_name = AT_UNNAMED; attr_name_len = 0; } } ntfs_log_verbose("attribute type = 0x%x\n", (unsigned int)attr_type); if (attr_name == AT_UNNAMED) ntfs_log_verbose("attribute name = \"\" (UNNAMED)\n"); else ntfs_log_verbose("attribute name = \"%s\" (length %u Unicode " "characters)\n", s2, (unsigned int)attr_name_len); /* Get the new length. */ ll = strtoll(s, &s2, 0); if (*s2 || ll < 0 || (ll >= LLONG_MAX && errno == ERANGE)) err_exit("Invalid new length: %s\n", s); new_len = ll; ntfs_log_verbose("new length = %lli\n", (long long)new_len); }
void *pluginsd_worker_thread(void *arg) { struct plugind *cd = (struct plugind *)arg; char line[PLUGINSD_LINE_MAX + 1]; #ifdef DETACH_PLUGINS_FROM_NETDATA unsigned long long usec = 0, susec = 0; struct timeval last = {0, 0} , now = {0, 0}; #endif char *words[MAX_WORDS] = { NULL }; uint32_t SET_HASH = simple_hash("SET"); uint32_t BEGIN_HASH = simple_hash("BEGIN"); uint32_t END_HASH = simple_hash("END"); uint32_t FLUSH_HASH = simple_hash("FLUSH"); uint32_t CHART_HASH = simple_hash("CHART"); uint32_t DIMENSION_HASH = simple_hash("DIMENSION"); uint32_t DISABLE_HASH = simple_hash("DISABLE"); #ifdef DETACH_PLUGINS_FROM_NETDATA uint32_t MYPID_HASH = simple_hash("MYPID"); uint32_t STOPPING_WAKE_ME_UP_PLEASE_HASH = simple_hash("STOPPING_WAKE_ME_UP_PLEASE"); #endif size_t count = 0; for(;;) { if(unlikely(netdata_exit)) break; FILE *fp = mypopen(cd->cmd, &cd->pid); if(unlikely(!fp)) { error("Cannot popen(\"%s\", \"r\").", cd->cmd); break; } info("PLUGINSD: '%s' running on pid %d", cd->fullfilename, cd->pid); RRDSET *st = NULL; char *s; uint32_t hash; while(likely(fgets(line, PLUGINSD_LINE_MAX, fp) != NULL)) { if(unlikely(netdata_exit)) break; line[PLUGINSD_LINE_MAX] = '\0'; // debug(D_PLUGINSD, "PLUGINSD: %s: %s", cd->filename, line); int w = pluginsd_split_words(line, words, MAX_WORDS); s = words[0]; if(unlikely(!s || !*s || !w)) { // debug(D_PLUGINSD, "PLUGINSD: empty line"); continue; } // debug(D_PLUGINSD, "PLUGINSD: words 0='%s' 1='%s' 2='%s' 3='%s' 4='%s' 5='%s' 6='%s' 7='%s' 8='%s' 9='%s'", words[0], words[1], words[2], words[3], words[4], words[5], words[6], words[7], words[8], words[9]); hash = simple_hash(s); if(likely(hash == SET_HASH && !strcmp(s, "SET"))) { char *dimension = words[1]; char *value = words[2]; if(unlikely(!dimension || !*dimension)) { error("PLUGINSD: '%s' is requesting a SET on chart '%s', without a dimension. Disabling it.", cd->fullfilename, st->id); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } if(unlikely(!value || !*value)) value = NULL; if(unlikely(!st)) { error("PLUGINSD: '%s' is requesting a SET on dimension %s with value %s, without a BEGIN. Disabling it.", cd->fullfilename, dimension, value?value:"<nothing>"); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: '%s' is setting dimension %s/%s to %s", cd->fullfilename, st->id, dimension, value?value:"<nothing>"); if(value) rrddim_set(st, dimension, strtoll(value, NULL, 0)); } else if(likely(hash == BEGIN_HASH && !strcmp(s, "BEGIN"))) { char *id = words[1]; char *microseconds_txt = words[2]; if(unlikely(!id)) { error("PLUGINSD: '%s' is requesting a BEGIN without a chart id. Disabling it.", cd->fullfilename); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } st = rrdset_find(id); if(unlikely(!st)) { error("PLUGINSD: '%s' is requesting a BEGIN on chart '%s', which does not exist. Disabling it.", cd->fullfilename, id); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } if(likely(st->counter_done)) { unsigned long long microseconds = 0; if(microseconds_txt && *microseconds_txt) microseconds = strtoull(microseconds_txt, NULL, 10); if(microseconds) rrdset_next_usec(st, microseconds); else rrdset_next_plugins(st); } } else if(likely(hash == END_HASH && !strcmp(s, "END"))) { if(unlikely(!st)) { error("PLUGINSD: '%s' is requesting an END, without a BEGIN. Disabling it.", cd->fullfilename); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: '%s' is requesting an END on chart %s", cd->fullfilename, st->id); rrdset_done(st); st = NULL; count++; } else if(likely(hash == FLUSH_HASH && !strcmp(s, "FLUSH"))) { debug(D_PLUGINSD, "PLUGINSD: '%s' is requesting a FLUSH", cd->fullfilename); st = NULL; } else if(likely(hash == CHART_HASH && !strcmp(s, "CHART"))) { int noname = 0; st = NULL; if((words[1]) != NULL && (words[2]) != NULL && strcmp(words[1], words[2]) == 0) noname = 1; char *type = words[1]; char *id = NULL; if(likely(type)) { id = strchr(type, '.'); if(likely(id)) { *id = '\0'; id++; } } char *name = words[2]; char *title = words[3]; char *units = words[4]; char *family = words[5]; char *context = words[6]; char *chart = words[7]; char *priority_s = words[8]; char *update_every_s = words[9]; if(unlikely(!type || !*type || !id || !*id)) { error("PLUGINSD: '%s' is requesting a CHART, without a type.id. Disabling it.", cd->fullfilename); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } int priority = 1000; if(likely(priority_s)) priority = atoi(priority_s); int update_every = cd->update_every; if(likely(update_every_s)) update_every = atoi(update_every_s); if(unlikely(!update_every)) update_every = cd->update_every; int chart_type = RRDSET_TYPE_LINE; if(unlikely(chart)) chart_type = rrdset_type_id(chart); if(unlikely(noname || !name || !*name || strcasecmp(name, "NULL") == 0 || strcasecmp(name, "(NULL)") == 0)) name = NULL; if(unlikely(!family || !*family)) family = NULL; if(unlikely(!context || !*context)) context = NULL; st = rrdset_find_bytype(type, id); if(unlikely(!st)) { debug(D_PLUGINSD, "PLUGINSD: Creating chart type='%s', id='%s', name='%s', family='%s', context='%s', chart='%s', priority=%d, update_every=%d" , type, id , name?name:"" , family?family:"" , context?context:"" , rrdset_type_name(chart_type) , priority , update_every ); st = rrdset_create(type, id, name, family, context, title, units, priority, update_every, chart_type); cd->update_every = update_every; } else debug(D_PLUGINSD, "PLUGINSD: Chart '%s' already exists. Not adding it again.", st->id); } else if(likely(hash == DIMENSION_HASH && !strcmp(s, "DIMENSION"))) { char *id = words[1]; char *name = words[2]; char *algorithm = words[3]; char *multiplier_s = words[4]; char *divisor_s = words[5]; char *options = words[6]; if(unlikely(!id || !*id)) { error("PLUGINSD: '%s' is requesting a DIMENSION, without an id. Disabling it.", cd->fullfilename); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } if(unlikely(!st)) { error("PLUGINSD: '%s' is requesting a DIMENSION, without a CHART. Disabling it.", cd->fullfilename); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } long multiplier = 1; if(multiplier_s && *multiplier_s) multiplier = strtol(multiplier_s, NULL, 0); if(unlikely(!multiplier)) multiplier = 1; long divisor = 1; if(likely(divisor_s && *divisor_s)) divisor = strtol(divisor_s, NULL, 0); if(unlikely(!divisor)) divisor = 1; if(unlikely(!algorithm || !*algorithm)) algorithm = "absolute"; if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: Creating dimension in chart %s, id='%s', name='%s', algorithm='%s', multiplier=%ld, divisor=%ld, hidden='%s'" , st->id , id , name?name:"" , rrddim_algorithm_name(rrddim_algorithm_id(algorithm)) , multiplier , divisor , options?options:"" ); RRDDIM *rd = rrddim_find(st, id); if(unlikely(!rd)) { rd = rrddim_add(st, id, name, multiplier, divisor, rrddim_algorithm_id(algorithm)); rd->flags = 0x00000000; if(options && *options) { if(strstr(options, "hidden") != NULL) rd->flags |= RRDDIM_FLAG_HIDDEN; if(strstr(options, "noreset") != NULL) rd->flags |= RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS; if(strstr(options, "nooverflow") != NULL) rd->flags |= RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS; } } else if(unlikely(st->debug)) debug(D_PLUGINSD, "PLUGINSD: dimension %s/%s already exists. Not adding it again.", st->id, id); } else if(unlikely(hash == DISABLE_HASH && !strcmp(s, "DISABLE"))) { error("PLUGINSD: '%s' called DISABLE. Disabling it.", cd->fullfilename); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } #ifdef DETACH_PLUGINS_FROM_NETDATA else if(likely(hash == MYPID_HASH && !strcmp(s, "MYPID"))) { char *pid_s = words[1]; pid_t pid = strtod(pid_s, NULL, 0); if(likely(pid)) cd->pid = pid; debug(D_PLUGINSD, "PLUGINSD: %s is on pid %d", cd->id, cd->pid); } else if(likely(hash == STOPPING_WAKE_ME_UP_PLEASE_HASH && !strcmp(s, "STOPPING_WAKE_ME_UP_PLEASE"))) { error("PLUGINSD: '%s' (pid %d) called STOPPING_WAKE_ME_UP_PLEASE.", cd->fullfilename, cd->pid); gettimeofday(&now, NULL); if(unlikely(!usec && !susec)) { // our first run susec = cd->rrd_update_every * 1000000ULL; } else { // second+ run usec = usec_dt(&now, &last) - susec; error("PLUGINSD: %s last loop took %llu usec (worked for %llu, sleeped for %llu).\n", cd->fullfilename, usec + susec, usec, susec); if(unlikely(usec < (rrd_update_every * 1000000ULL / 2ULL))) susec = (rrd_update_every * 1000000ULL) - usec; else susec = rrd_update_every * 1000000ULL / 2ULL; } error("PLUGINSD: %s sleeping for %llu. Will kill with SIGCONT pid %d to wake it up.\n", cd->fullfilename, susec, cd->pid); usleep(susec); killpid(cd->pid, SIGCONT); memmove(&last, &now, sizeof(struct timeval)); break; } #endif else { error("PLUGINSD: '%s' is sending command '%s' which is not known by netdata. Disabling it.", cd->fullfilename, s); cd->enabled = 0; killpid(cd->pid, SIGTERM); break; } } if(likely(count)) { cd->successful_collections += count; cd->serial_failures = 0; } else cd->serial_failures++; info("PLUGINSD: '%s' on pid %d stopped after %zu successful data collections (ENDs).", cd->fullfilename, cd->pid, count); // get the return code int code = mypclose(fp, cd->pid); if(unlikely(netdata_exit)) break; else if(code != 0) { // the plugin reports failure if(likely(!cd->successful_collections)) { // nothing collected - disable it error("PLUGINSD: '%s' exited with error code %d. Disabling it.", cd->fullfilename, code); cd->enabled = 0; } else { // we have collected something if(likely(cd->serial_failures <= 10)) { error("PLUGINSD: '%s' exited with error code %d, but has given useful output in the past (%zu times). Waiting a bit before starting it again.", cd->fullfilename, code, cd->successful_collections); sleep((unsigned int) (cd->update_every * 10)); } else { error("PLUGINSD: '%s' exited with error code %d, but has given useful output in the past (%zu times). We tried %zu times to restart it, but it failed to generate data. Disabling it.", cd->fullfilename, code, cd->successful_collections, cd->serial_failures); cd->enabled = 0; } } } else { // the plugin reports success if(unlikely(!cd->successful_collections)) { // we have collected nothing so far if(likely(cd->serial_failures <= 10)) { error("PLUGINSD: '%s' (pid %d) does not generate useful output but it reports success (exits with 0). Waiting a bit before starting it again.", cd->fullfilename, cd->pid); sleep((unsigned int) (cd->update_every * 10)); } else { error("PLUGINSD: '%s' (pid %d) does not generate useful output, although it reports success (exits with 0), but we have tried %zu times to collect something. Disabling it.", cd->fullfilename, cd->pid, cd->serial_failures); cd->enabled = 0; } } else sleep((unsigned int) cd->update_every); } cd->pid = 0; if(unlikely(!cd->enabled)) break; } info("PLUGINSD: '%s' thread exiting", cd->fullfilename); cd->obsolete = 1; pthread_exit(NULL); return NULL; }
/* LONGLONG */ long long int atoll(const char *str) { return (strtoll(str, (char **)NULL, 10)); }
/** Parse a stringified option * This function parse a string option and create the associated object * variable * The option must be of the form "[no[-]]foo[=bar]" where foo is the * option name and bar is the value of the option. * \param p_obj the object in which the variable must be created * \param psz_option the option to parse * \param trusted whether the option is set by a trusted input or not * \return nothing */ void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, bool trusted ) { char *psz_name, *psz_value; int i_type; bool b_isno = false; vlc_value_t val; val.psz_string = NULL; /* It's too much of a hassle to remove the ':' when we parse * the cmd line :) */ if( psz_option[0] == ':' ) psz_option++; if( !psz_option[0] ) return; psz_name = strdup( psz_option ); if( psz_name == NULL ) return; psz_value = strchr( psz_name, '=' ); if( psz_value != NULL ) *psz_value++ = '\0'; i_type = config_GetType( p_obj, psz_name ); if( !i_type && !psz_value ) { /* check for "no-foo" or "nofoo" */ if( !strncmp( psz_name, "no-", 3 ) ) { memmove( psz_name, psz_name + 3, strlen(psz_name) + 1 - 3 ); } else if( !strncmp( psz_name, "no", 2 ) ) { memmove( psz_name, psz_name + 2, strlen(psz_name) + 1 - 2 ); } else goto cleanup; /* Option doesn't exist */ b_isno = true; i_type = config_GetType( p_obj, psz_name ); } if( !i_type ) goto cleanup; /* Option doesn't exist */ if( ( i_type != VLC_VAR_BOOL ) && ( !psz_value || !*psz_value ) ) goto cleanup; /* Invalid value */ /* check if option is unsafe */ if( !trusted && !config_IsSafe( psz_name ) ) { msg_Err( p_obj, "unsafe option \"%s\" has been ignored for " "security reasons", psz_name ); free( psz_name ); return; } /* Create the variable in the input object. * Children of the input object will be able to retreive this value * thanks to the inheritance property of the object variables. */ var_Create( p_obj, psz_name, i_type ); switch( i_type ) { case VLC_VAR_BOOL: val.b_bool = !b_isno; break; case VLC_VAR_INTEGER: val.i_int = strtoll( psz_value, NULL, 0 ); break; case VLC_VAR_FLOAT: val.f_float = us_atof( psz_value ); break; case VLC_VAR_STRING: val.psz_string = psz_value; break; default: goto cleanup; } var_Set( p_obj, psz_name, val ); cleanup: free( psz_name ); }
/* * __config_process_value -- * Deal with special config values like true / false. */ static int __config_process_value(WT_CONFIG *conf, WT_CONFIG_ITEM *value) { char *endptr; /* Empty values are okay: we can't do anything interesting with them. */ if (value->len == 0) return (0); if (value->type == WT_CONFIG_ITEM_ID) { if (strncasecmp(value->str, "true", value->len) == 0) { value->type = WT_CONFIG_ITEM_BOOL; value->val = 1; } else if (strncasecmp(value->str, "false", value->len) == 0) { value->type = WT_CONFIG_ITEM_BOOL; value->val = 0; } } else if (value->type == WT_CONFIG_ITEM_NUM) { errno = 0; value->val = strtoll(value->str, &endptr, 10); /* Check any leftover characters. */ while (endptr < value->str + value->len) switch (*endptr++) { case 'b': case 'B': /* Byte: no change. */ break; case 'k': case 'K': WT_SHIFT_INT64(value->val, 10); break; case 'm': case 'M': WT_SHIFT_INT64(value->val, 20); break; case 'g': case 'G': WT_SHIFT_INT64(value->val, 30); break; case 't': case 'T': WT_SHIFT_INT64(value->val, 40); break; case 'p': case 'P': WT_SHIFT_INT64(value->val, 50); break; default: /* * We didn't get a well-formed number. That * might be okay, the required type will be * checked by __wt_config_check. */ value->type = WT_CONFIG_ITEM_ID; break; } /* * If we parsed the whole string but the number is out of range, * report an error. Don't report an error for strings that * aren't well-formed integers: if an integer is expected, that * will be caught by __wt_config_check. */ if (value->type == WT_CONFIG_ITEM_NUM && errno == ERANGE) goto range; } return (0); range: return (__config_err(conf, "Number out of range", ERANGE)); }
static int storage_trunk_load() { #define TRUNK_DATA_FIELD_COUNT 6 #define TRUNK_LINE_MAX_LENGHT 64 int64_t restore_offset; char trunk_data_filename[MAX_PATH_SIZE]; char buff[4 * 1024 + 1]; int line_count; char *pLineStart; char *pLineEnd; char *cols[TRUNK_DATA_FIELD_COUNT]; FDFSTrunkFullInfo trunkInfo; int result; int fd; int bytes; int len; snprintf(trunk_data_filename, sizeof(trunk_data_filename), \ "%s/data/%s", g_fdfs_base_path, STORAGE_TRUNK_DATA_FILENAME); if (g_trunk_init_reload_from_binlog) { if (unlink(trunk_data_filename) != 0) { result = errno != 0 ? errno : ENOENT; if (result != ENOENT) { logError("file: "__FILE__", line: %d, " \ "unlink file %s fail, " \ "errno: %d, error info: %s", __LINE__, \ trunk_data_filename, result, \ STRERROR(result)); return result; } } restore_offset = 0; return storage_trunk_restore(restore_offset); } fd = open(trunk_data_filename, O_RDONLY); if (fd < 0) { result = errno != 0 ? errno : EIO; if (result == ENOENT) { restore_offset = 0; return storage_trunk_restore(restore_offset); } logError("file: "__FILE__", line: %d, " \ "open file %s fail, " \ "errno: %d, error info: %s", \ __LINE__, trunk_data_filename, \ result, STRERROR(result)); return result; } if ((bytes=read(fd, buff, sizeof(buff) - 1)) < 0) { result = errno != 0 ? errno : EIO; logError("file: "__FILE__", line: %d, " \ "read from file %s fail, " \ "errno: %d, error info: %s", \ __LINE__, trunk_data_filename, \ result, STRERROR(result)); close(fd); return result; } *(buff + bytes) = '\0'; pLineEnd = strchr(buff, '\n'); if (pLineEnd == NULL) { logError("file: "__FILE__", line: %d, " \ "read offset from file %s fail", \ __LINE__, trunk_data_filename); close(fd); return EINVAL; } *pLineEnd = '\0'; restore_offset = strtoll(buff, NULL, 10); pLineStart = pLineEnd + 1; //skip \n line_count = 0; while (1) { pLineEnd = strchr(pLineStart, '\n'); if (pLineEnd == NULL) { if (bytes < sizeof(buff) - 1) //EOF { break; } len = strlen(pLineStart); if (len > TRUNK_LINE_MAX_LENGHT) { logError("file: "__FILE__", line: %d, " \ "file %s, line length: %d too long", \ __LINE__, trunk_data_filename, len); close(fd); return EINVAL; } memcpy(buff, pLineStart, len); if ((bytes=read(fd, buff + len, sizeof(buff) \ - len - 1)) < 0) { result = errno != 0 ? errno : EIO; logError("file: "__FILE__", line: %d, " \ "read from file %s fail, " \ "errno: %d, error info: %s", \ __LINE__, trunk_data_filename, \ result, STRERROR(result)); close(fd); return result; } if (bytes == 0) { result = ENOENT; logError("file: "__FILE__", line: %d, " \ "file: %s, end of file, expect " \ "end line", __LINE__, \ trunk_data_filename); close(fd); return result; } bytes += len; *(buff + bytes) = '\0'; pLineStart = buff; continue; } ++line_count; *pLineEnd = '\0'; if (splitEx(pLineStart, ' ', cols, TRUNK_DATA_FIELD_COUNT) \ != TRUNK_DATA_FIELD_COUNT) { logError("file: "__FILE__", line: %d, " \ "file %s, line: %d is invalid", \ __LINE__, trunk_data_filename, line_count); close(fd); return EINVAL; } trunkInfo.path.store_path_index = atoi(cols[0]); trunkInfo.path.sub_path_high = atoi(cols[1]); trunkInfo.path.sub_path_low = atoi(cols[2]); trunkInfo.file.id = atoi(cols[3]); trunkInfo.file.offset = atoi(cols[4]); trunkInfo.file.size = atoi(cols[5]); if ((result=storage_trunk_do_add_space(&trunkInfo)) != 0) { close(fd); return result; } pLineStart = pLineEnd + 1; //next line } close(fd); if (*pLineStart != '\0') { logError("file: "__FILE__", line: %d, " \ "file %s does not end correctly", \ __LINE__, trunk_data_filename); return EINVAL; } logDebug("file: "__FILE__", line: %d, " \ "file %s, line count: %d", \ __LINE__, trunk_data_filename, line_count); return storage_trunk_restore(restore_offset); }