void
abuf_log(struct abuf *buf)
{
log_putu(buf->start);
log_puts("+");
log_putu(buf->used);
log_puts("/");
log_putu(buf->len);
}
static int
afile_aiff_readcomm(struct afile *f, unsigned int csize,
int comp, unsigned int *nfr)
{
struct aiff_comm comm;
unsigned int csize_min;
unsigned int e, m;
csize_min = comp ?
sizeof(struct aiff_comm) : sizeof(struct aiff_commbase);
if (csize < csize_min) {
log_puts(f->path);
log_puts(": ");
log_putu(csize);
log_puts(": bogus comm chunk size\n");
return 0;
}
if (read(f->fd, &comm, csize_min) != csize_min) {
log_puts(f->path);
log_puts(": failed to read comm chunk\n");
return 0;
}
f->nch = be16_get(&comm.base.nch);
e = be16_get(&comm.base.rate_ex);
m = be32_get(&comm.base.rate_hi);
if (e < 0x3fff || e > 0x3fff + 31) {
log_puts(f->path);
log_puts(": malformed sample rate\n");
return 0;
}
f->rate = m >> (0x3fff + 31 - e);
if (comp) {
if (memcmp(comm.comp_id, aiff_id_none, 4) == 0) {
f->fmt = AFILE_FMT_PCM;
f->par.bits = be16_get(&comm.base.bits);
} else if (memcmp(comm.comp_id, aiff_id_fl32, 4) == 0) {
f->fmt = AFILE_FMT_FLOAT;
f->par.bits = 32;
} else if (memcmp(comm.comp_id, aiff_id_ulaw, 4) == 0) {
f->fmt = AFILE_FMT_ULAW;
f->par.bits = 8;
} else if (memcmp(comm.comp_id, aiff_id_alaw, 4) == 0) {
f->fmt = AFILE_FMT_ALAW;
f->par.bits = 8;
} else {
log_puts(f->path);
log_puts(": unsupported encoding\n");
return 0;
}
} else {
f->fmt = AFILE_FMT_PCM;
f->par.bits = be16_get(&comm.base.bits);
}
f->par.le = 0;
f->par.sig = 1;
f->par.msb = 1;
f->par.bps = (f->par.bits + 7) / 8;
*nfr = be32_get(&comm.base.nfr);
return afile_checkpar(f);
}
/*
* advance the writer pointer by "count" bytes
*/
void
abuf_wcommit(struct abuf *buf, int count)
{
#ifdef DEBUG
if (count < 0 || count > (buf->len - buf->used)) {
log_puts("abuf_wcommit: bad count = ");
log_putu(count);
log_puts("\n");
panic();
}
#endif
buf->used += count;
}
void
abuf_done(struct abuf *buf)
{
#ifdef DEBUG
if (buf->used > 0) {
if (log_level >= 3) {
log_puts("deleting non-empty buffer, used = ");
log_putu(buf->used);
log_puts("\n");
}
}
#endif
xfree(buf->data);
buf->data = (void *)0xdeadbeef;
}
static int
afile_readhdr(struct afile *f, void *addr, size_t size)
{
if (lseek(f->fd, 0, SEEK_SET) < 0) {
log_puts(f->path);
log_puts(": failed to seek to beginning of file\n");
return 0;
}
if (read(f->fd, addr, size) != size) {
log_puts(f->path);
log_puts(": failed to read header\n");
return 0;
}
return 1;
}
/*
* add the midi endpoint in the ``tag'' midi thru box
*/
void
midi_tag(struct midi *ep, unsigned int tag)
{
struct midi *peer;
struct midithru *t = midithru + tag;
int i;
if (ep->mode & MODE_MIDIOUT) {
ep->txmask |= t->txmask;
midi_tickets(ep);
}
if (ep->mode & MODE_MIDIIN) {
#ifdef DEBUG
if (ep->obuf.used > 0) {
midi_log(ep);
log_puts(": tagged with non-empty buffer\n");
panic();
}
#endif
for (i = 0; i < MIDI_NEP; i++) {
if (!(t->rxmask & (1 << i)))
continue;
peer = midi_ep + i;
peer->txmask |= ep->self;
}
}
if (ep->mode & MODE_MIDIOUT)
t->rxmask |= ep->self;
if (ep->mode & MODE_MIDIIN)
t->txmask |= ep->self;
}
/*
* discard "count" bytes at the start postion.
*/
void
abuf_rdiscard(struct abuf *buf, int count)
{
#ifdef DEBUG
if (count < 0 || count > buf->used) {
log_puts("abuf_rdiscard: bad count = ");
log_putu(count);
log_puts("\n");
panic();
}
#endif
buf->used -= count;
buf->start += count;
if (buf->start >= buf->len)
buf->start -= buf->len;
}
void log_putc(int fd, const char* c) {
if(!c) return;
stringptr ss, *s = &ss;
s->ptr = (char*) c;
s->size = strlen(c);
log_puts(fd, s);
}
static int
afile_writehdr(struct afile *f, void *addr, size_t size)
{
if (lseek(f->fd, 0, SEEK_SET) < 0) {
log_puts(f->path);
log_puts(": failed to seek back to header\n");
return 0;
}
if (write(f->fd, addr, size) != size) {
log_puts(f->path);
log_puts(": failed to write header\n");
return 0;
}
f->curpos = f->startpos;
return 1;
}
void dbglog_write(int level, const char* src, const char* fmt, ...)
{
time_t timet;
struct tm time_tm;
char buf[2048];
int count;
va_list valist;
if(!dbglog_enable_t || dbglog_handle==NULL) return;
time(&timet);
memcpy(&time_tm, localtime(&timet), sizeof(time_tm));
sprintf(buf, "[%7s] [%15s] %02d-%02d %02d:%02d:%02d (%d) ",
loglevel_strs[level], src,
// time_tm.tm_year+1900,
time_tm.tm_mon+1, time_tm.tm_mday,
time_tm.tm_hour, time_tm.tm_min, time_tm.tm_sec,
threadpool_getindex()
);
count = (int)strlen(buf);
va_start(valist, fmt);
count += vsnprintf(buf+count, sizeof(buf)-count, fmt, valist);
va_end(valist);
log_puts(dbglog_handle, level, buf, (unsigned int)count);
}
void log_printf_lf(enum log_levels level,
const char *file,
unsigned line,
const char *function,
const char *format,
...)
{
char *string;
va_list ap;
count++;
if (level > debug_level)
return;
va_start(ap, format);
string = alloc_vprintf(format, ap);
if (string != NULL) {
strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one
*char longer */
log_puts(level, file, line, function, string);
free(string);
}
va_end(ap);
}
static void pktfwd_sig_handler(int sigio)
{
int ret;
ret = lgw_stop();
if (ret == LGW_HAL_SUCCESS) {
log_puts(LOG_NORMAL, "Concentrator stopped");
} else {
log_puts(LOG_NORMAL, "Concentrator fail to stop");
}
#ifdef PKTFWD_DISABLE_ECHO
tcsetattr(STDIN_FILENO, TCSAFLUSH, &savedtty);
#endif
exit(EXIT_SUCCESS);
}
void
dev_sio_timeout(void *arg)
{
struct dev *d = arg;
dev_log(d);
log_puts(": watchdog timeout\n");
dev_close(d);
}
void print_queue(pkgstate* state, jobtype jt) {
sblist* queue = (jt == JT_DOWNLOAD) ? state->dl_queue : state->build_queue;
char *queuename = (jt == JT_DOWNLOAD) ? "download" : "build";
pkg_exec* listitem;
log_put(1, VARISL("*** "), VARIC(queuename), VARISL("queue ***"), NULL);
sblist_iter(queue, listitem) {
log_puts(1, listitem->name);
log_putln(1);
}
static void fputa(char const *arr[], FILE * stream)
{
int i;
for (i = 0; arr[i] != NULL; ++i)
if (stream_format_output(stream, "%s\n", arr[i]) < 0) {
log_puts(LCI_SEV_ALERT, "cannot print\n");
exit(EXIT_FAILURE);
}
}
void lci_options(int *cnt, char *vec[])
{
int i;
if (*cnt < 2) {
print_usage_on(stderr);
exit(EXIT_FAILURE);
}
for (i = 1; i != *cnt; ++i) {
if (parse_bool_flag(vec[i], "-b", -1) ||
parse_bool_flag(vec[i], "--no-banner", 6)) {
log_puts(LCI_SEV_DEBUG, "no banner\n");
show_banner = 0;
remove_index(&i, cnt, &vec[0]);
continue;
}
if (parse_bool_flag(vec[i], "-c", -1) ||
parse_bool_flag(vec[i], "--no-compiler", 6)) {
log_puts(LCI_SEV_DEBUG, "no compiler\n");
run_compiler = 0;
remove_index(&i, cnt, &vec[0]);
continue;
}
if (parse_bool_flag(vec[i], "-f", -1) ||
parse_bool_flag(vec[i], "--force-lint", 3)) {
log_puts(LCI_SEV_DEBUG, "force lint\n");
force_lint = 1;
remove_index(&i, cnt, &vec[0]);
continue;
}
if (parse_bool_flag(vec[i], "-l", -1) ||
parse_bool_flag(vec[i], "--no-lint", 6)) {
log_puts(LCI_SEV_DEBUG, "no lint\n");
run_lint = 0;
remove_index(&i, cnt, &vec[0]);
continue;
}
if (parse_bool_flag(vec[i], "-v", -1) ||
parse_bool_flag(vec[i], "--verbose", 6)) {
log_puts(LCI_SEV_DEBUG, "verbose\n");
inc_severity_ceiling();
remove_index(&i, cnt, &vec[0]);
continue;
}
if (parse_bool_flag(vec[i], "--help", 3)) {
log_puts(LCI_SEV_DEBUG, "help\n");
print_usage_on(stdout);
exit(EXIT_SUCCESS);
}
if (parse_bool_flag(vec[i], "--version", 6)) {
log_puts(LCI_SEV_DEBUG, "version\n");
print_version_on(stdout);
exit(EXIT_SUCCESS);
}
break;
}
}
void
fdpass_hup(void *arg)
{
struct fdpass *f = arg;
if (log_level >= 3) {
fdpass_log(f);
log_puts(": hup\n");
}
fdpass_close(f);
}
void
fdpass_in_helper(void *arg)
{
int cmd, num, mode, fd;
struct fdpass *f = arg;
struct dev *d;
struct port *p;
if (!fdpass_recv(f, &cmd, &num, &mode, &fd))
return;
switch (cmd) {
case FDPASS_OPEN_SND:
d = dev_bynum(num);
if (d == NULL || !(mode & (SIO_PLAY | SIO_REC))) {
if (log_level >= 1) {
fdpass_log(f);
log_puts(": bad audio device or mode\n");
}
fdpass_close(f);
return;
}
fd = sio_sun_getfd(d->path, mode, 1);
break;
case FDPASS_OPEN_MIDI:
p = port_bynum(num);
if (p == NULL || !(mode & (MIO_IN | MIO_OUT))) {
if (log_level >= 1) {
fdpass_log(f);
log_puts(": bad midi port or mode\n");
}
fdpass_close(f);
return;
}
fd = mio_rmidi_getfd(p->path, mode, 1);
break;
default:
fdpass_close(f);
return;
}
fdpass_send(f, FDPASS_RETURN, 0, 0, fd);
}
void hash_reads( table* T, const char* reads_fn, interval_stack* is )
{
samfile_t* reads_f = samopen( reads_fn, "rb", NULL );
if( reads_f == NULL ) {
failf( "Can't open bam file '%s'.", reads_fn );
}
bam_index_t* reads_index = bam_index_load( reads_fn );
if( reads_index == NULL ) {
failf( "Can't open bam index '%s.bai'.", reads_fn );
}
bam_init_header_hash( reads_f->header );
table_create( T, reads_f->header->n_targets );
T->seq_names = (char**)malloc( sizeof(char*) * reads_f->header->n_targets );
size_t k;
for( k = 0; k < reads_f->header->n_targets; k++ ) {
T->seq_names[k] = strdup(reads_f->header->target_name[k]);
}
log_puts( LOG_MSG, "hashing reads ... \n" );
log_indent();
bam_iter_t read_iter;
bam1_t* read = bam_init1();
int tid;
interval_stack::iterator i;
for( i = is->begin(); i != is->end(); i++ ) {
tid = bam_get_tid( reads_f->header, i->seqname );
if( tid < 0 ) continue;
read_iter = bam_iter_query( reads_index, tid,
i->start, i->end );
while( bam_iter_read( reads_f->x.bam, read_iter, read ) >= 0 ) {
if( bam1_strand(read) == i->strand ) {
table_inc( T, read );
}
}
bam_iter_destroy(read_iter);
}
bam_destroy1(read);
log_unindent();
log_printf( LOG_MSG, "done. (%zu unique reads hashed)\n", T->m );
bam_index_destroy(reads_index);
samclose(reads_f);
}
int log_write(LOG_HANDLE ctx, int level, const char* fmt, ...)
{
char buf[2*1024];
int count;
va_list argptr;
va_start(argptr, fmt);
count = vsnprintf(buf, sizeof(buf), fmt, argptr);
va_end(argptr);
return log_puts(ctx, level, buf, count);
}
void
fdpass_in_worker(void *arg)
{
struct fdpass *f = arg;
if (log_level >= 3) {
fdpass_log(f);
log_puts(": exit\n");
}
fdpass_close(f);
return;
}
static int
afile_aiff_readdata(struct afile *f, unsigned int csize, unsigned int *roffs)
{
struct aiff_data data;
if (csize < sizeof(struct aiff_data)) {
log_puts(f->path);
log_puts(": ");
log_putu(csize);
log_puts(": bogus data chunk size\n");
return 0;
}
csize = sizeof(struct aiff_data);
if (read(f->fd, &data, csize) != csize) {
log_puts(f->path);
log_puts(": failed to read data chunk\n");
return 0;
}
*roffs = csize + be32_get(&data.offs);
return 1;
}
void
dev_sio_close(struct dev *d)
{
#ifdef DEBUG
if (log_level >= 3) {
dev_log(d);
log_puts(": closed\n");
}
#endif
timo_del(&d->sio.watchdog);
file_del(d->sio.file);
sio_close(d->sio.hdl);
}
void
dev_sio_stop(struct dev *d)
{
if (!sio_eof(d->sio.hdl) && !sio_stop(d->sio.hdl)) {
if (log_level >= 1) {
dev_log(d);
log_puts(": failed to stop device\n");
}
return;
}
#ifdef DEBUG
if (log_level >= 3) {
dev_log(d);
log_puts(": stopped, load avg = ");
log_puti(d->sio.sum_utime / 1000);
log_puts(" / ");
log_puti(d->sio.sum_wtime / 1000);
log_puts("\n");
}
#endif
timo_del(&d->sio.watchdog);
}
void
dev_sio_hup(void *arg)
{
struct dev *d = arg;
#ifdef DEBUG
if (log_level >= 2) {
dev_log(d);
log_puts(": disconnected\n");
}
#endif
dev_close(d);
}
int
afile_seek(struct afile *f, off_t pos)
{
pos += f->startpos;
if (f->endpos >= 0 && pos > f->endpos && !f->par.sig) {
log_puts(f->path);
log_puts(": attempt to seek outside file boundaries\n");
return 0;
}
/*
* seek only if needed to avoid errors with pipes & sockets
*/
if (pos != f->curpos) {
if (lseek(f->fd, pos, SEEK_SET) < 0) {
log_puts(f->path);
log_puts(": couldn't seek\n");
return 0;
}
f->curpos = pos;
}
return 1;
}
void
dev_sio_onmove(void *arg, int delta)
{
struct dev *d = arg;
#ifdef DEBUG
if (log_level >= 4) {
dev_log(d);
log_puts(": tick, delta = ");
log_puti(delta);
log_puts("\n");
}
d->sio.sum_utime += file_utime - d->sio.utime;
d->sio.sum_wtime += file_wtime - d->sio.wtime;
d->sio.wtime = file_wtime;
d->sio.utime = file_utime;
if (d->mode & MODE_PLAY)
d->sio.pused -= delta;
if (d->mode & MODE_REC)
d->sio.rused += delta;
#endif
dev_onmove(d, delta);
}
void daemonize(void) {
pid_t pid = fork();
if (pid < 0) {
#ifndef NO_DAEMONIZE_OUTPUT
log_puts(2, SPLITERAL("fork error"));
#endif
exit(1);
}
if (pid > 0) exit(0);
setsid(); /* obtain a new process group */
int fd;
for (fd = getdtablesize(); fd >= 0; --fd) close(fd); /* close all descriptors */
fd = open("/dev/null", O_RDWR); dup(fd); dup(fd); /* handle standart I/O */
}
/*
* broadcast the given message to other endpoints
*/
void
midi_send(struct midi *iep, unsigned char *msg, int size)
{
struct midi *oep;
int i;
#ifdef DEBUG
if (log_level >= 4) {
midi_log(iep);
log_puts(": sending:");
for (i = 0; i < size; i++) {
log_puts(" ");
log_putx(msg[i]);
}
log_puts("\n");
}
#endif
for (i = 0; i < MIDI_NEP ; i++) {
if ((iep->txmask & (1 << i)) == 0)
continue;
oep = midi_ep + i;
if (msg[0] <= 0x7f) {
if (oep->owner != iep)
continue;
} else if (msg[0] <= 0xf7)
oep->owner = iep;
#ifdef DEBUG
if (log_level >= 4) {
midi_log(iep);
log_puts(" -> ");
midi_log(oep);
log_puts("\n");
}
#endif
oep->ops->omsg(oep->arg, msg, size);
}
}
/*
* Write header and seek to start position
*/
static int
afile_au_writehdr(struct afile *f)
{
struct au_hdr hdr;
unsigned int fmt;
memset(&hdr, 0, sizeof(struct au_hdr));
memcpy(hdr.id, au_id, 4);
be32_set(&hdr.offs, f->startpos);
be32_set(&hdr.size, f->endpos - f->startpos);
switch (f->par.bits) {
case 8:
fmt = AU_FMT_PCM8;
break;
case 16:
fmt = AU_FMT_PCM16;
break;
case 24:
fmt = AU_FMT_PCM24;
break;
case 32:
fmt = AU_FMT_PCM32;
break;
#ifdef DEBUG
default:
log_puts(f->path);
log_puts(": wrong precision\n");
panic();
return 0;
#endif
}
be32_set(&hdr.fmt, fmt);
be32_set(&hdr.rate, f->rate);
be32_set(&hdr.nch, f->nch);
return afile_writehdr(f, &hdr, sizeof(struct au_hdr));
}
