static void write_record (int move_back_flag) { save_record = record_start; record_start = new_record; if (archive == STDIN) { archive = STDOUT; flush_write (); archive = STDIN; } else { move_archive (-(records_read + 1)); flush_write (); } record_start = save_record; if (move_back_flag) { /* Move the tape head back to where we were. */ if (archive != STDIN) move_archive (records_read); records_read--; } blocks_needed = blocking_factor; new_blocks = 0; }
/* Write out the record which has been filled. If MOVE_BACK_FLAG, backspace to where we started. */ static void write_record (int move_back_flag) { union block *save_record = record_start; record_start = new_record; if (acting_as_filter) { archive = STDOUT_FILENO; flush_write (); archive = STDIN_FILENO; } else { move_archive ((records_written + records_skipped) - records_read); flush_write (); } record_start = save_record; if (move_back_flag) { /* Move the tape head back to where we were. */ if (! acting_as_filter) move_archive (records_read - (records_written + records_skipped)); } new_blocks = 0; }
static ssize_t write(struct file * file, const char __user * userbuf, size_t count, loff_t * off) { char *buffer = file->private_data; struct dentry *dentry = file->f_dentry; int size = dentry->d_inode->i_size; loff_t offs = *off; if (count > PAGE_SIZE) count = PAGE_SIZE; if (size) { if (offs > size) return 0; if (offs + count > size) count = size - offs; } if (copy_from_user(buffer, userbuf, count)) return -EFAULT; count = flush_write(dentry, buffer, offs, count); if (count > 0) *off = offs + count; return count; }
// read_cb: a TCP connection is readable so read the bytes that are on // it and pass them to OpenSSL void read_cb(uv_stream_t *s, ssize_t nread, const uv_buf_t *buf) { connection_state *state = (connection_state *)s->data; if (nread > 0) { // If there's data to read then pass it to OpenSSL via the BIO // TODO: check return value BIO_write(state->read_bio, buf->base, nread); } if ((nread == UV_EOF) || (nread < 0)) { connection_terminate(state->tcp); } else { if (do_ssl(state)) { write_queued_messages(state); flush_write(state); } else { connection_terminate(state->tcp); } } // Buffer was previously allocated by us in a call to // allocate_cb. libuv will not reuse so we must free. if (buf) { free(buf->base); } }
static ssize_t write(struct file *file, const char __user *userbuf, size_t bytes, loff_t *off) { struct bin_buffer *bb = file->private_data; struct dentry *dentry = file->f_path.dentry; int size = dentry->d_inode->i_size; loff_t offs = *off; int count = min_t(size_t, bytes, PAGE_SIZE); if (size) { if (offs > size) return 0; if (offs + count > size) count = size - offs; } mutex_lock(&bb->mutex); if (copy_from_user(bb->buffer, userbuf, count)) { count = -EFAULT; goto out_unlock; } count = flush_write(dentry, bb->buffer, offs, count); if (count > 0) *off = offs + count; out_unlock: mutex_unlock(&bb->mutex); return count; }
Errcode slow_to_wacom(SHORT port, char *s) /* send a string out serial port with a delay afterwards */ { ser_write(port,s,strlen(s)); flush_write(port); wait_milli(150); return(ser_status(port)); }
/* * Read utility functions */ uint8_t *read_data(void) { static uint8_t last_read_data[10000]; int i, j, expected_len = 0, extra_bytes = 0; if (trace) printf("[%s]\n", __FUNCTION__); if (buffer_current_size()) *usbreadbuffer_ptr++ = SEND_IMMEDIATE; /* tell the FTDI that we are waiting... */ flush_write(NULL); last_read_data_length = 0; for (i = 0; i < read_size_ptr; i++) { if (read_size[i] > 0) expected_len += read_size[i]; else { if (i > 0 && read_size[i-1] < 0) extra_bytes++; /* we will squeeze out partial bytes in the processing below */ else expected_len++; /* When there are 2 bit operations in a row, this is just accumulating * shifted bits into a register for return to user. When exiting * Shift-DR/IR state, the last bit shifted is not performed with DATAWBITS, * but with a TMS operation. For this reason, the combo of 2 bit ops * in a row is quite common. */ } } if (expected_len + extra_bytes) ftdi_read_data(global_ftdi, last_read_data, expected_len + extra_bytes); last_read_data_length = expected_len; if (expected_len) { uint8_t *p = last_read_data; int validbits = 0; for (i = 0; i < read_size_ptr; i++) { if (read_size[i] < 0) { validbits -= read_size[i]; if (validbits < 0 || validbits > 8) { printf("[%s] validbits %d big\n", __FUNCTION__, validbits); validbits = 8; //exit(-1); } *p &= (0xff << (8-validbits)); /* NOTE: when trying to combine back data bits that result from a TMS * shift with > 1 bit, be aware that the number of bits shifted in reflects the * _number of TMS bits shifted_, not the number of valid data bits (which is * always only 1). */ if (i > 0 && read_size[i-1] < 0) { *(p-1) = *p >> (8-validbits); /* put result into LSBs */ /* Note: union datatypes work correctly, but int needs the data as MSBs! */ for (j = 0; j < expected_len; j++) /* copies too much, but... */ *(p+j) = *(p+j+1); /* move the data down in the buffer 1 byte */ } else p++; }
void flush_or_clean() { switch(get_mode()) { case gf_read_only: clean_read(); break; case gf_write_only: case gf_read_write: flush_write(); break; default: throw SRC_BUG; } };
static ssize_t write(struct file *file, const char __user *userbuf, size_t bytes, loff_t *off) { struct bin_buffer *bb = file->private_data; struct dentry *dentry = file->f_path.dentry; int size = dentry->d_inode->i_size; loff_t offs = *off; int count = min_t(size_t, bytes, PAGE_SIZE); char *temp; if (!bytes) return 0; if (size) { if (offs > size) return 0; if (offs + count > size) count = size - offs; } temp = kmalloc(count, GFP_KERNEL); if (!temp) return -ENOMEM; if (copy_from_user(temp, userbuf, count)) { count = -EFAULT; goto out_free; } mutex_lock(&bb->mutex); memcpy(bb->buffer, temp, count); count = flush_write(dentry, bb->buffer, offs, count); mutex_unlock(&bb->mutex); if (count > 0) *off = offs + count; out_free: kfree(temp); return count; }
static ssize_t write(struct file *file, const char __user *userbuf, size_t bytes, loff_t *off) { struct bin_buffer *bb = file->private_data; struct dentry *dentry = file->f_path.dentry; int size = dentry->d_inode->i_size; loff_t offs = *off; int count = min_t(size_t, bytes, PAGE_SIZE); char *temp; if (!bytes) return 0; if (size) { if (offs > size) return 0; if (offs + count > size) count = size - offs; } temp = memdup_user(userbuf, count); if (IS_ERR(temp)) return PTR_ERR(temp); mutex_lock(&bb->mutex); memcpy(bb->buffer, temp, count); count = flush_write(dentry, bb->buffer, offs, count); mutex_unlock(&bb->mutex); if (count > 0) *off = offs + count; kfree(temp); return count; }
static void print_level_text(struct level *l,uint8_t *buffer) { register uint8_t *text = buffer; if(!buffer) return; start_write(); while(*text) { if(*text == '%' && text[1]) { text++; switch(*text) { case 'g': if(l) writes(l->group_name); break; case 'm': if(l) writes(l->element_name); break; case '%': writec('%'); break; default: writec('%'); writec(*text); break; } } else { writec(*text); } text++; } flush_write(); }
Errcode wac_input(Idriver *idr) { static char wlinebuf[32]; char *s = wlinebuf; int count = sizeof(wlinebuf)-2; int c; int stype; int temp; int dp; int ux,uy; SHORT port = idr->comm_port; ser_write(port, "RQ1\n", 4); flush_write(port); while (--count >= 0) { if ((c = timeout_get_char(port)) < Success) { return(c); } if ((*s++ = c) == '\n') break; } *s = 0; s = wlinebuf; switch (*s++) /* see what first character of packet says it is */ { case '!': stype = PSTYLUS; break; case '#': stype = STYLUS; break; case '*': stype = PUCK; /* it's a puck */ break; default: flush_read(port); return(Err_version); } s = skip_past_comma(s); ux = atoi(s) - 120; s = skip_past_comma(s); uy = atoi(s) - 120; s = skip_past_comma(s); temp = atoi(s); switch (stype) { case PSTYLUS: idr->buttons = 0; wac_pos[2] = 0; if (temp > -99 && temp < 99) /* filter to reasonable values */ { wac_pos[0] = ux; wac_pos[1] = uy; if (temp < pmin) pmin = temp; if (temp > pmax) pmax = temp; dp = pmax-(pmin+PTHRESH); temp -= pmin+PTHRESH; if (temp > 0) { wac_pos[2] = temp*PMAX/dp; idr->buttons = 1; } } /* check for control key to interpret a right click (Arr, no side button on pressure sensitive stylus!) */ if (jkey_shift() & 0x4) /* right button on control key */ idr->buttons |= 0x2; break; case STYLUS: if (temp != 99) { wac_pos[0] = ux; wac_pos[1] = uy; idr->buttons = temp; } break; case PUCK: idr->buttons = 0; if (temp != 99) { wac_pos[0] = ux; wac_pos[1] = uy; if (temp&2) idr->buttons |= 1; if (temp&4) idr->buttons |= 2; } break; } return(Success); }
// do_ssl: process pending data from OpenSSL and send any data that's // waiting. Returns 1 if ok, 0 if the connection should be terminated int do_ssl(connection_state *state) { BYTE *response = NULL; int response_len = 0; kssl_error_code err; // First determine whether the SSL_accept has completed. If not then any // data on the TCP connection is related to the handshake and is not // application data. if (!state->connected) { if (!SSL_is_init_finished(state->ssl)) { int rc = SSL_do_handshake(state->ssl); if (rc != 1) { switch (SSL_get_error(state->ssl, rc)) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: ERR_clear_error(); return 1; default: ERR_clear_error(); return 0; } } } state->connected = 1; } // Read whatever data needs to be read (controlled by state->need) while (state->need > 0) { int read = SSL_read(state->ssl, state->current, state->need); if (read <= 0) { int err = SSL_get_error(state->ssl, read); switch (err) { // Nothing to read so wait for an event notification by exiting // this function, or SSL needs to do a write (typically because of // a connection regnegotiation happening) and so an SSL_read // isn't possible right now. In either case return from this // function and wait for a callback indicating that the socket // is ready for a read. case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: ERR_clear_error(); return 1; // Connection termination case SSL_ERROR_ZERO_RETURN: ERR_clear_error(); return 0; // Something went wrong so give up on connetion default: log_ssl_error(state->ssl, read); return 0; } } // Read some number of bytes into the state->current buffer so move that // pointer on and reduce the state->need. If there's still more // needed then loop around to see if we can read it. This is // essential because we will only get a single event when data // becomes ready and will need to read it all. state->need -= read; state->current += read; if (state->need > 0) { continue; } // All the required data has been read and is in state->start. If // it's a header then do basic checks on the header and then get // ready to receive the payload if there is one. If it's the // payload then the entire header and payload can now be // processed. if (state->state == CONNECTION_STATE_GET_HEADER) { err = parse_header(state->wire_header, &state->header); if (err != KSSL_ERROR_NONE) { return 0; } state->start = 0; if (state->header.version_maj != KSSL_VERSION_MAJ) { write_log(1, "Message version mismatch %02x != %02x", state->header.version_maj, KSSL_VERSION_MAJ); write_error(state, state->header.id, KSSL_ERROR_VERSION_MISMATCH); clear_read_queue(state); free_read_state(state); set_get_header_state(state); return 1; } // If the header indicates that a payload is coming then read it // before processing the operation requested in the header if (state->header.length > 0) { if (!set_get_payload_state(state, state->header.length)) { write_log(1, "Memory allocation error"); write_error(state, state->header.id, KSSL_ERROR_INTERNAL); clear_read_queue(state); free_read_state(state); set_get_header_state(state); return 1; } continue; } } if (state->state == CONNECTION_STATE_GET_PAYLOAD) { // Do nothing here. If we reach here then we know that the // entire payload has been read. } else { // This should be unreachable. If this occurs give up processing // and reset. write_log(1, "Connection in unknown state %d", state->state); free_read_state(state); set_get_header_state(state); return 1; } // When we reach here state->header is valid and filled in and if // necessary state->start points to the payload. uv_rwlock_rdlock(pk_lock); err = kssl_operate(&state->header, state->start, privates, &response, &response_len); if (err != KSSL_ERROR_NONE) { log_err_error(); } else { queue_write(state, response, response_len); } uv_rwlock_rdunlock(pk_lock); // When this point is reached a complete header (and optional payload) // have been received and processed by the switch() statement above. So, // write the queued messages and then free the allocated memory and get // ready to receive another header. write_queued_messages(state); flush_write(state); free_read_state(state); set_get_header_state(state); // Loop around again in case there are multiple requests queued // up by OpenSSL. } return 1; }
void inherited_flush_read() { flush_write(); clean_read(); };
void inherited_sync_write() { flush_write(); };
void compressor::local_terminate() { if(compr != NULL) { S_I ret; // flushing the pending data flush_write(); clean_write(); ret = compr->wrap.compressEnd(); delete compr; compr = NULL; switch(ret) { case WR_OK: break; case WR_DATA_ERROR: // some data remains in the compression pipe (data loss) throw SRC_BUG; case WR_STREAM_ERROR: throw Erange("compressor::~compressor", gettext("compressed data is corrupted")); default : throw SRC_BUG; } } if(decompr != NULL) { // flushing data flush_read(); clean_read(); S_I ret = decompr->wrap.decompressEnd(); delete decompr; decompr = NULL; switch(ret) { case WR_OK: break; default: throw SRC_BUG; } } if(lzo_read_buffer != NULL) { flush_read(); clean_read(); delete [] lzo_read_buffer; lzo_read_buffer = NULL; } if(lzo_write_buffer != NULL) { flush_write(); clean_write(); delete [] lzo_write_buffer; lzo_write_buffer = NULL; } if(lzo_compressed != NULL) { delete [] lzo_compressed; lzo_compressed = NULL; } if(lzo_wrkmem != NULL) { delete [] lzo_wrkmem; lzo_wrkmem = NULL; } }