static void add_shm_source(int shm_segment, int poll, int dpoll, double delay,
char *prefix, struct timemaster_config *config,
char **ntp_config)
{
char *refid = get_refid(prefix, shm_segment);
switch (config->ntp_program) {
case CHRONYD:
string_appendf(ntp_config,
"refclock SHM %d poll %d dpoll %d "
"refid %s precision 1.0e-9 delay %.1e\n",
shm_segment, poll, dpoll, refid, delay);
break;
case NTPD:
string_appendf(ntp_config,
"server 127.127.28.%d minpoll %d maxpoll %d "
"mode 1\n"
"fudge 127.127.28.%d refid %s\n",
shm_segment, poll, poll, shm_segment, refid);
break;
}
free(refid);
}
void nerr_error_string (NEOERR *err, NEOSTRING *str)
{
NEOERR *more;
char buf[1024];
char *err_name;
if (err == STATUS_OK)
return;
if (err == INTERNAL_ERR)
{
string_append (str, "Internal error");
return;
}
more = err;
while (more && more != INTERNAL_ERR)
{
err = more;
more = err->next;
if (err->error != NERR_PASS)
{
NEOERR *r;
if (err->error == 0)
{
err_name = buf;
snprintf (buf, sizeof (buf), "Unknown Error");
}
else
{
r = uListGet (Errors, err->error - 1, (void **)&err_name);
if (r != STATUS_OK)
{
err_name = buf;
snprintf (buf, sizeof (buf), "Error %d", err->error);
}
}
string_appendf(str, "%s: %s", err_name, err->desc);
return;
}
}
}
int string_appendc (String *sobj, char c)
{
return string_appendf (sobj, "%c", c);
}
int string_append (String *sobj, const char *str)
{
return string_appendf (sobj, "%s", str);
}
static NEOERR *split_and_convert (const char *src, int slen,
STRING *out, HTML_CONVERT_OPTS *opts)
{
NEOERR *err = STATUS_OK;
regmatch_t email_match, url_match;
int errcode;
char *ptr, *esc;
char errbuf[256];
struct _parts *parts;
int part_count;
int part;
int x, i;
int spaces = 0;
if (!CompiledRe)
{
#ifdef HAVE_PTHREADS
/* In threaded environments, we have to mutex lock to do this regcomp, but
* we don't want to use a mutex every time to check that it was regcomp.
* So, we only lock if our first test of compiled was false */
err = mLock(&InitLock);
if (err != STATUS_OK) return nerr_pass(err);
if (CompiledRe == 0) {
#endif
if ((errcode = regcomp (&EmailRegex, EmailRe, REG_ICASE | REG_EXTENDED)))
{
regerror (errcode, &EmailRegex, errbuf, sizeof(errbuf));
err = nerr_raise (NERR_PARSE, "Unable to compile EmailRE: %s", errbuf);
}
if ((errcode = regcomp (&UrlRegex, URLRe, REG_ICASE | REG_EXTENDED)))
{
regerror (errcode, &UrlRegex, errbuf, sizeof(errbuf));
err = nerr_raise (NERR_PARSE, "Unable to compile URLRe: %s", errbuf);
}
CompiledRe = 1;
#ifdef HAVE_PTHREADS
}
if (err) {
mUnlock(&InitLock);
return err;
}
err = mUnlock(&InitLock);
if (err != STATUS_OK) return nerr_pass(err);
#else
if (err) {
return err;
}
#endif
}
part_count = 20;
parts = (struct _parts *) malloc (sizeof(struct _parts) * part_count);
part = 0;
x = 0;
if (regexec (&EmailRegex, src+x, 1, &email_match, 0) != 0)
{
email_match.rm_so = -1;
email_match.rm_eo = -1;
}
else
{
email_match.rm_so += x;
email_match.rm_eo += x;
}
if (regexec (&UrlRegex, src+x, 1, &url_match, 0) != 0)
{
url_match.rm_so = -1;
url_match.rm_eo = -1;
}
else
{
url_match.rm_so += x;
url_match.rm_eo += x;
}
while ((x < slen) && !((email_match.rm_so == -1) && (url_match.rm_so == -1)))
{
if (part >= part_count)
{
void *new_ptr;
part_count *= 2;
new_ptr = realloc (parts, sizeof(struct _parts) * part_count);
if (new_ptr == NULL) {
free(parts);
return nerr_raise (NERR_NOMEM,
"Unable to increase url matcher to %d urls",
part_count);
}
parts = (struct _parts *) new_ptr;
}
if ((url_match.rm_so != -1) && ((email_match.rm_so == -1) || (url_match.rm_so <= email_match.rm_so)))
{
parts[part].begin = url_match.rm_so;
parts[part].end = url_match.rm_eo;
parts[part].type = SC_TYPE_URL;
x = parts[part].end + 1;
part++;
if (x < slen)
{
if (regexec (&UrlRegex, src+x, 1, &url_match, 0) != 0)
{
url_match.rm_so = -1;
url_match.rm_eo = -1;
}
else
{
url_match.rm_so += x;
url_match.rm_eo += x;
}
if ((email_match.rm_so != -1) && (x > email_match.rm_so))
{
if (regexec (&EmailRegex, src+x, 1, &email_match, 0) != 0)
{
email_match.rm_so = -1;
email_match.rm_eo = -1;
}
else
{
email_match.rm_so += x;
email_match.rm_eo += x;
}
}
}
}
else
{
parts[part].begin = email_match.rm_so;
parts[part].end = email_match.rm_eo;
parts[part].type = SC_TYPE_EMAIL;
x = parts[part].end + 1;
part++;
if (x < slen)
{
if (regexec (&EmailRegex, src+x, 1, &email_match, 0) != 0)
{
email_match.rm_so = -1;
email_match.rm_eo = -1;
}
else
{
email_match.rm_so += x;
email_match.rm_eo += x;
}
if ((url_match.rm_so != -1) && (x > url_match.rm_so))
{
if (regexec (&UrlRegex, src+x, 1, &url_match, 0) != 0)
{
url_match.rm_so = -1;
url_match.rm_eo = -1;
}
else
{
url_match.rm_so += x;
url_match.rm_eo += x;
}
}
}
}
}
i = 0;
x = 0;
while (x < slen)
{
if ((i >= part) || (x < parts[i].begin))
{
ptr = strpbrk(src + x, "&<>\r\n ");
if (ptr == NULL)
{
if (spaces)
{
int sp;
for (sp = 0; sp < spaces - 1; sp++)
{
err = string_append (out, " ");
if (err != STATUS_OK) break;
}
if (err != STATUS_OK) break;
err = string_append_char (out, ' ');
}
spaces = 0;
if (i < part)
{
err = string_appendn (out, src + x, parts[i].begin - x);
x = parts[i].begin;
}
else
{
err = string_append (out, src + x);
x = slen;
}
}
else
{
if ((i >= part) || ((ptr - src) < parts[i].begin))
{
if (spaces)
{
int sp;
for (sp = 0; sp < spaces - 1; sp++)
{
err = string_append (out, " ");
if (err != STATUS_OK) break;
}
if (err != STATUS_OK) break;
err = string_append_char (out, ' ');
}
spaces = 0;
err = string_appendn (out, src + x, (ptr - src) - x);
if (err != STATUS_OK) break;
x = ptr - src;
if (src[x] == ' ')
{
if (opts->space_convert)
{
spaces++;
}
else
err = string_append_char (out, ' ');
}
else
{
if (src[x] != '\n' && spaces)
{
int sp;
for (sp = 0; sp < spaces - 1; sp++)
{
err = string_append (out, " ");
if (err != STATUS_OK) break;
}
if (err != STATUS_OK) break;
err = string_append_char (out, ' ');
}
spaces = 0;
if (src[x] == '&')
err = string_append (out, "&");
else if (src[x] == '<')
err = string_append (out, "<");
else if (src[x] == '>')
err = string_append (out, ">");
else if (src[x] == '\n')
if (opts->newlines_convert)
err = string_append (out, "<br/>\n");
else if (x && src[x-1] == '\n')
err = string_append (out, "<p/>\n");
else
err = string_append_char (out, '\n');
else if (src[x] != '\r')
err = nerr_raise (NERR_ASSERT, "src[x] == '%c'", src[x]);
}
x++;
}
else
{
if (spaces)
{
int sp;
for (sp = 0; sp < spaces - 1; sp++)
{
err = string_append (out, " ");
if (err != STATUS_OK) break;
}
if (err != STATUS_OK) break;
err = string_append_char (out, ' ');
}
spaces = 0;
err = string_appendn (out, src + x, parts[i].begin - x);
x = parts[i].begin;
}
}
}
else
{
if (spaces)
{
int sp;
for (sp = 0; sp < spaces - 1; sp++)
{
err = string_append (out, " ");
if (err != STATUS_OK) break;
}
if (err != STATUS_OK) break;
err = string_append_char (out, ' ');
}
spaces = 0;
if (parts[i].type == SC_TYPE_URL)
{
char last_char = src[parts[i].end-1];
int suffix=0;
if (last_char == '.' || last_char == ',') { suffix=1; }
err = string_append (out, " <a ");
if (err != STATUS_OK) break;
if (opts->url_class)
{
err = string_appendf (out, "class=%s ", opts->url_class);
if (err) break;
}
if (opts->url_target)
{
err = string_appendf (out, "target=\"%s\" ", opts->url_target);
if (err) break;
}
err = string_append(out, "href=\"");
if (err) break;
if (opts->bounce_url)
{
char *url, *esc_url, *new_url;
int url_len;
if (!strncasecmp(src + x, "www.", 4))
{
url_len = 7 + parts[i].end - x - suffix;
url = (char *) malloc(url_len+1);
if (url == NULL)
{
err = nerr_raise(NERR_NOMEM,
"Unable to allocate memory to convert url");
break;
}
strcpy(url, "http://");
strncat(url, src + x, parts[i].end - x - suffix);
}
else
{
url_len = parts[i].end - x - suffix;
url = (char *) malloc(url_len+1);
if (url == NULL)
{
err = nerr_raise(NERR_NOMEM,
"Unable to allocate memory to convert url");
break;
}
strncpy(url, src + x, parts[i].end - x - suffix);
url[url_len] = '\0';
}
err = cgi_url_escape(url, &esc_url);
free(url);
if (err) {
free(esc_url);
break;
}
new_url = sprintf_alloc(opts->bounce_url, esc_url);
free(esc_url);
if (new_url == NULL)
{
err = nerr_raise(NERR_NOMEM, "Unable to allocate memory to convert url");
break;
}
err = string_append (out, new_url);
free(new_url);
if (err) break;
}
else
{
if (!strncasecmp(src + x, "www.", 4))
{
err = string_append (out, "http://");
if (err != STATUS_OK) break;
}
err = string_appendn (out, src + x, parts[i].end - x - suffix);
if (err != STATUS_OK) break;
}
err = string_append (out, "\">");
if (err != STATUS_OK) break;
if (opts->link_name) {
err = html_escape_alloc((opts->link_name),
strlen(opts->link_name), &esc);
} else {
err = html_escape_alloc((src + x), parts[i].end - x - suffix, &esc);
}
if (err != STATUS_OK) break;
err = string_append (out, esc);
free(esc);
if (err != STATUS_OK) break;
err = string_append (out, "</a>");
if (suffix) {
err = string_appendn(out,src + parts[i].end - 1,1);
if (err != STATUS_OK) break;
}
}
else /* type == SC_TYPE_EMAIL */
{
err = string_append (out, "<a ");
if (err != STATUS_OK) break;
if (opts->mailto_class)
{
err = string_appendf (out, "class=%s ", opts->mailto_class);
if (err) break;
}
err = string_append(out, "href=\"mailto:");
if (err) break;
err = string_appendn (out, src + x, parts[i].end - x);
if (err != STATUS_OK) break;
err = string_append (out, "\">");
if (err != STATUS_OK) break;
err = html_escape_alloc(src + x, parts[i].end - x, &esc);
if (err != STATUS_OK) break;
err = string_append (out, esc);
free(esc);
if (err != STATUS_OK) break;
err = string_append (out, "</a>");
}
x = parts[i].end;
i++;
}
if (err != STATUS_OK) break;
}
free (parts);
return err;
}
static int add_ptp_source(struct ptp_domain *source,
struct timemaster_config *config, int *shm_segment,
int ***allocated_phcs, char **ntp_config,
struct script *script)
{
struct config_file *config_file;
char **command, *uds_path, **interfaces;
int i, j, num_interfaces, *phc, *phcs, hw_ts;
struct sk_ts_info ts_info;
pr_debug("adding PTP domain %d", source->domain);
hw_ts = SOF_TIMESTAMPING_TX_HARDWARE | SOF_TIMESTAMPING_RX_HARDWARE |
SOF_TIMESTAMPING_RAW_HARDWARE;
for (num_interfaces = 0;
source->interfaces[num_interfaces]; num_interfaces++)
;
if (!num_interfaces)
return 0;
/* get PHCs used by specified interfaces */
phcs = xmalloc(num_interfaces * sizeof(int));
for (i = 0; i < num_interfaces; i++) {
phcs[i] = -1;
/* check if the interface has a usable PHC */
if (sk_get_ts_info(source->interfaces[i], &ts_info)) {
pr_err("failed to get time stamping info for %s",
source->interfaces[i]);
free(phcs);
return 1;
}
if (!ts_info.valid ||
((ts_info.so_timestamping & hw_ts) != hw_ts)) {
pr_debug("interface %s: no PHC", source->interfaces[i]);
continue;
}
pr_debug("interface %s: PHC %d", source->interfaces[i],
ts_info.phc_index);
/* and the PHC isn't already used in another source */
for (j = 0; (*allocated_phcs)[j]; j++) {
if (*(*allocated_phcs)[j] == ts_info.phc_index) {
pr_debug("PHC %d already allocated",
ts_info.phc_index);
break;
}
}
if (!(*allocated_phcs)[j])
phcs[i] = ts_info.phc_index;
}
for (i = 0; i < num_interfaces; i++) {
/* skip if already used by ptp4l in this domain */
if (phcs[i] == -2)
continue;
interfaces = (char **)parray_new();
parray_append((void ***)&interfaces, source->interfaces[i]);
/* merge all interfaces sharing PHC to one ptp4l command */
if (phcs[i] >= 0) {
for (j = i + 1; j < num_interfaces; j++) {
if (phcs[i] == phcs[j]) {
parray_append((void ***)&interfaces,
source->interfaces[j]);
/* mark the interface as used */
phcs[j] = -2;
}
}
/* don't use this PHC in other sources */
phc = xmalloc(sizeof(int));
*phc = phcs[i];
parray_append((void ***)allocated_phcs, phc);
}
uds_path = string_newf("%s/ptp4l.%d.socket",
config->rundir, *shm_segment);
config_file = xmalloc(sizeof(*config_file));
config_file->path = string_newf("%s/ptp4l.%d.conf",
config->rundir, *shm_segment);
config_file->content = xstrdup("[global]\n");
extend_config_string(&config_file->content,
config->ptp4l.settings);
extend_config_string(&config_file->content,
source->ptp4l_settings);
string_appendf(&config_file->content,
"slaveOnly 1\n"
"domainNumber %d\n"
"uds_address %s\n",
source->domain, uds_path);
if (phcs[i] >= 0) {
/* HW time stamping */
command = get_ptp4l_command(&config->ptp4l, config_file,
interfaces, 1);
parray_append((void ***)&script->commands, command);
command = get_phc2sys_command(&config->phc2sys,
source->domain,
source->phc2sys_poll,
*shm_segment, uds_path);
parray_append((void ***)&script->commands, command);
} else {
/* SW time stamping */
command = get_ptp4l_command(&config->ptp4l, config_file,
interfaces, 0);
parray_append((void ***)&script->commands, command);
string_appendf(&config_file->content,
"clock_servo ntpshm\n"
"ntpshm_segment %d\n", *shm_segment);
}
parray_append((void ***)&script->configs, config_file);
add_shm_source(*shm_segment, source->ntp_poll,
source->phc2sys_poll, source->delay,
source->ntp_options, "PTP", config, ntp_config);
(*shm_segment)++;
free(uds_path);
free(interfaces);
}
free(phcs);
return 0;
}
static void extend_config_string(char **s, char **lines)
{
for (; *lines; lines++)
string_appendf(s, "%s\n", *lines);
}
void print_xml_feature::visit_post (const target_desc *e)
{
string_appendf (*m_buffer, "</target>\n");
}
void print_xml_feature::visit (const tdesc_type_with_fields *t)
{
const static char *types[] = { "struct", "union", "flags", "enum" };
gdb_assert (t->kind >= TDESC_TYPE_STRUCT && t->kind <= TDESC_TYPE_ENUM);
string_appendf (*m_buffer,
"<%s id=\"%s\"", types[t->kind - TDESC_TYPE_STRUCT],
t->name.c_str ());
switch (t->kind)
{
case TDESC_TYPE_STRUCT:
case TDESC_TYPE_FLAGS:
if (t->size > 0)
string_appendf (*m_buffer, " size=\"%d\"", t->size);
string_appendf (*m_buffer, ">\n");
for (const tdesc_type_field &f : t->fields)
{
string_appendf (*m_buffer, " <field name=\"%s\" ", f.name.c_str ());
if (f.start == -1)
string_appendf (*m_buffer, "type=\"%s\"/>\n",
f.type->name.c_str ());
else
string_appendf (*m_buffer, "start=\"%d\" end=\"%d\"/>\n", f.start,
f.end);
}
break;
case TDESC_TYPE_ENUM:
string_appendf (*m_buffer, ">\n");
for (const tdesc_type_field &f : t->fields)
string_appendf (*m_buffer, " <field name=\"%s\" start=\"%d\"/>\n",
f.name.c_str (), f.start);
break;
case TDESC_TYPE_UNION:
string_appendf (*m_buffer, ">\n");
for (const tdesc_type_field &f : t->fields)
string_appendf (*m_buffer, " <field name=\"%s\" type=\"%s\"/>\n",
f.name.c_str (), f.type->name.c_str ());
break;
default:
error (_("xml output is not supported for type \"%s\"."),
t->name.c_str ());
}
string_appendf (*m_buffer, "</%s>\n", types[t->kind - TDESC_TYPE_STRUCT]);
}
void print_xml_feature::visit (const tdesc_type_vector *t)
{
string_appendf (*m_buffer, "<vector id=\"%s\" type=\"%s\" count=\"%d\"/>\n",
t->name.c_str (), t->element_type->name.c_str (), t->count);
}
void print_xml_feature::visit_post (const tdesc_feature *e)
{
string_appendf (*m_buffer, "</feature>\n");
}
void print_xml_feature::visit_pre (const tdesc_feature *e)
{
string_appendf (*m_buffer, "<feature name=\"%s\">\n", e->name.c_str ());
}
static void ips2places(HDF *hdf, HASH *evth)
{
if (!hdf || !evth) return;
mevent_t *evt = (mevent_t*)hash_lookup(evth, "place");
mevent_t *evta = (mevent_t*)hash_lookup(evth, "aic");
if (!evt || !evta) {
mtc_err("can't find event");
return;
}
char *p, *q;
HDF *node, *rnode;
STRING ip;
string_init(&ip);
node = hdf_obj_child(hdf);
while (node) {
p = hdf_get_value(node, "ip", NULL);
q = hdf_get_value(node, "addr", NULL);
if (p && (!q || !*q)) string_appendf(&ip, "%s,", p);
node = hdf_obj_next(node);
}
if (ip.len <= 0) return;
hdf_set_value(evt->hdfsnd, "ip", ip.buf);
MEVENT_TRIGGER_VOID(evt, ip.buf, REQ_CMD_PLACEGET, FLAGS_SYNC);
if (evt->hdfrcv) {
node = hdf_obj_child(hdf);
while (node) {
rnode = hdf_obj_child(evt->hdfrcv);
p = hdf_get_value(node, "ip", NULL);
q = hdf_get_value(node, "addr", NULL);
if (p && (!q || !*q)) {
while (rnode) {
q = hdf_get_value(rnode, "ip", NULL);
if (q && !strcmp(p, q)) break;
else q = NULL;
rnode = hdf_obj_next(rnode);
}
if (q) {
hdf_set_value(node, "addr", hdf_get_value(rnode, "c", NULL));
hdf_set_value(node, "area", hdf_get_value(rnode, "a", NULL));
hdf_set_value(evta->hdfsnd, "uid", hdf_get_value(node, "uid", 0));
hdf_set_value(evta->hdfsnd, "aid", hdf_get_value(node, "aid", 0));
hdf_set_value(evta->hdfsnd, "addr", hdf_get_value(rnode, "c", "Mars"));
MEVENT_TRIGGER_NRET(evta, NULL, REQ_CMD_APPUSERUP, FLAGS_NONE);
} else {
mtc_warn("can't find addr for %s", p);
}
}
node = hdf_obj_next(node);
}
}
string_clear(&ip);
}