int main(int argc, char *argv[]) { const char *progname; char **cmdv, *default_cmdv[] = { "caps" }; int c, result, cmdc; int print_level = LOG_INFO, verbose = 1, use_syslog = 1; clockid_t clkid; install_handler(SIGALRM, handle_alarm); /* Process the command line arguments. */ progname = strrchr(argv[0], '/'); progname = progname ? 1+progname : argv[0]; while (EOF != (c = getopt(argc, argv, "l:qQvh"))) { switch (c) { case 'l': if (get_arg_val_i(c, optarg, &print_level, PRINT_LEVEL_MIN, PRINT_LEVEL_MAX)) return -1; break; case 'q': use_syslog = 0; break; case 'Q': verbose = 0; break; case 'v': version_show(stdout); return 0; case 'h': usage(progname); return 0; default: usage(progname); return -1; } } print_set_progname(progname); print_set_verbose(verbose); print_set_syslog(use_syslog); print_set_level(print_level); if ((argc - optind) < 1) { usage(progname); return -1; } if ((argc - optind) == 1) { cmdv = default_cmdv; cmdc = 1; } else { cmdv = &argv[optind+1]; cmdc = argc - optind - 1; } clkid = clock_open(argv[optind]); if (clkid == CLOCK_INVALID) return -1; /* pass the remaining arguments to the run_cmds loop */ result = run_cmds(clkid, cmdc, cmdv); if (result < -1) { /* show usage when command fails */ usage(progname); return result; } return 0; }
int main(int argc, char *argv[]) { const char *iface_name = NULL; char *config = NULL, *progname; int c, cnt, index, length, tmo = -1, batch_mode = 0, zero_datalen = 0; int ret = 0; char line[1024], *command = NULL, uds_local[MAX_IFNAME_SIZE + 1]; enum transport_type transport_type = TRANS_UDP_IPV4; UInteger8 boundary_hops = 1, domain_number = 0, transport_specific = 0; struct ptp_message *msg; struct option *opts; struct config *cfg; #define N_FD 2 struct pollfd pollfd[N_FD]; handle_term_signals(); cfg = config_create(); if (!cfg) { return -1; } opts = config_long_options(cfg); /* Process the command line arguments. */ progname = strrchr(argv[0], '/'); progname = progname ? 1+progname : argv[0]; while (EOF != (c = getopt_long(argc, argv, "246u""b:d:f:hi:s:t:vz", opts, &index))) { switch (c) { case 0: if (config_parse_option(cfg, opts[index].name, optarg)) { ret = -1; goto out; } break; case '2': if (config_set_int(cfg, "network_transport", TRANS_IEEE_802_3)) { ret = -1; goto out; } break; case '4': if (config_set_int(cfg, "network_transport", TRANS_UDP_IPV4)) { ret = -1; goto out; } break; case '6': if (config_set_int(cfg, "network_transport", TRANS_UDP_IPV6)) { ret = -1; goto out; } break; case 'u': if (config_set_int(cfg, "network_transport", TRANS_UDS)) { ret = -1; goto out; } break; case 'b': boundary_hops = atoi(optarg); break; case 'd': if (config_set_int(cfg, "domainNumber", atoi(optarg))) { ret = -1; goto out; } break; case 'f': config = optarg; break; case 'i': iface_name = optarg; break; case 's': if (strlen(optarg) > MAX_IFNAME_SIZE) { fprintf(stderr, "path %s too long, max is %d\n", optarg, MAX_IFNAME_SIZE); config_destroy(cfg); return -1; } if (config_set_string(cfg, "uds_address", optarg)) { config_destroy(cfg); return -1; } break; case 't': if (1 == sscanf(optarg, "%x", &c)) { if (config_set_int(cfg, "transportSpecific", c)) { ret = -1; goto out; } } break; case 'v': version_show(stdout); config_destroy(cfg); return 0; case 'z': zero_datalen = 1; break; case 'h': usage(progname); config_destroy(cfg); return 0; case '?': default: usage(progname); config_destroy(cfg); return -1; } } if (config && (c = config_read(config, cfg))) { config_destroy(cfg); return -1; } transport_type = config_get_int(cfg, NULL, "network_transport"); transport_specific = config_get_int(cfg, NULL, "transportSpecific") << 4; domain_number = config_get_int(cfg, NULL, "domainNumber"); if (!iface_name) { if (transport_type == TRANS_UDS) { snprintf(uds_local, sizeof(uds_local), "/var/run/pmc.%d", getpid()); iface_name = uds_local; } else { iface_name = "eth0"; } } if (optind < argc) { batch_mode = 1; } print_set_progname(progname); print_set_syslog(1); print_set_verbose(1); pmc = pmc_create(cfg, transport_type, iface_name, boundary_hops, domain_number, transport_specific, zero_datalen); if (!pmc) { fprintf(stderr, "failed to create pmc\n"); config_destroy(cfg); return -1; } pollfd[0].fd = batch_mode ? -1 : STDIN_FILENO; pollfd[1].fd = pmc_get_transport_fd(pmc); while (is_running()) { if (batch_mode && !command) { if (optind < argc) { command = argv[optind++]; } else { /* No more commands, wait a bit for any outstanding replies and exit. */ tmo = 100; } } pollfd[0].events = 0; pollfd[1].events = POLLIN | POLLPRI; if (!batch_mode && !command) pollfd[0].events |= POLLIN | POLLPRI; if (command) pollfd[1].events |= POLLOUT; cnt = poll(pollfd, N_FD, tmo); if (cnt < 0) { if (EINTR == errno) { continue; } else { pr_emerg("poll failed"); ret = -1; break; } } else if (!cnt) { break; } if (pollfd[0].revents & POLLHUP) { if (tmo == -1) { /* Wait a bit longer for outstanding replies. */ tmo = 100; pollfd[0].fd = -1; pollfd[0].events = 0; } else { break; } } if (pollfd[0].revents & (POLLIN|POLLPRI)) { if (!fgets(line, sizeof(line), stdin)) { break; } length = strlen(line); if (length < 2) { continue; } line[length - 1] = 0; command = line; } if (pollfd[1].revents & POLLOUT) { if (pmc_do_command(pmc, command)) { fprintf(stderr, "bad command: %s\n", command); } command = NULL; } if (pollfd[1].revents & (POLLIN|POLLPRI)) { msg = pmc_recv(pmc); if (msg) { pmc_show(msg, stdout); msg_put(msg); } } } pmc_destroy(pmc); msg_cleanup(); out: config_destroy(cfg); return ret; }
int main(int argc, char **argv) { struct timemaster_config *config; struct script *script; char *progname, *config_path = NULL; int c, ret = 0, log_stdout = 0, log_syslog = 1, dry_run = 0; progname = strrchr(argv[0], '/'); progname = progname ? progname + 1 : argv[0]; print_set_progname(progname); print_set_verbose(1); print_set_syslog(0); while (EOF != (c = getopt(argc, argv, "f:nl:mqvh"))) { switch (c) { case 'f': config_path = optarg; break; case 'n': dry_run = 1; break; case 'l': print_set_level(atoi(optarg)); break; case 'm': log_stdout = 1; break; case 'q': log_syslog = 0; break; case 'v': version_show(stdout); return 0; case 'h': usage(progname); return 0; default: usage(progname); return 1; } } if (!config_path) { pr_err("no configuration file specified"); return 1; } config = config_parse(config_path); if (!config) return 1; script = script_create(config); config_destroy(config); if (!script) return 1; print_set_verbose(log_stdout); print_set_syslog(log_syslog); if (dry_run) script_print(script); else ret = script_run(script); script_destroy(script); if (!dry_run) pr_info("exiting"); return ret; }
int main(int argc, char *argv[]) { char *config = NULL, *req_phc = NULL, *progname; int c, i; struct interface *iface = cfg_settings.iface; char *ports[MAX_PORTS]; int nports = 0; int *cfg_ignore = &cfg_settings.cfg_ignore; enum delay_mechanism *dm = &cfg_settings.dm; enum transport_type *transport = &cfg_settings.transport; enum timestamp_type *timestamping = &cfg_settings.timestamping; struct clock *clock; struct defaultDS *ds = &cfg_settings.dds.dds; int phc_index = -1, required_modes = 0; if (SIG_ERR == signal(SIGINT, handle_int_quit_term)) { fprintf(stderr, "cannot handle SIGINT\n"); return -1; } if (SIG_ERR == signal(SIGQUIT, handle_int_quit_term)) { fprintf(stderr, "cannot handle SIGQUIT\n"); return -1; } if (SIG_ERR == signal(SIGTERM, handle_int_quit_term)) { fprintf(stderr, "cannot handle SIGTERM\n"); return -1; } /* Set fault timeouts to a default value */ for (i = 0; i < FT_CNT; i++) { cfg_settings.pod.flt_interval_pertype[i].type = FTMO_LOG2_SECONDS; cfg_settings.pod.flt_interval_pertype[i].val = 4; } /* Process the command line arguments. */ progname = strrchr(argv[0], '/'); progname = progname ? 1+progname : argv[0]; while (EOF != (c = getopt(argc, argv, "AEP246HSLf:i:p:sl:mqvh"))) { switch (c) { case 'A': *dm = DM_AUTO; *cfg_ignore |= CFG_IGNORE_DM; break; case 'E': *dm = DM_E2E; *cfg_ignore |= CFG_IGNORE_DM; break; case 'P': *dm = DM_P2P; *cfg_ignore |= CFG_IGNORE_DM; break; case '2': *transport = TRANS_IEEE_802_3; *cfg_ignore |= CFG_IGNORE_TRANSPORT; break; case '4': *transport = TRANS_UDP_IPV4; *cfg_ignore |= CFG_IGNORE_TRANSPORT; break; case '6': *transport = TRANS_UDP_IPV6; *cfg_ignore |= CFG_IGNORE_TRANSPORT; break; case 'H': *timestamping = TS_HARDWARE; *cfg_ignore |= CFG_IGNORE_TIMESTAMPING; break; case 'S': *timestamping = TS_SOFTWARE; *cfg_ignore |= CFG_IGNORE_TIMESTAMPING; break; case 'L': *timestamping = TS_LEGACY_HW; *cfg_ignore |= CFG_IGNORE_TIMESTAMPING; break; case 'f': config = optarg; break; case 'i': ports[nports] = optarg; nports++; break; case 'p': req_phc = optarg; break; case 's': ds->flags |= DDS_SLAVE_ONLY; *cfg_ignore |= CFG_IGNORE_SLAVEONLY; break; case 'l': if (get_arg_val_i(c, optarg, &cfg_settings.print_level, PRINT_LEVEL_MIN, PRINT_LEVEL_MAX)) return -1; *cfg_ignore |= CFG_IGNORE_PRINT_LEVEL; break; case 'm': cfg_settings.verbose = 1; *cfg_ignore |= CFG_IGNORE_VERBOSE; break; case 'q': cfg_settings.use_syslog = 0; *cfg_ignore |= CFG_IGNORE_USE_SYSLOG; break; case 'v': version_show(stdout); return 0; case 'h': usage(progname); return 0; case '?': usage(progname); return -1; default: usage(progname); return -1; } } if (config && (c = config_read(config, &cfg_settings))) { return c; } if (ds->flags & DDS_SLAVE_ONLY) { ds->clockQuality.clockClass = 255; } print_set_progname(progname); print_set_verbose(cfg_settings.verbose); print_set_syslog(cfg_settings.use_syslog); print_set_level(cfg_settings.print_level); for (i = 0; i < nports; i++) { if (config_create_interface(ports[i], &cfg_settings) < 0) { fprintf(stderr, "too many interfaces\n"); return -1; } } if (!cfg_settings.nports) { fprintf(stderr, "no interface specified\n"); usage(progname); return -1; } if (!(ds->flags & DDS_TWO_STEP_FLAG)) { switch (*timestamping) { case TS_SOFTWARE: case TS_LEGACY_HW: fprintf(stderr, "one step is only possible " "with hardware time stamping\n"); return -1; case TS_HARDWARE: *timestamping = TS_ONESTEP; break; case TS_ONESTEP: break; } } switch (*timestamping) { case TS_SOFTWARE: required_modes |= SOF_TIMESTAMPING_TX_SOFTWARE | SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE; break; case TS_LEGACY_HW: required_modes |= SOF_TIMESTAMPING_TX_HARDWARE | SOF_TIMESTAMPING_RX_HARDWARE | SOF_TIMESTAMPING_SYS_HARDWARE; break; case TS_HARDWARE: case TS_ONESTEP: required_modes |= SOF_TIMESTAMPING_TX_HARDWARE | SOF_TIMESTAMPING_RX_HARDWARE | SOF_TIMESTAMPING_RAW_HARDWARE; break; } /* check whether timestamping mode is supported. */ for (i = 0; i < cfg_settings.nports; i++) { if (iface[i].ts_info.valid && ((iface[i].ts_info.so_timestamping & required_modes) != required_modes)) { fprintf(stderr, "interface '%s' does not support " "requested timestamping mode.\n", iface[i].name); return -1; } } /* determine PHC Clock index */ if (cfg_settings.dds.free_running) { phc_index = -1; } else if (*timestamping == TS_SOFTWARE || *timestamping == TS_LEGACY_HW) { phc_index = -1; } else if (req_phc) { if (1 != sscanf(req_phc, "/dev/ptp%d", &phc_index)) { fprintf(stderr, "bad ptp device string\n"); return -1; } } else if (iface[0].ts_info.valid) { phc_index = iface[0].ts_info.phc_index; } else { fprintf(stderr, "ptp device not specified and\n" "automatic determination is not\n" "supported. please specify ptp device\n"); return -1; } if (phc_index >= 0) { pr_info("selected /dev/ptp%d as PTP clock", phc_index); } if (generate_clock_identity(&ds->clockIdentity, iface[0].name)) { fprintf(stderr, "failed to generate a clock identity\n"); return -1; } clock = clock_create(phc_index, iface, cfg_settings.nports, *timestamping, &cfg_settings.dds, cfg_settings.clock_servo); if (!clock) { fprintf(stderr, "failed to create a clock\n"); return -1; } while (running) { if (clock_poll(clock)) break; } clock_destroy(clock); return 0; }