int
main(int argc, char* argv[]) {
int fd;
static struct cdb c;
errmsg_iam("cdbget");
if(argc < 3)
die(1, "usage: cdbget data.cdb key");
fd = open(argv[1], O_RDONLY | O_BINARY);
if(fd == -1)
diesys(1, "open");
cdb_init(&c, fd);
if(cdb_find(&c, argv[2], str_len(argv[2])) > 0) {
do {
char* x = malloc(cdb_datalen(&c));
if(!x)
die(1, "out of memory");
if(cdb_read(&c, x, cdb_datalen(&c), cdb_datapos(&c)) == -1)
diesys(1, "cdb_read");
buffer_put(buffer_1, x, cdb_datalen(&c));
buffer_put(buffer_1, "\n", 1);
free(x);
} while(cdb_findnext(&c, argv[2], str_len(argv[2])) > 0);
}
buffer_flush(buffer_1);
}
static int doit(stralloc *out,int s,char ipremote[16],uint16 portremote,char iplocal[16],uint16 portlocal,unsigned int timeout,uint32 netif)
{
buffer b;
char bspace[128];
char strnum[FMT_ULONG];
int numcolons;
char ch;
if (socket_bind6(s,iplocal,0,netif) == -1) return -1;
if (timeoutconn6(s,ipremote,113,timeout,netif) == -1) return -1;
buffer_init(&b,mywrite,s,bspace,sizeof bspace);
buffer_put(&b,strnum,fmt_ulong(strnum,portremote));
buffer_put(&b," , ",3);
buffer_put(&b,strnum,fmt_ulong(strnum,portlocal));
buffer_put(&b,"\r\n",2);
if (buffer_flush(&b) == -1) return -1;
buffer_init(&b,myread,s,bspace,sizeof bspace);
numcolons = 0;
for (;;) {
if (buffer_get(&b,&ch,1) != 1) return -1;
if ((ch == ' ') || (ch == '\t') || (ch == '\r')) continue;
if (ch == '\n') return 0;
if (numcolons < 3) {
if (ch == ':') ++numcolons;
}
else {
if (!stralloc_append(out,&ch)) return -1;
if (out->len > 256) return 0;
}
}
}
int count_depth() {
char buffer[MAXIMUM_PATH_LENGTH];
size_t len, i, c;
for(;;) {
buffer[0] = '\0';
len = buffer_getline(buffer_0, buffer, sizeof(buffer));
if(len == 0 || buffer[0] == '\0')
break;
if(buffer[len - 1 ] == '/')
len--;
c = 0;
for(i = 0; i < len; i++) {
if(buffer[i] == '/')
c++;
}
buffer_putulong(buffer_1, (unsigned long)c);
buffer_put(buffer_1, " ", 1);
buffer_put(buffer_1, buffer, len);
buffer_put(buffer_1, "\n", 1);
}
buffer_flush(buffer_1);
return 0;
}
main()
{
int pid;
int wstat;
char ch;
sig_ignore(sig_pipe);
pid = fork();
if (pid == -1) strerr_die2sys(111,"mconnect-io: fatal: ","unable to fork: ");
if (!pid) {
buffer_init(&bin,myread,0,inbuf,sizeof inbuf);
buffer_init(&bout,write,7,outbuf,sizeof outbuf);
while (buffer_get(&bin,&ch,1) == 1) {
if (ch == '\n') buffer_put(&bout,"\r",1);
buffer_put(&bout,&ch,1);
}
_exit(0);
}
buffer_init(&bin,myread,6,inbuf,sizeof inbuf);
buffer_init(&bout,write,1,outbuf,sizeof outbuf);
while (buffer_get(&bin,&ch,1) == 1)
buffer_put(&bout,&ch,1);
kill(pid,sig_term);
wait_pid(&wstat,pid);
_exit(0);
}
void snap_dump(char *filename, stralloc *sa)
{
dAVLCursor c;
dAVLNode *node;
char strip[IP6_FMT];
char strnum[FMT_ULONG];
int fd;
fd = open_trunc("filename");
if(fd == -1)
strerr_warn1(ARGV0 "warning: unable to open for tcp.tmp for writing", &strerr_sys);
buffer_init(&wb, write, fd, wbspace, sizeof wbspace);
node = dAVLFirst(&c, t);
while(node)
{
buffer_put(&wb, strnum, fmt_ulong(strnum, node->key));
buffer_puts(&wb, ",");
buffer_put(&wb, strip, ip4_fmt(strip, node->ip4));
buffer_puts(&wb, ",");
buffer_put(&wb, strip, ip6_fmt(strip, node->ip6));
buffer_puts(&wb, ",LOC\n");
node = dAVLNext(&c);
}
buffer_flush(&wb);
close(fd);
}
int main (void)
{
PROG = "s6-tai64nlocal" ;
for (;;)
{
unsigned int p = 0 ;
int r = skagetln(buffer_0f1, &satmp, '\n') ;
if (r == -1)
if (errno != EPIPE)
strerr_diefu1sys(111, "read from stdin") ;
else r = 1 ;
else if (!r) break ;
if (satmp.len > TIMESTAMP)
{
tain_t a ;
p = timestamp_scan(satmp.s, &a) ;
if (p)
{
char fmt[LOCALTMN_FMT+1] ;
localtmn_t local ;
unsigned int len ;
localtmn_from_tain(&local, &a, 1) ;
len = localtmn_fmt(fmt, &local) ;
if (buffer_put(buffer_1, fmt, len) < 0)
strerr_diefu1sys(111, "write to stdout") ;
}
}
if (buffer_put(buffer_1, satmp.s + p, satmp.len - p) < 0)
strerr_diefu1sys(111, "write to stdout") ;
satmp.len = 0 ;
}
return 0 ;
}
static int
x_escape_put (struct buffer *out, const char *str, unsigned long len, void *data)
{
unsigned long pos;
char ch;
for (;;) {
pos = scan_notcharsetn (str, "<>&", len);
if (pos) buffer_put (out, str, pos);
str += pos;
len -= pos;
if (!len) break;
ch = *str;
switch (ch) {
case '<': buffer_put (out, "<", 4); break;
case '>': buffer_put (out, ">", 4); break;
case '&': buffer_put (out, "&", 5); break;
default: break;
}
++str;
--len;
if (!len) break;
}
return 1;
}
int main(void)
{
struct taia taia;
char stamp[TAIA_TAI64N + 1];
char ch;
stamp[0] = '@';
for (;;) {
if (buffer_get(buffer0, &ch, 1) != 1) { done(); goto FINISH; }
taia_now(&taia);
taia_tai64n(stamp + 1, &taia);
stamp[sizeof(stamp) - 1] = ' ';
buffer_put(buffer1, stamp, sizeof(stamp));
for (;;) {
buffer_put(buffer1, &ch, 1);
if (ch == '\n') break;
if (buffer_get(buffer0, &ch, 1) != 1) { done(); goto FINISH; }
}
}
FINISH:
return 0;
}
int
main(int argc, char **argv, const char *ZEBRA_VTYSH_PATH)
{
struct buffer *b1, *b2;
int n;
char junk[3];
char c = 'a';
memory_init();
if ((argc != 2) || (sscanf(argv[1], "%d%1s", &n, junk) != 1))
{
fprintf(stderr, "Usage: %s <number of chars to simulate>\n", *argv);
return 1;
}
b1 = buffer_new(0);
b2 = buffer_new(1024);
while (n-- > 0)
{
buffer_put(b1, &c, 1);
buffer_put(b2, &c, 1);
if (c++ == 'z')
c = 'a';
buffer_reset(b1);
buffer_reset(b2);
}
buffer_free(b1);
buffer_free(b2);
return 0;
}
void print(char *buf,unsigned int len)
{
char tcpheader[2];
uint16_pack_big(tcpheader,len);
buffer_put(&netwrite,tcpheader,2);
buffer_put(&netwrite,buf,len);
buffer_flush(&netwrite);
}
static ssize_t __block_write(struct file *file, off_t posit, uint8_t *buf, size_t count)
{
struct blockdev *bd = file->inode->devdata;
int blk_size = bd->ctl->blocksize;
unsigned pos = posit;
// If we are offset in a block, we dont wanna overwrite stuff.
if(pos % blk_size)
{
struct ioreq *req = ioreq_create(bd, READ, pos / blk_size, 1);
struct buffer *br = block_cache_get_first_buffer(req);
ioreq_put(req);
if(!br)
return 0;
// If count is less than whats remaining, just use count.
int write = (blk_size-(pos % blk_size));
if(count < (unsigned)write)
write=count;
memcpy(br->data+(pos % blk_size), buf, write);
atomic_fetch_or(&br->flags, BUFFER_DIRTY);
buffer_put(br);
buf += write;
count -= write;
pos += write;
}
while(count >= (unsigned int)blk_size)
{
ASSERT((pos & ~(blk_size - 1)) == pos);
struct buffer *entry = dm_block_cache_get(bd, pos / blk_size);
if(!entry) {
entry = buffer_create(bd, pos / blk_size, BUFFER_DIRTY, buf);
memcpy(entry->data, buf, blk_size);
dm_block_cache_insert(bd, pos/blk_size, entry, BLOCK_CACHE_OVERWRITE);
} else {
memcpy(entry->data, buf, blk_size);
atomic_fetch_or(&entry->flags, BUFFER_DIRTY);
}
buffer_put(entry);
count -= blk_size;
pos += blk_size;
buf += blk_size;
}
// Anything left over?
if(count > 0)
{
struct ioreq *req = ioreq_create(bd, READ, pos/blk_size, 1);
struct buffer *br = block_cache_get_first_buffer(req);
ioreq_put(req);
if(!br)
return 0;
memcpy(br->data, buf, count);
atomic_fetch_or(&br->flags, BUFFER_DIRTY);
buffer_put(br);
pos+=count;
}
return pos-posit;
}
static void showstatus(const char status[19], int r)
{
const char *x;
struct tai when;
struct tai now;
pid = (unsigned char) status[15];
pid <<= 8; pid += (unsigned char) status[14];
pid <<= 8; pid += (unsigned char) status[13];
pid <<= 8; pid += (unsigned char) status[12];
paused = status[16];
want = status[17];
statusflag = status[18];
tai_unpack(status,&when);
tai_now(&now);
if (tai_less(&now,&when)) when = now;
tai_sub(&when,&now,&when);
if (pid) {
buffer_puts(&b,"up (pid ");
buffer_put(&b,strnum,fmt_ulong(strnum,pid));
buffer_puts(&b,") ");
}
else
buffer_puts(&b,"down ");
buffer_put(&b,strnum,fmt_ulong(strnum,tai_approx(&when)));
buffer_puts(&b," seconds");
if (pid && !normallyup)
buffer_puts(&b,", normally down");
if (!pid && normallyup)
buffer_puts(&b,", normally up");
if (pid && paused)
buffer_puts(&b,", paused");
if (!pid && (want == 'u'))
buffer_puts(&b,", want up");
if (pid && (want == 'd'))
buffer_puts(&b,", want down");
if (r > 18) {
switch (statusflag) {
case svstatus_stopped: x = ", stopped"; break;
case svstatus_starting: x = ", starting"; break;
case svstatus_started: x = ", started"; break;
case svstatus_running: x = ", running"; break;
case svstatus_stopping: x = ", stopping"; break;
case svstatus_failed: x=", failed"; break;
default: x = ", status unknown";
}
if (x)
buffer_puts(&b,x);
}
}
int mercy_seek_abs(unsigned short row, unsigned short col) {
if (row >= mercy_context.rows ||
col >= mercy_context.cols)
return -1;
if (buffer_puts(buffer_1, MERCY_ESCAPE) ||
buffer_putulong(buffer_1, row + 1) ||
buffer_put(buffer_1, ";", 1) ||
buffer_putulong(buffer_1, col + 1) ||
buffer_put(buffer_1, "H", 1))
return -1;
return 0;
}
unsigned char canSend(CAN_PORT notused, Message *m)
{
unsigned char i;
/* Send the message as raw bytes (note little-endianness of Cortex M3) */
buffer_put(send_buffer, (m->cob_id) & 0xFF);
buffer_put(send_buffer, (m->cob_id) >> 8);
buffer_put(send_buffer, (m->rtr));
buffer_put(send_buffer, (m->len));
for (i= 0; i < (m->len); i++)
buffer_put(send_buffer, m->data[i]);
/* Start sending by enabling the interrupt */
usart_enable_tx_interrupt(USART1);
return 1; // successful
}
void Lexer::consumeString()
{
m_value = "";
char delim = buffer_pop();
for (;;) {
if (buffer_empty()) {
buffer_put(m_input->get());
}
char current = buffer_peek();
if (current == delim) {
buffer_pop();
break;
}
if (current == std::char_traits<char>::eof()) {
break;
}
m_value.push_back(buffer_pop());
}
m_token = token::string;
}
int
send_file_fd (int out_fd, int in_fd, uint64 offset, uint64 size, uint64 *sent)
{
char data_in[BUFFER_INSIZE];
char data_out[BUFFER_OUTSIZE];
struct buffer buf_in;
struct buffer buf_out;
int64 r;
int64 w;
uint64 r_sent = 0;
char *x;
buffer_init (&buf_in, (buffer_op) read, in_fd, data_in, sizeof (data_in));
buffer_init (&buf_out, (buffer_op) write, out_fd, data_out, sizeof (data_out));
for (;;) {
r = buffer_feed (&buf_in);
if (r == 0) break;
if (r == -1) goto FAIL;
x = buffer_peek (&buf_in);
w = buffer_put (&buf_out, x, r);
if (w == -1) goto FAIL;
buffer_seek (&buf_in, r);
r_sent += w;
}
*sent = r_sent;
return 0;
FAIL:
*sent = r_sent;
return -1;
}
int
main (int argc, char *argv[])
{
int n = 0;
char *x = NULL;
dns_random_init (seed);
prog = strdup ((x = strrchr (argv[0], '/')) != NULL ? x + 1 : argv[0]);
n = check_option (argc, argv);
argv += n;
argc -= n;
while (*argv)
{
if (!ip4_scan (*argv, ip))
errx (-1, "could not parse IP address `%s'", *argv);
if (dns_name4 (&out, ip) == -1)
errx (-1, "could not find host name for `%s'", *argv);
buffer_put (buffer_1, out.s, out.len);
buffer_puts (buffer_1,"\n");
++argv;
}
buffer_flush (buffer_1);
return 0;
}
void usart1_isr(void)
{
u8 ch;
//if Receive interrupt
if (((USART_CR1(USART1) & USART_CR1_RXNEIE) != 0) &&
((USART_SR(USART1) & USART_SR_RXNE) != 0))
{
ch=usart_recv(USART1);
buffer_put(&u1rx, ch);
}
if (((USART_CR1(USART1) & USART_CR1_TXEIE) != 0) &&
((USART_SR(USART1) & USART_SR_TXE) != 0))
{
if (buffer_get(&u1tx, &ch) == SUCCESS)
{
//if char read from buffer
usart_send(USART1, ch);
}
else //if buffer empty
{
//disable Transmit Data Register empty interrupt
usart_disable_tx_interrupt(USART1);
}
}
}
int main(int argc,char **argv)
{
int i;
char *x;
char *y;
unsigned int u;
uint32 ttl;
if (!cache_init(200)) _exit(111);
if (*argv) ++argv;
while (x = *argv++) {
i = str_chr(x,':');
if (x[i])
cache_set(x,i,x + i + 1,str_len(x) - i - 1,86400,0);
else {
y = cache_get(x,i,&u,&ttl,0);
if (y)
buffer_put(buffer_1,y,u);
buffer_puts(buffer_1,"\n");
}
}
buffer_flush(buffer_1);
_exit(0);
}
void Lexer::consumeIdentifier()
{
m_value = "";
for (;;) {
if (buffer_empty()) {
buffer_put(m_input->get());
}
char current = buffer_peek();
/*
* The XML spec allows much narrower set of valid identifiers, but
* I see not charm in accepting some of the malformed identifiers
* since the parser is not very strict about standard too.
*/
// TODO: Replace it with std::isspace in the future.
if (isspace(current) ||
current == '<' || current == '>' ||
current == '=' || current == '/' || current == '?' ||
current == '"' || current == '\'' ||
current == std::char_traits<char>::eof())
{
break;
}
m_value.push_back(buffer_pop());
}
m_token = token::identifier;
}
/* output error message
* ----------------------------------------------------------------------- */
int sh_errorn(const char *s, unsigned int len) {
sh_msg(NULL);
buffer_put(fd_err->w, s, len);
buffer_putm(fd_err->w, ": ", strerror(errno), "\n", NULL);
buffer_flush(fd_err->w);
return 1;
}
int main(int argc,char **argv)
{
int i;
dns_random_init(seed);
if (*argv) ++argv;
while (*argv) {
if (!stralloc_copys(&fqdn,*argv))
strerr_die2x(111,FATAL,"out of memory");
if (dns_ip4(&out,&fqdn) == -1)
strerr_die4sys(111,FATAL,"unable to find IP address for ",*argv,": ");
for (i = 0; i + 4 <= out.len; i += 4) {
buffer_put(buffer_1,str,ip4_fmt(str,out.s + i));
buffer_puts(buffer_1," ");
}
buffer_puts(buffer_1,"\n");
++argv;
}
buffer_flush(buffer_1);
_exit(0);
}
int main(void) {
initStartup();
buffer_put(&SerialData0.rx, 0); // sleep this!
while (1) {
if (!buffer_isempty(&SerialData0.rx)) { //if you've received some input then save it to the input
if (uart0_peek_int() != input) {
prevInput = input;
input = uart0_fgetchar_int(&uart_str);
} else
buffer_get(&SerialData0.rx); // remove from buffer!
}
if (prevInput != input) {
if (input != 0) { // if the hosts requests a readout
if ((input & 0b00001000) == 0) //if you've not requested the rear pad then disable mux and it's decoder input
PORTL = 0x00;
if (firstOffRx == 0) {// if you were in sleep then get out ()might need to change this
sleepSystemWake();
firstOffRx = 1;
}
uart0_fputchar_int(MAIN_PACKET_END_BYTE,&uart_str); //send the start packet id
for (int i = 0; i < 5; i++) { // rx all requested sensors
uint8_t tempInput = (input & (0b00000001 << i));
if (tempInput != 0)
helperRetrieveSensor(tempInput);
}
} else if (firstOffRx == 1) // sleep here once and only once
sleepSystem();
}
}
return 0;
}
static enum ud_tree_walk_stat
rt_tag_link_ext (struct udoc *ud, struct udr_ctx *rc)
{
char cnum[FMT_ULONG];
const struct ud_node *node = rc->uc_tree_ctx->utc_state->utc_node;
struct ud_ref *ref;
struct buffer *buf = &rc->uc_out->uoc_buffer;
unsigned long index;
unsigned long max;
/* urls are numbered, so a linear search is necessary to work out the url id */
/* XXX: this is not ideal... */
max = ud_oht_size (&ud->ud_link_exts);
for (index = 0; index < max; ++index) {
ud_assert (ud_oht_get_index (&ud->ud_link_exts, index, (void *) &ref));
if (node == ref->ur_node) {
buffer_puts (buf, "\\from[url_");
buffer_put (buf, cnum, fmt_ulong (cnum, index));
buffer_puts (buf, "]");
return 1;
}
}
return 1;
}
void doit()
{
char ch;
int match = 1;
long linenum = 0;
stralloc fifoline = { 0 };
linenum = 0;
/* try duming data in 23 seconds */
alarm(dumpfreq);
buffer_putsflush(buffer_2, ARGV0 "entering main loop\n");
/* forever read from pipe line by line and handle it */
while(1)
{
while(match)
{
if(flagdumpasap == 1)
dumpcheck(flagdumpasap, flagchanged, flagchildrunning, flagsighup);
++linenum;
if(buffer_get(&wr, &ch, 1) == 1)
{
if(getln(&wr, &fifoline, &match, '\n') == -1)
continue;
buffer_put(buffer_2, &ch, 1);
buffer_putflush(buffer_2, fifoline.s, fifoline.len);
handle_line(&fifoline, ch);
}
}
}
}
static int outputlines (stralloc const *s, unsigned int len)
{
register unsigned int i = 0 ;
for (; i < len ; i++)
if (buffer_put(buffer_1, s[i].s, s[i].len) < 0) return 0 ;
return buffer_flush(buffer_1) ;
}
buffer_status_t
buffer_write(struct buffer *b, int fd, const void *p, size_t size)
{
ssize_t nbytes;
#if 0
/* Should we attempt to drain any previously buffered data? This could help
reduce latency in pushing out the data if we are stuck in a long-running
thread that is preventing the main select loop from calling the flush
thread... */
if (b->head && (buffer_flush_available(b, fd) == BUFFER_ERROR))
return BUFFER_ERROR;
#endif
if (b->head)
/* Buffer is not empty, so do not attempt to write the new data. */
nbytes = 0;
else if ((nbytes = write(fd, p, size)) < 0)
{
if (ERRNO_IO_RETRY(errno))
nbytes = 0;
else
{
zlog_warn("%s: write error on fd %d: %s",
__func__, fd, safe_strerror(errno));
return BUFFER_ERROR;
}
}
/* Add any remaining data to the buffer. */
{
size_t written = nbytes;
if (written < size)
buffer_put(b, ((const char *)p)+written, size-written);
}
return b->head ? BUFFER_PENDING : BUFFER_EMPTY;
}
int buffer_putflush (buffer *b, char const *s, unsigned int len)
{
int r = buffer_put(b, s, len) ;
if (r < 0) return -1 ;
if (!buffer_flush(b)) return -1 ;
return r ;
}
char *
octstr_append_n(octstr_t *octstr, const void *ptr, size_t n)
{
assert(octstr != NULL);
buffer_put(octstr->buf, ptr, n);
return buffer_ptr(octstr->buf);
}
char *
octstr_append(octstr_t *octstr, const char *ptr)
{
assert(octstr != NULL);
buffer_put(octstr->buf, ptr, strlen(ptr));
return buffer_ptr(octstr->buf);
}
