/* This function behaves exactly like read(). The only difference is * that it accepts the gnutls_session_t and the content_type_t of data to * receive (if called by the user the Content is Userdata only) * It is intended to receive data, under the current session. * * The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos. */ ssize_t _gnutls_recv_int (gnutls_session_t session, content_type_t type, gnutls_handshake_description_t htype, uint8_t * data, size_t data_size, void* seq, unsigned int ms) { int ret; if ((type != GNUTLS_ALERT && type != GNUTLS_HEARTBEAT) && (data_size == 0 || data == NULL)) return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); if (session->internals.read_eof != 0) { /* if we have already read an EOF */ return 0; } else if (session_is_valid (session) != 0 || session->internals.may_not_read != 0) { gnutls_assert (); return GNUTLS_E_INVALID_SESSION; } switch(session->internals.recv_state) { case RECV_STATE_DTLS_RETRANSMIT: ret = _dtls_retransmit(session); if (ret < 0) return gnutls_assert_val(ret); session->internals.recv_state = RECV_STATE_0; case RECV_STATE_0: _dtls_async_timer_check(session); /* If we have enough data in the cache do not bother receiving * a new packet. (in order to flush the cache) */ ret = check_buffers (session, type, data, data_size, seq); if (ret != 0) return ret; ret = _gnutls_recv_in_buffers(session, type, htype, ms); if (ret < 0 && ret != GNUTLS_E_SESSION_EOF) return gnutls_assert_val(ret); return check_buffers (session, type, data, data_size, seq); default: return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR); } }
static int write_dpram32_and_check(struct ft1000_usb *ft1000dev, u16 tempbuffer[], u16 dpram) { int status; u16 resultbuffer[64]; int i; for (i = 0; i < 10; i++) { status = ft1000_write_dpram32(ft1000dev, dpram, (u8 *)&tempbuffer[0], 64); if (status == 0) { /* Work around for ASIC bit stuffing problem. */ if ((tempbuffer[31] & 0xfe00) == 0xfe00) { status = ft1000_write_dpram32(ft1000dev, dpram+12, (u8 *)&tempbuffer[24], 64); } /* Let's check the data written */ status = ft1000_read_dpram32(ft1000dev, dpram, (u8 *)&resultbuffer[0], 64); if ((tempbuffer[31] & 0xfe00) == 0xfe00) { if (check_buffers(tempbuffer, resultbuffer, 28, 0)) { DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n"); usleep_range(9000, 11000); break; } status = ft1000_read_dpram32(ft1000dev, dpram+12, (u8 *)&resultbuffer[0], 64); if (check_buffers(tempbuffer, resultbuffer, 16, 24)) { DEBUG("FT1000:download:DPRAM write failed 2 during bootloading\n"); usleep_range(9000, 11000); break; } } else { if (check_buffers(tempbuffer, resultbuffer, 32, 0)) { DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n"); usleep_range(9000, 11000); break; } } if (status == 0) break; } } return status; }
static void domapread(unsigned offset, unsigned size) { unsigned pg_offset; unsigned map_size; char *p; offset -= offset % readbdy; if (size == 0) { if (!quiet && testcalls > simulatedopcount) prt("skipping zero size read\n"); log4(OP_SKIPPED, OP_MAPREAD, offset, size); return; } if (size + offset > file_size) { if (!quiet && testcalls > simulatedopcount) prt("skipping seek/read past end of file\n"); log4(OP_SKIPPED, OP_MAPREAD, offset, size); return; } log4(OP_MAPREAD, offset, size, 0); if (testcalls <= simulatedopcount) return; if (!quiet && ((progressinterval && testcalls % progressinterval == 0) || (debug && (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) prt("%lu mapread\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, offset, offset + size - 1, size); pg_offset = offset & page_mask; map_size = pg_offset + size; if ((p = (char *)mmap(0, map_size, PROT_READ, MAP_FILE | MAP_SHARED, fd, (off_t)(offset - pg_offset))) == (char *)-1) { prterr("domapread: mmap"); report_failure(190); } if (setjmp(jmpbuf) == 0) { jmpbuf_good = 1; memcpy(temp_buf, p + pg_offset, size); check_eofpage("Read", offset, p, size); jmpbuf_good = 0; } else { report_failure(1901); } if (munmap(p, map_size) != 0) { prterr("domapread: munmap"); report_failure(191); } check_buffers(offset, size); }
/* This function behaves exactly like read(). The only difference is * that it accepts the gnutls_session_t and the content_type_t of data to * receive (if called by the user the Content is Userdata only) * It is intended to receive data, under the current session. * * The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos. */ ssize_t _gnutls_recv_int (gnutls_session_t session, content_type_t type, gnutls_handshake_description_t htype, uint8_t * data, size_t data_size, void* seq) { int ret; if (type != GNUTLS_ALERT && (data_size == 0 || data == NULL)) { return GNUTLS_E_INVALID_REQUEST; } if (session->internals.read_eof != 0) { /* if we have already read an EOF */ return 0; } else if (session_is_valid (session) != 0 || session->internals.may_not_read != 0) { gnutls_assert (); return GNUTLS_E_INVALID_SESSION; } _dtls_async_timer_check(session); /* If we have enough data in the cache do not bother receiving * a new packet. (in order to flush the cache) */ ret = check_buffers (session, type, data, data_size, seq); if (ret != 0) return ret; ret = _gnutls_recv_in_buffers(session, type, htype); if (ret < 0 && ret != GNUTLS_E_SESSION_EOF) return gnutls_assert_val(ret); return check_buffers (session, type, data, data_size, seq); }
void doread(unsigned offset, unsigned size) { off_t ret; unsigned iret; offset -= offset % readbdy; if (o_direct) size -= size % readbdy; if (size == 0) { if (!quiet && testcalls > simulatedopcount && !o_direct) prt("skipping zero size read\n"); log4(OP_SKIPPED, OP_READ, offset, size); return; } if (size + offset > file_size) { if (!quiet && testcalls > simulatedopcount) prt("skipping seek/read past end of file\n"); log4(OP_SKIPPED, OP_READ, offset, size); return; } log4(OP_READ, offset, size, 0); if (testcalls <= simulatedopcount) return; if (!quiet && ((progressinterval && testcalls % progressinterval == 0) || (fsx_debug && (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, offset, offset + size - 1, size); ret = lseek(fd, (off_t)offset, SEEK_SET); if (ret == (off_t)-1) { prterr("doread: lseek"); report_failure(140); } iret = fsxread(fd, temp_buf, size, offset); if (iret != size) { if (iret == -1) prterr("doread: read"); else prt("short read: 0x%x bytes instead of 0x%x\n", iret, size); report_failure(141); } check_buffers(offset, size); }
void check_clones() { char filename[1024]; char imagename[1024]; int ret, fd; rbd_image_t cur_image; struct stat file_info; while (num_clones > 0) { prt("checking clone #%d\n", num_clones); --num_clones; clone_imagename(imagename, sizeof(imagename), num_clones); if ((ret = rbd_open(ioctx, imagename, &cur_image, NULL)) < 0) { simple_err("check_clones: rbd open", ret); exit(167); } clone_filename(filename, sizeof(filename), num_clones + 1); if ((fd = open(filename, O_RDONLY)) < 0) { simple_err("check_clones: open", -errno); exit(168); } prt("checking image %s against file %s\n", imagename, filename); if ((ret = fstat(fd, &file_info)) < 0) { simple_err("check_clones: fstat", -errno); exit(169); } if ((ret = pread(fd, good_buf, file_info.st_size, 0)) < 0) { simple_err("check_clones: pread", -errno); exit(170); } if ((ret = rbd_read(cur_image, 0, file_info.st_size, temp_buf)) < 0) { simple_err("check_clones: rbd_read", ret); exit(171); } close(fd); check_buffers(0, file_info.st_size); unlink(filename); /* remove the snapshot if it exists, ignore the error from the last clone. */ rbd_snap_unprotect(cur_image, "snap"); rbd_snap_remove(cur_image, "snap"); rbd_close(cur_image); rbd_remove(ioctx, imagename); } }
bool run_1_err_test() { prep_buffers(); uint32_t ecc = ecc_generate(buf1); int byte_idx = rand()%512; int bit_idx = rand()%8; buf2[byte_idx] ^= 0x01 << bit_idx; bool v = ecc_verify(buf2, ecc); if (v) { if (!check_buffers()) { printf("VERIFIED but not FIXED\n"); return false; } } return v; }
int jed_spawn_fg_process (int (*f)(VOID_STAR), VOID_STAR cd) { int status; int inited; if ((Jed_Secure_Mode) || (Jed_Suspension_Not_Allowed)) { msg_error ("Access to shell denied."); return -1; } /* FIXME: X_Suspend_Hook should not be here. Currently, this hook is * used only by GUI jed, where suspension makes no sense. Of course in * this case, spawning a foreground process also does not make sense. */ if (Batch || (X_Suspend_Hook != NULL)) return (*f) (cd); SLsig_block_signals (); inited = Jed_Display_Initialized; SLsig_unblock_signals (); jed_reset_display(); #if !defined(IBMPC_SYSTEM) && !defined(VMS) jed_reset_signals (); #endif reset_tty(); status = (*f) (cd); if (inited) { #if !defined(IBMPC_SYSTEM) && !defined(VMS) init_signals(); #endif if (-1 == init_tty()) { exit_error ("Unable to initialize terminal.", 0); } flush_input (); jed_init_display (); } check_buffers(); return status; }
void doread(unsigned offset, unsigned size) { int ret; offset -= offset % readbdy; if (o_direct) size -= size % readbdy; if (size == 0) { if (!quiet && testcalls > simulatedopcount && !o_direct) prt("skipping zero size read\n"); log4(OP_SKIPPED, OP_READ, offset, size); return; } if (size + offset > file_size) { if (!quiet && testcalls > simulatedopcount) prt("skipping seek/read past end of file\n"); log4(OP_SKIPPED, OP_READ, offset, size); return; } log4(OP_READ, offset, size, 0); if (testcalls <= simulatedopcount) return; if (!quiet && ((progressinterval && testcalls % progressinterval == 0) || (debug && (monitorstart == -1 || (offset + size > monitorstart && (monitorend == -1 || offset <= monitorend)))))) prt("%lu read\t0x%x thru\t0x%x\t(0x%x bytes)\n", testcalls, offset, offset + size - 1, size); ret = ops->read(&ctx, offset, size, temp_buf); if (ret != (int)size) { if (ret < 0) prterrcode("doread: ops->read", ret); else prt("short read: 0x%x bytes instead of 0x%x\n", ret, size); report_failure(141); } check_buffers(good_buf, temp_buf, offset, size); }
/*---------------------------------------------------------------------------*/ static void advanceSlot(struct rtimer *t, void *ptr, int status) { off(TURN_OFF); last = RTIMER_TIME(t); if(!(rtimer_set(t, last + REGULAR_SLOT, 1, (void (*)(struct rtimer *, void *))advanceSlot, NULL) == RTIMER_OK)) { printf("%s\n", "WPI-MAC: Could not schedule task!!!!!"); } if(current_slot == TOTAL_SLOTS + 1) { current_slot = BROADCAST_SLOT; } else { current_slot++; } if(current_slot > (TOTAL_SLOTS - 1)) { current_slot = BROADCAST_SLOT; } //printf("Slot is now %u\n", current_slot); unsigned char somethingToSend = check_buffers(current_slot); if(somethingToSend) { // grab the necessary info from our queue QueuedPacket *curr = QPQueue[current_slot]; real_send(curr->sent, curr->ptr, curr->packet); } else if(current_slot == BROADCAST_SLOT || current_slot == node_id) { // just need to be awake to listen // if(!(rtimer_set(t, last + CONTENTION_PREPARE + (CONTENTION_TICKS * (CONTENTION_SLOTS)), 1, (void (*)(struct rtimer *, void *))async_on, NULL) == RTIMER_OK)){ // printf("%s\n", "Could not schedule task!!!!!"); // } rtimer_clock_t stall = last + CONTENTION_PREPARE + (CONTENTION_TICKS * (CONTENTION_SLOTS)); // printf("STALLLLL: %u %u %u %u\n", RTIMER_NOW(), stall, REGULAR_SLOT, last); while(RTIMER_CLOCK_LT(RTIMER_NOW(), stall)); if(!radio_is_on) on(); } else { // we can snooze if(radio_is_on) off(TURN_OFF); } }
//--------------------------------------------------------------------------- // Function: write_blk // // Parameters: struct ft1000_device - device structure // u16 **pUsFile - DSP image file pointer in u16 // u8 **pUcFile - DSP image file pointer in u8 // long word_length - length of the buffer to be written // to DPRAM // // Returns: STATUS_SUCCESS - success // STATUS_FAILURE - failure // // Description: This function writes a block of DSP image to DPRAM // // Notes: // //--------------------------------------------------------------------------- static u32 write_blk (struct ft1000_device *ft1000dev, u16 **pUsFile, u8 **pUcFile, long word_length) { u32 Status = STATUS_SUCCESS; u16 dpram; int loopcnt, i, j; u16 tempword; u16 tempbuffer[64]; u16 resultbuffer[64]; struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net); //DEBUG("FT1000:download:start word_length = %d\n",(int)word_length); dpram = (u16)DWNLD_MAG1_PS_HDR_LOC; tempword = *(*pUsFile); (*pUsFile)++; Status = ft1000_write_dpram16(ft1000dev, dpram, tempword, 0); tempword = *(*pUsFile); (*pUsFile)++; Status = ft1000_write_dpram16(ft1000dev, dpram++, tempword, 1); *pUcFile = *pUcFile + 4; word_length--; tempword = (u16)word_length; word_length = (word_length / 16) + 1; for (; word_length > 0; word_length--) /* In words */ { loopcnt = 0; for (i=0; i<32; i++) { if (tempword != 0) { tempbuffer[i++] = *(*pUsFile); (*pUsFile)++; tempbuffer[i] = *(*pUsFile); (*pUsFile)++; *pUcFile = *pUcFile + 4; loopcnt++; tempword--; } else { tempbuffer[i++] = 0; tempbuffer[i] = 0; } } //DEBUG("write_blk: loopcnt is %d\n", loopcnt); //DEBUG("write_blk: bootmode = %d\n", bootmode); //DEBUG("write_blk: dpram = %x\n", dpram); if (pft1000info->bootmode == 0) { if (dpram >= 0x3F4) Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 8); else Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 64); } else { for (j=0; j<10; j++) { Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 64); if (Status == STATUS_SUCCESS) { // Work around for ASIC bit stuffing problem. if ( (tempbuffer[31] & 0xfe00) == 0xfe00) { Status = ft1000_write_dpram32(ft1000dev, dpram+12, (u8 *)&tempbuffer[24], 64); } // Let's check the data written Status = ft1000_read_dpram32 (ft1000dev, dpram, (u8 *)&resultbuffer[0], 64); if ( (tempbuffer[31] & 0xfe00) == 0xfe00) { if (check_buffers(tempbuffer, resultbuffer, 28, 0)) { DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n"); msleep(10); Status = STATUS_FAILURE; break; } Status = ft1000_read_dpram32 (ft1000dev, dpram+12, (u8 *)&resultbuffer[0], 64); if (check_buffers(tempbuffer, resultbuffer, 16, 24)) { DEBUG("FT1000:download:DPRAM write failed 2 during bootloading\n"); msleep(10); Status = STATUS_FAILURE; break; } } else { if (check_buffers(tempbuffer, resultbuffer, 32, 0)) { DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n"); msleep(10); Status = STATUS_FAILURE; break; } } if (Status == STATUS_SUCCESS) break; } } if (Status != STATUS_SUCCESS) { DEBUG("FT1000:download:Write failed tempbuffer[31] = 0x%x\n", tempbuffer[31]); break; } } dpram = dpram + loopcnt; } return Status; }
int main( int argc, char *argv[]) { int ret = -1; int world_rank = 0; MPI_Comm comm; PVFS_BMI_addr_t *bmi_peer_array; int *mpi_peer_array; int num_clients; struct bench_options opts; struct mem_buffers mpi_send_bufs; struct mem_buffers mpi_recv_bufs; struct mem_buffers bmi_send_bufs; struct mem_buffers bmi_recv_bufs; enum bmi_buffer_type buffer_type = BMI_EXT_ALLOC; double mpi_time, bmi_time; bmi_context_id context; /* start up benchmark environment */ ret = bench_init(&opts, argc, argv, &num_clients, &world_rank, &comm, &bmi_peer_array, &mpi_peer_array, &context); if (ret < 0) { fprintf(stderr, "bench_init() failure.\n"); return (-1); } /* verify that we didn't get any weird parameters */ if (num_clients > 1 || opts.num_servers > 1) { fprintf(stderr, "Too many procs specified.\n"); return (-1); } /* setup MPI buffers */ ret = alloc_buffers(&mpi_send_bufs, ITERATIONS, opts.message_len); ret += alloc_buffers(&mpi_recv_bufs, ITERATIONS, opts.message_len); if (ret < 0) { fprintf(stderr, "alloc_buffers() failure.\n"); return (-1); } /* setup BMI buffers (differs depending on command line args) */ if (opts.flags & BMI_ALLOCATE_MEMORY) { buffer_type = BMI_PRE_ALLOC; ret = BMI_alloc_buffers(&bmi_send_bufs, ITERATIONS, opts.message_len, bmi_peer_array[0], BMI_SEND); ret += BMI_alloc_buffers(&bmi_recv_bufs, ITERATIONS, opts.message_len, bmi_peer_array[0], BMI_RECV); if (ret < 0) { fprintf(stderr, "BMI_alloc_buffers() failure.\n"); return (-1); } } else { buffer_type = BMI_EXT_ALLOC; ret = alloc_buffers(&bmi_send_bufs, ITERATIONS, opts.message_len); ret += alloc_buffers(&bmi_recv_bufs, ITERATIONS, opts.message_len); if (ret < 0) { fprintf(stderr, "alloc_buffers() failure.\n"); return (-1); } } /* mark all send buffers */ ret = mark_buffers(&bmi_send_bufs); ret += mark_buffers(&mpi_send_bufs); if (ret < 0) { fprintf(stderr, "mark_buffers() failure.\n"); return (-1); } /******************************************************************/ /* Actually measure some stuff */ /* BMI series */ if (world_rank == 0) { ret = bmi_server(&opts, &bmi_recv_bufs, &bmi_send_bufs, bmi_peer_array[0], buffer_type, &bmi_time, context); } else { ret = bmi_client(&opts, &bmi_recv_bufs, &bmi_send_bufs, bmi_peer_array[0], buffer_type, &bmi_time, context); } if (ret < 0) { return (-1); } /* MPI series */ if (world_rank == 0) { ret = mpi_server(&opts, &mpi_recv_bufs, &mpi_send_bufs, mpi_peer_array[0], &mpi_time); } else { ret = mpi_client(&opts, &mpi_recv_bufs, &mpi_send_bufs, mpi_peer_array[0], &mpi_time); } if (ret < 0) { return (-1); } /******************************************************************/ #if 0 if (!(opts.flags & REUSE_BUFFERS)) { /* verify received buffers */ ret = check_buffers(&mpi_recv_bufs); if (ret < 0) { fprintf(stderr, "MPI buffer verification failed.\n"); return (-1); } ret = check_buffers(&bmi_recv_bufs); if (ret < 0) { fprintf(stderr, "BMI buffer verification failed.\n"); return (-1); } } #endif /* print out results */ if (world_rank == 0) { bench_args_dump(&opts); printf("number of iterations: %d\n", ITERATIONS); printf ("all times measure round trip in seconds unless otherwise noted\n"); printf("\"ave\" field is computed as (total time)/iterations\n"); } /* enforce output ordering */ fflush(stdout); MPI_Barrier(MPI_COMM_WORLD); if (world_rank != 0) { printf("%d\t%f\t%f\t(size,total,ave)", bmi_recv_bufs.size, bmi_time, (bmi_time / ITERATIONS)); printf(" bmi server\n"); printf("%d\t%f\t%f\t(size,total,ave)", mpi_recv_bufs.size, mpi_time, (mpi_time / ITERATIONS)); printf(" mpi server\n"); } /* enforce output ordering */ fflush(stdout); MPI_Barrier(MPI_COMM_WORLD); if (world_rank == 0) { printf("%d\t%f\t%f\t(size,total,ave)", bmi_recv_bufs.size, bmi_time, (bmi_time / ITERATIONS)); printf(" bmi client\n"); printf("%d\t%f\t%f\t(size,total,ave)", mpi_recv_bufs.size, mpi_time, (mpi_time / ITERATIONS)); printf(" mpi client\n"); } /* free buffers */ free_buffers(&mpi_send_bufs); free_buffers(&mpi_recv_bufs); if (opts.flags & BMI_ALLOCATE_MEMORY) { BMI_free_buffers(&bmi_send_bufs, bmi_peer_array[0], BMI_SEND); BMI_free_buffers(&bmi_recv_bufs, bmi_peer_array[0], BMI_RECV); } else { free_buffers(&bmi_send_bufs); free_buffers(&bmi_recv_bufs); } /* shutdown interfaces */ BMI_close_context(context); BMI_finalize(); MPI_Finalize(); return 0; }
/* Function that carries out read/write operations */ static int spim_io(const struct spi_slave *slave, struct spim_buffer *first, struct spim_buffer *second) { u32 reg, base; int i, trans_count, ret; struct spim_buffer *transaction[2]; struct img_spi_slave *img_slave = get_img_slave(slave); base = img_slave->base; ret = check_buffers(slave, first, second); if (ret) return ret; /* * Soft reset peripheral internals, this will terminate any * pending transactions */ write32_x(base + SPFI_CONTROL_REG_OFFSET, SPIM_SOFT_RESET_MASK); write32_x(base + SPFI_CONTROL_REG_OFFSET, 0); /* Port state register */ reg = read32_x(base + SPFI_PORT_STATE_REG_OFFSET); reg = spi_write_reg_field(reg, SPFI_PORT_SELECT, slave->cs); write32_x(base + SPFI_PORT_STATE_REG_OFFSET, reg); /* Set transaction register */ reg = transaction_reg_setup(first, second); write32_x(base + SPFI_TRANSACTION_REG_OFFSET, reg); /* Clear status */ write32_x(base + SPFI_INT_CLEAR_REG_OFFSET, 0xffffffff); /* Set control register */ reg = control_reg_setup(first, second); write32_x(base + SPFI_CONTROL_REG_OFFSET, reg); /* First transaction always exists */ transaction[0] = first; trans_count = 1; /* Is there a second transaction? */ if (second) { transaction[1] = second; trans_count++; } /* Now write/read FIFO's */ for (i = 0; i < trans_count; i++) /* Which transaction to execute, "Send" or "Get"? */ if (transaction[i]->isread) { /* Get */ ret = receivedata(slave, transaction[i]->buffer, transaction[i]->size); if (ret) { printk(BIOS_ERR, "%s: Error: receive data failed.\n", __func__); return ret; } } else { /* Send */ ret = transmitdata(slave, transaction[i]->buffer, transaction[i]->size); if (ret) { printk(BIOS_ERR, "%s: Error: transmit data failed.\n", __func__); return ret; } } /* Wait for end of the transaction */ ret = wait_status(base + SPFI_INT_STATUS_REG_OFFSET, SPFI_ALLDONE_SHIFT); if (ret) return ret; /* * Soft reset peripheral internals, this will terminate any * pending transactions */ write32_x(base + SPFI_CONTROL_REG_OFFSET, SPIM_SOFT_RESET_MASK); write32_x(base + SPFI_CONTROL_REG_OFFSET, 0); return SPIM_OK; }
/* This function behaves exactly like read(). The only difference is * that it accepts the gnutls_session_t and the content_type_t of data to * receive (if called by the user the Content is Userdata only) * It is intended to receive data, under the current session. * * The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos. */ ssize_t _gnutls_recv_int (gnutls_session_t session, content_type_t type, gnutls_handshake_description_t htype, opaque * data, size_t sizeofdata) { int decrypted_length; opaque version[2]; content_type_t recv_type; uint16_t length; uint8_t *ciphertext; int ret, ret2; uint16_t header_size; int empty_packet = 0; gnutls_datum_t data_enc, tmp; record_parameters_st *record_params; record_state_st *record_state; ret = _gnutls_epoch_get (session, EPOCH_READ_CURRENT, &record_params); if (ret < 0) { gnutls_assert (); return ret; } /* Safeguard against processing data with an incomplete cipher state. */ if (!record_params->initialized) { gnutls_assert (); return GNUTLS_E_INVALID_REQUEST; } record_state = &record_params->read; if (type != GNUTLS_ALERT && (sizeofdata == 0 || data == NULL)) { return GNUTLS_E_INVALID_REQUEST; } begin: if (empty_packet > MAX_EMPTY_PACKETS_SEQUENCE) { gnutls_assert (); return GNUTLS_E_TOO_MANY_EMPTY_PACKETS; } if (session->internals.read_eof != 0) { /* if we have already read an EOF */ return 0; } else if (session_is_valid (session) != 0 || session->internals.may_not_read != 0) { gnutls_assert (); return GNUTLS_E_INVALID_SESSION; } /* If we have enough data in the cache do not bother receiving * a new packet. (in order to flush the cache) */ ret = check_buffers (session, type, data, sizeofdata); if (ret != 0) return ret; /* default headers for TLS 1.0 */ header_size = RECORD_HEADER_SIZE; if ((ret = _gnutls_io_read_buffered (session, header_size, -1)) != header_size) { if (ret < 0 && gnutls_error_is_fatal (ret) == 0) return ret; session_invalidate (session); if (type == GNUTLS_ALERT) { gnutls_assert (); return 0; /* we were expecting close notify */ } session_unresumable (session); gnutls_assert (); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH; } ret = _mbuffer_linearize (&session->internals.record_recv_buffer); if (ret != 0) { gnutls_assert (); return ret; } _mbuffer_get_first (&session->internals.record_recv_buffer, &data_enc); if ((ret = record_check_headers (session, data_enc.data, type, htype, &recv_type, version, &length, &header_size)) < 0) { gnutls_assert (); return ret; } /* Here we check if the Type of the received packet is * ok. */ if ((ret = check_recv_type (recv_type)) < 0) { gnutls_assert (); return ret; } /* Here we check if the advertized version is the one we * negotiated in the handshake. */ if ((ret = record_check_version (session, htype, version)) < 0) { gnutls_assert (); session_invalidate (session); return ret; } _gnutls_record_log ("REC[%p]: Expected Packet[%d] %s(%d) with length: %d\n", session, (int) _gnutls_uint64touint32 (&record_state->sequence_number), _gnutls_packet2str (type), type, (int) sizeofdata); _gnutls_record_log ("REC[%p]: Received Packet[%d] %s(%d) with length: %d\n", session, (int) _gnutls_uint64touint32 (&record_state->sequence_number), _gnutls_packet2str (recv_type), recv_type, length); if (length > MAX_RECV_SIZE) { _gnutls_record_log ("REC[%p]: FATAL ERROR: Received packet with length: %d\n", session, length); session_unresumable (session); session_invalidate (session); gnutls_assert (); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH; } /* check if we have that data into buffer. */ if ((ret = _gnutls_io_read_buffered (session, header_size + length, recv_type)) != header_size + length) { if (ret < 0 && gnutls_error_is_fatal (ret) == 0) return ret; session_unresumable (session); session_invalidate (session); gnutls_assert (); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH; } /* ok now we are sure that we can read all the data - so * move on ! */ ret = _mbuffer_linearize (&session->internals.record_recv_buffer); if (ret != 0) { gnutls_assert (); return ret; } _mbuffer_get_first (&session->internals.record_recv_buffer, &data_enc); ciphertext = &data_enc.data[header_size]; ret = get_temp_recv_buffer (session, &tmp); if (ret < 0) { gnutls_assert (); return ret; } /* decrypt the data we got. */ ret = _gnutls_decrypt (session, ciphertext, length, tmp.data, tmp.size, recv_type, record_params); if (ret < 0) { session_unresumable (session); session_invalidate (session); gnutls_assert (); return ret; } _mbuffer_remove_bytes (&session->internals.record_recv_buffer, header_size + length); decrypted_length = ret; /* Check if this is a CHANGE_CIPHER_SPEC */ if (type == GNUTLS_CHANGE_CIPHER_SPEC && recv_type == GNUTLS_CHANGE_CIPHER_SPEC) { _gnutls_record_log ("REC[%p]: ChangeCipherSpec Packet was received\n", session); if ((size_t) ret != sizeofdata) { /* sizeofdata should be 1 */ gnutls_assert (); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH; } memcpy (data, tmp.data, sizeofdata); return ret; } _gnutls_record_log ("REC[%p]: Decrypted Packet[%d] %s(%d) with length: %d\n", session, (int) _gnutls_uint64touint32 (&record_state->sequence_number), _gnutls_packet2str (recv_type), recv_type, decrypted_length); /* increase sequence number */ if (_gnutls_uint64pp (&record_state->sequence_number) != 0) { session_invalidate (session); gnutls_assert (); return GNUTLS_E_RECORD_LIMIT_REACHED; } ret = record_check_type (session, recv_type, type, htype, tmp.data, decrypted_length); if (ret < 0) { if (ret == GNUTLS_E_INT_RET_0) return 0; gnutls_assert (); return ret; } /* Get Application data from buffer */ if ((recv_type == type) && (type == GNUTLS_APPLICATION_DATA || type == GNUTLS_HANDSHAKE || type == GNUTLS_INNER_APPLICATION)) { ret = _gnutls_record_buffer_get (type, session, data, sizeofdata); if (ret < 0) { gnutls_assert (); return ret; } /* if the buffer just got empty */ if (_gnutls_record_buffer_get_size (type, session) == 0) { if ((ret2 = _gnutls_io_clear_peeked_data (session)) < 0) { gnutls_assert (); return ret2; } } } else { gnutls_assert (); return GNUTLS_E_UNEXPECTED_PACKET; /* we didn't get what we wanted to */ } /* (originally for) TLS 1.0 CBC protection. * Actually this code is called if we just received * an empty packet. An empty TLS packet is usually * sent to protect some vulnerabilities in the CBC mode. * In that case we go to the beginning and start reading * the next packet. */ if (ret == 0) { empty_packet++; goto begin; } return ret; }
void check_clone(int clonenum) { char filename[128]; char imagename[128]; int ret, fd; struct rbd_ctx cur_ctx = RBD_CTX_INIT; struct stat file_info; char *good_buf, *temp_buf; clone_imagename(imagename, sizeof(imagename), clonenum); if ((ret = ops->open(imagename, &cur_ctx)) < 0) { prterrcode("check_clone: ops->open", ret); exit(167); } clone_filename(filename, sizeof(filename), clonenum + 1); if ((fd = open(filename, O_RDONLY)) < 0) { simple_err("check_clone: open", -errno); exit(168); } prt("checking clone #%d, image %s against file %s\n", clonenum, imagename, filename); if ((ret = fstat(fd, &file_info)) < 0) { simple_err("check_clone: fstat", -errno); exit(169); } good_buf = NULL; ret = posix_memalign((void **)&good_buf, MAX(writebdy, (int)sizeof(void *)), file_info.st_size); if (ret > 0) { prterrcode("check_clone: posix_memalign(good_buf)", -ret); exit(96); } temp_buf = NULL; ret = posix_memalign((void **)&temp_buf, MAX(readbdy, (int)sizeof(void *)), file_info.st_size); if (ret > 0) { prterrcode("check_clone: posix_memalign(temp_buf)", -ret); exit(97); } if ((ret = pread(fd, good_buf, file_info.st_size, 0)) < 0) { simple_err("check_clone: pread", -errno); exit(170); } if ((ret = ops->read(&cur_ctx, 0, file_info.st_size, temp_buf)) < 0) { prterrcode("check_clone: ops->read", ret); exit(171); } close(fd); if ((ret = ops->close(&cur_ctx)) < 0) { prterrcode("check_clone: ops->close", ret); exit(174); } check_buffers(good_buf, temp_buf, 0, file_info.st_size); unlink(filename); free(good_buf); free(temp_buf); }