int config_read(char *name, struct config *cfg)
{
enum config_section current_section = UNKNOWN_SECTION;
enum parser_result parser_res;
FILE *fp;
char buf[1024], *line, *c, *option, *value;
int current_port, line_num;
fp = 0 == strncmp(name, "-", 2) ? stdin : fopen(name, "r");
if (!fp) {
fprintf(stderr, "failed to open configuration file %s: %m\n", name);
return -1;
}
for (line_num = 1; fgets(buf, sizeof(buf), fp); line_num++) {
c = buf;
/* skip whitespace characters */
while (isspace(*c))
c++;
/* ignore empty lines and comments */
if (*c == '#' || *c == '\n' || *c == '\0')
continue;
line = c;
/* remove trailing whitespace characters and \n */
c += strlen(line) - 1;
while (c > line && (*c == '\n' || isspace(*c)))
*c-- = '\0';
if (parse_section_line(line, ¤t_section) == PARSED_OK) {
if (current_section == PORT_SECTION) {
char port[17];
if (1 != sscanf(line, " %16s", port)) {
fprintf(stderr, "could not parse port name on line %d\n",
line_num);
goto parse_error;
}
current_port = config_create_interface(port, cfg);
if (current_port < 0)
goto parse_error;
}
continue;
}
switch (current_section) {
case GLOBAL_SECTION:
case PORT_SECTION:
if (parse_setting_line(line, &option, &value)) {
fprintf(stderr, "could not parse line %d in %s section\n",
line_num,
current_section == GLOBAL_SECTION ?
"global" : cfg->iface[current_port].name);
goto parse_error;
}
if (current_section == GLOBAL_SECTION)
parser_res = parse_global_setting(option, value, cfg);
else
parser_res = parse_port_setting(option, value, cfg, current_port);
switch (parser_res) {
case PARSED_OK:
break;
case NOT_PARSED:
fprintf(stderr, "unknown option %s at line %d in %s section\n",
option, line_num,
current_section == GLOBAL_SECTION ?
"global" : cfg->iface[current_port].name);
goto parse_error;
case BAD_VALUE:
fprintf(stderr, "%s is a bad value for option %s at line %d\n",
value, option, line_num);
goto parse_error;
}
break;
case UNKNOWN_SECTION:
fprintf(stderr, "line %d is not in a section\n", line_num);
goto parse_error;
default:
continue;
}
}
fclose(fp);
return 0;
parse_error:
fprintf(stderr, "failed to parse configuration file %s\n", name);
fclose(fp);
return -2;
}
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;
}
