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); }