STATE send_data(uint8_t *packet, int32_t *packet_len, int32_t data_file, int32_t buf_size, int32_t *seq_num) { uint8_t buf[MAX_LEN]; int32_t len_read = 0; len_read = read(data_file, buf, buf_size); switch(len_read) { case -1: perror("send_data, read error"); return DONE; break; case 0: (*packet_len) = send_buf(buf, 1, &server, END_OF_FILE, *seq_num, packet); printf("File Transfer Complete\n"); return DONE; break; default: (*packet_len) = send_buf(buf, len_read, &server, DATA, *seq_num, packet); (*seq_num)++; return WAIT_ON_ACK; break; } }
void child_main(int fd_client) { int recv_len; recv_buf(fd_client,(char*)&recv_len,4);//length char filename[128]=""; recv_buf(fd_client,filename,recv_len); printf("file :%s\n",filename); int fpsend = open(filename,O_RDONLY); if(fpsend == -1) { char nofile[128]="no file\n"; int lenit = strlen(nofile); send(fd_client,(char*)&lenit,4,0); send_buf(fd_client,nofile,lenit); return; } char msg[1024]; int sendlen; while(memset(msg,0,1023),sendlen = read(fpsend,msg,1024)!=0) { send(fd_client,(char *)&sendlen,4,0); send_buf(fd_client,msg,sendlen); } //send 0 to client? }
void downFile(int fd_client, char *name) { send(fd_client, "file", 8, 0); send(fd_client, name, 256, 0); int send_len; char msg[1024]; char file_name[256] = "0"; char dir[256] = "0"; getcwd(dir, sizeof(dir)); sprintf(file_name,"%s/%s",dir, name); name[strlen(file_name) -1] = '\0'; int fd_file = open(file_name, O_RDONLY); if(fd_file == -1){ perror("fd_file fail!\n"); exit(1); } while(memset(&msg, 0, 1024), (send_len = read(fd_file, msg, 1024) ) != 0){ if(send_len == -1){ perror("read\n"); exit(1); } send_buf(fd_client, (char*)&send_len, 4); send_buf(fd_client, msg, send_len); } send_len = 0; send_buf(fd_client, (char*)&send_len, 4); close(fd_file); }
void ClientNetSocket::send() { ASSERT(_peer != INVALID_SOCKET); try { if (_send_message) { _send_pos += send_buf(_send_message->data() + _send_pos, _send_message->size() - _send_pos); if (_send_pos != _send_message->size()) { return; } else { send_message_done(); } } while (!_send_messages.empty()) { _send_message = _send_messages.front(); _send_messages.pop_front(); _send_pos = send_buf(_send_message->data(), _send_message->size()); if (_send_pos != _send_message->size()) { return; } else { send_message_done(); } } } catch (ClientNetSocket::SendException&) { close_and_tell(); } }
void StompStreamSocket::send_line(char* line) { if (line != NULL) { printf("<-- SEND: %s\n", line); send_buf(line, strlen(line)); } send_buf("\n", 1); }
uint8_t SPI_SRAM_23K256_Init(struct ftdi_context *ftdi) { char buf[16]; // 23K256 Write Status to Disable HOLD // enable Chip Select signal buf[0] = SET_BITS_LOW; buf[1] = 0x00; // 0x00 = 0b00000000 ==> CS=Low buf[2] = 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output // MPSSE command to clock data out on +ve edge, in on -ve edge buf[3] = 0x34; buf[4] = 0x01; // sending two bytes, command and data buf[5] = 0x00; buf[6] = 0x01; // Write Status byte to buf[7] = 0x01; // 0x01 ==> Byte Mode with Hold Pin Disabled // disable Chip Select signal buf[8] = SET_BITS_LOW; buf[9] = 0x08; // 0x08 = 0b00001000 ==> CS=High buf[10]= 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output send_buf(ftdi, buf, 11); recv_buf(ftdi, buf, 1); // only one byte is read back sleep(0.1); // 23K256 Read STATUS // enable Chip Select signal buf[0] = SET_BITS_LOW; buf[1] = 0x00; // 0x08 = 0b00000000 ==> CS=Low buf[2] = 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output // MPSSE command to clock data out on +ve edge, in on -ve edge buf[3] = 0x34; buf[4] = 0x01; // sending two bytes, command and data buf[5] = 0x00; buf[6] = 0x05; // read Status byte buf[7] = 0xFF; // force clocking in order to read byte by sending a byte // disable Chip Select signal buf[8] = SET_BITS_LOW; buf[9] = 0x08; // 0x08 = 0b00001000 ==> CS=High buf[10]= 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output send_buf(ftdi, buf, 11); recv_buf(ftdi, buf, 3); if (DEBUG_LEVEL) { printf("Status Byte = 0x%02X\n\n", (uint8_t)buf[2]); } return (uint8_t)buf[2]; }
int send_message(int fd, struct metadata_update *msg, int tmo) { __s32 len = msg->len; int rv; rv = send_buf(fd, &start_magic, 4, tmo); rv = rv ?: send_buf(fd, &len, 4, tmo); if (len > 0) rv = rv ?: send_buf(fd, msg->buf, msg->len, tmo); rv = send_buf(fd, &end_magic, 4, tmo); return rv; }
static int send_optional_header(struct ploop_copy_handle *copy_h) { int ret; struct ploop_pvd_header *vh; size_t block_size; struct ploop_pvd_ext_block_check *hc; struct ploop_pvd_ext_block_element_header *h; __u8 *block = NULL, *data; vh = (struct ploop_pvd_header *)copy_h->idelta.hdr0; block_size = vh->m_Sectors * SECTOR_SIZE; if (p_memalign((void **)&block, 4096, block_size)) return SYSEXIT_MALLOC; hc = (struct ploop_pvd_ext_block_check *)block; h = (struct ploop_pvd_ext_block_element_header *)(hc + 1); data = (__u8 *)(h + 1); h->magic = EXT_MAGIC_DIRTY_BITMAP; ret = save_dirty_bitmap(copy_h->devfd, ©_h->idelta, copy_h->eof_offset, data, &h->size, NULL, cbt_writer, copy_h); if (ret) { if (ret == SYSEXIT_NOCBT) ret = 0; goto out; } vh->m_DiskInUse = SIGNATURE_DISK_CLOSED_V21; vh->m_FormatExtensionOffset = (copy_h->eof_offset + SECTOR_SIZE - 1) / SECTOR_SIZE; if (send_buf(copy_h, vh, sizeof(*vh), 0)) { ploop_err(errno, "Can't write header"); ret = SYSEXIT_WRITE; goto out; } ploop_log(3, "Send extension header offset=%llu size=%d", vh->m_FormatExtensionOffset * SECTOR_SIZE, h->size); hc->m_Magic = FORMAT_EXTENSION_MAGIC; MD5((const unsigned char *)(hc + 1), block_size - sizeof(*hc), hc->m_Md5); if (send_buf(copy_h, block, block_size, vh->m_FormatExtensionOffset * SECTOR_SIZE)) { ploop_err(errno, "Can't write optional header"); ret = SYSEXIT_WRITE; goto out; } out: free(block); return ret; }
int SendMailFile (FILE *in) { char szBuffer[513]; int _read_resp = 1; while (!feof (in)) { int buf_len; if (!fgets (szBuffer, sizeof (szBuffer), in)) continue; buf_len = strlen (szBuffer); while (buf_len > 0 && isspace (szBuffer[buf_len - 1])) { szBuffer[buf_len - 1] = 0; buf_len--; } fprintf (stdout, "%s\n", szBuffer); if (0 == strnicmp (szBuffer, "DATA", 4)) { if (0 > send_buf ("%s\r\n", szBuffer)) goto error; if (0 > read_resp (stdout)) goto error; _read_resp = 0; } else if (0 == strcmp (szBuffer, ".")) { if (0 > send_buf ("%s\r\n", szBuffer)) goto error; if (0 > read_resp (stdout)) goto error; _read_resp = 1; } else { if (0 > send_buf ("%s\r\n", szBuffer)) goto error; if (_read_resp) if (0 > read_resp (stdout)) goto error; }; }; return TRUE; error: return FALSE; }
static void *sender_thread(void *data) { struct ploop_copy_handle *h = data; struct sender_data *sd = &h->sd; int done; pthread_mutex_lock(&sd->mutex); ploop_dbg(3, "start sender_thread"); pthread_barrier_wait(&sd->barrier); do { pthread_cond_wait(&sd->cond, &sd->mutex); wakeup(&sd->wait_mutex, &sd->wait_cond); sd->ret = send_buf(h, sd->buf, sd->len, sd->pos); if (sd->ret) sd->err_no = errno; done = (sd->len == 0 && sd->pos == 0); } while (!done); pthread_mutex_unlock(&sd->mutex); ploop_log(3, "send_thread exited ret=%d", sd->ret); return NULL; }
void SPI_SRAM_23K256_Write_Byte(struct ftdi_context *ftdi, uint16_t address, uint8_t data) { char buf[16]; uint8_t bytesToTransfer = 4; // enable Chip Select signal buf[0] = SET_BITS_LOW; buf[1] = 0x00; // 0x00 = 0b00000000 ==> CS=Low buf[2] = 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output // MPSSE command to clock data out on +ve edge, in on -ve edge buf[3] = 0x34; buf[4] = (bytesToTransfer - 1); // will be transferring 4 bytes so length=3 buf[5] = 0x00; buf[6] = 0x02; // write buf[7] = (uint8_t)(address >> 8); // address high byte buf[8] = (uint8_t)(address); // address low byte buf[9] = data; // force clocking in order to read byte by sending a byte // disable Chip Select signal buf[10]= SET_BITS_LOW; buf[11]= 0x08; // 0x08 = 0b00001000 ==> CS=High buf[12]= 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output send_buf(ftdi, buf, 13); recv_buf(ftdi, buf, bytesToTransfer); // same as number that will be transferred if (DEBUG_LEVEL) { printf("Byte written to address 0x%04X = 0x%02X\n\n", address, data); } }
STATE filename(char *fname, int32_t buf_size) { uint8_t packet[MAX_LEN]; uint8_t buf[MAX_LEN]; uint8_t flag = 0; int32_t seq_num = 0; int32_t fname_len = strlen(fname) + 1; int32_t recv_check = 0; memcpy(buf, &buf_size, 4); memcpy(&buf[4], fname, fname_len); send_buf(buf, fname_len + 4, &server, FNAME, 0, packet); if (select_call(server.sk_num, 1, 0, NOT_NULL) == 1) { recv_check = recv_buf(packet, 1000, server.sk_num, &server, &flag, &seq_num); /* check for bit flip ... if so, send the file name again */ if (recv_check == CRC_ERROR) return FILENAME; if (flag == FNAME_BAD) { printf("File %s already exists and is write-protected\n", fname); return DONE; } return FILE_OK; } return FILENAME; }
/******************************************************************************* * Function Name : send * Description : Send the protocol package via the socket. * Input : socket - the socket connection * pack - the protocol package to be sent * Output : None * Return : If no error occurs, send returns the total number of bytes sent, * which can be less than the number requested to be sent in the len parameter. * Otherwise, a value of SOCKET_ERROR is returned *******************************************************************************/ int Protocol::send(SOCKET socket, const ProtocolPackage& pack){ //calculate the length of body unsigned int body_len = (unsigned char)pack.header.length[0] | (unsigned char)pack.header.length[1] << 8; //calculate the length of entire package int len = ProtocolHeader::SIZE + body_len + strlen(ProtocolPackage::EOP); //allocate the memory boost::shared_ptr<char> send_buf(new char[len], boost::checked_array_deleter<char>()); char* pSendBuf = send_buf.get(); //assign the header pSendBuf[0] = pack.header.mode; pSendBuf[1] = pack.header.type; pSendBuf[2] = pack.header.seq; pSendBuf[3] = pack.header.reserved; pSendBuf[4] = pack.header.pin[0]; pSendBuf[5] = pack.header.pin[1]; pSendBuf[6] = pack.header.pin[2]; pSendBuf[7] = pack.header.pin[3]; pSendBuf[8] = pack.header.pin[4]; pSendBuf[9] = pack.header.pin[5]; pSendBuf[10] = pack.header.length[0]; pSendBuf[11] = pack.header.length[1]; //assign the body for(unsigned int i = 0; i < body_len; i++){ pSendBuf[ProtocolHeader::SIZE + i] = pack.body[i]; } //assign the EOP for(unsigned int i = 0; i < strlen(ProtocolPackage::EOP); i++){ pSendBuf[ProtocolHeader::SIZE + body_len + i] = *(ProtocolPackage::EOP + i); } //send the printer login buffer return ::send(socket, pSendBuf, len, 0); }
int8_t nativenet_send(radio_packet_t *packet) { packet->src = _native_net_addr; DEBUG("nativenet_send: Sending packet of length %" PRIu16 " from %" PRIu16 " to %" PRIu16 "\n", packet->length, packet->src, packet->dst); return send_buf(packet); }
std::vector<uint8_t> Datagram_Handshake_IO::format_fragment(const uint8_t fragment[], size_t frag_len, uint16_t frag_offset, uint16_t msg_len, Handshake_Type type, uint16_t msg_sequence) const { std::vector<uint8_t> send_buf(12 + frag_len); send_buf[0] = static_cast<uint8_t>(type); store_be24(&send_buf[1], msg_len); store_be(msg_sequence, &send_buf[4]); store_be24(&send_buf[6], frag_offset); store_be24(&send_buf[9], frag_len); if (frag_len > 0) { copy_mem(&send_buf[12], fragment, frag_len); } return send_buf; }
void CRClient::sendIOtoRenderer (std::string io) { boost::shared_ptr<std::string> send_buf(new std::string(io)); rsocket.async_send_to(boost::asio::buffer(*send_buf), renderer_endpoint, boost::bind(&CRClient::handle_rsend, this, send_buf, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); }
static int cbt_writer(void *data, const void *buf, int len, off_t pos) { struct ploop_copy_handle *h = (struct ploop_copy_handle *)data; h->eof_offset += len; return send_buf(h, buf, len, pos); }
int main (int argc,char **argv){ struct sockaddr_in server; struct fgetinfo *p1; struct finfo p4; char buffer[10000]; FILE *foutfd; char host[1000],fin[FILENAME_MAX],fout[FILENAME_MAX]; int sock,port,connected,retval; parse(argc,argv,host,&port,fin,fout); /* PRINT PARSED ARGUMENTS */ printf("Port %i<--\n",port); printf("Server %s<--\n",host); start_client(&sock,&server,port,host); printf("Starting communication\n\n"); p1=get_info(fin); // Try to open out file if((foutfd=(FILE *)fopen(fout,"wb"))==NULL){ printf("Out file could't be created or truncated for writing\n"); exit(1); } connected=0; while (connected<3){ connected++; send_buf(sock,&server,p1,sizeof(*p1)); print_fgetinfo(*p1); if(receive(sock,buffer,sizeof(buffer))==0){ memcpy(&p4,buffer,sizeof(p4)); if(!check_finfo(p4)){ connected=4; print_finfo(p4); if (p4.file_exist==1){ // Start transfer retval=transfer(sock,&server,p4.file_id,foutfd,p4.file_size); fclose(foutfd); // Show transfer result exit(retval); } else{ printf("\nERROR: Requested file does not exist on server\n\n"); exit(1); } } } } if (connected==3){ printf("\nERROR: Server not responding\n\n"); exit(1); } exit (0); }
static void get_send_irg(void) { int i; for(i = 0; i < MAX_PORT; i++) { if(UART_GET_WST(i) & (i%8)) { send_buf(&serial_devp[i]); } } }
uint8_t nativenet_send(radio_packet_t *packet) { packet->src = _native_net_addr; DEBUG("nativenet_send: Sending packet of length %"PRIu16" from %"PRIu16" to %"PRIu16"\n", packet->length, packet->src, packet->dst); if (send_buf(packet) == -1) { warnx("nativenet_send: error sending packet"); return 0; } return true; }
int HTTP::download(ParsedLink link) { s.reset(); if(s.sock_create() == ERROR_FAIL) return ERROR_FAIL; DWORD address; if(get_address((char*)link.host.c_str(),&address) == ERROR_FAIL) return ERROR_FAIL; if(s.sock_connect(address,link.port) == ERROR_FAIL) return ERROR_FAIL; std::unique_ptr<char> send_buf(new char[2048]); int count = 0; count += sprintf(send_buf.get() + count,"GET %s HTTP/1.1\r\n",link.request.c_str()); count += sprintf(send_buf.get() + count,"Host: %s\r\n",link.host.c_str()); count += sprintf(send_buf.get() + count,"User-agent: Crawler-ke-wang-1.2\r\n"); count += sprintf(send_buf.get() + count,"Connection: close\r\n"); count += sprintf(send_buf.get() + count,"\r\n"); send_buf.get()[count] = '\0'; if(!s.sock_send(send_buf.get(),count)) return ERROR_FAIL; if(!s.sock_recv()) return ERROR_FAIL; try { if((head_start = s.get_header()) == NULL) return ERROR_FAIL; if((head_size = s.get_header_size()) == -1) return ERROR_FAIL; if((body_start = s.get_body()) == NULL) return ERROR_FAIL; if((body_size = s.get_body_size()) == -1) return ERROR_FAIL; } catch(...) { return ERROR_FAIL; } full_size = s.get_full_size(); local_stat.download_size += full_size; if(!s.close()) return ERROR_FAIL; return ERROR_SUCCESS; }
ssize_t mtcp_send_message(mtcp_state *pmts, const void *buf, size_t len) { int blocking; ssize_t result; blocking = mtcp_get_block_state(pmts); if (blocking < 0) { return blocking; } if (pmts->lenbufpos < 4) { if (pmts->lenbufpos == 0) { *(uint32_t*)pmts->lenbuf = htonl(len); } result = send_buf(pmts->sock, pmts->lenbuf, &pmts->lenbufpos, 4, blocking); if (result <= 0) { return result; } } result = send_buf(pmts->sock, buf, &pmts->bufpos, len, blocking); return result; }
int main(void) { uint8_t command; serial_init(); trigger_setup(); aes_setup(); #ifdef DELAYS random_setup(); #endif while(1) { command = usart_recv_byte(); switch(command) { case 'e': fill_buf(); random_setup(); encrypt(); send_buf(); break; case 'd': fill_buf(); random_setup(); decrypt(); send_buf(); break; default: continue; } } return 0; }
static int send_str (SOCKET s, ...) { va_list ap; char *p; int ret; size_t len; va_start (ap, s); p = vstrmake (&len, ap); va_end (ap); if (!p) return 1; ret = send_buf (s, p, len); heap_free (p); return ret; }
void ParallelBFS::calculate(NodeId root) { distance.assign((size_t) vertex_count, infinity); NodeId level = 1; NodeList frontier; frontier.reserve((size_t)vertex_count); if (comm.rank() == find_owner(root)) { frontier.push_back(root - first_vertex); distance[root - first_vertex] = 0; } std::vector<NodeList> send_buf((size_t)comm.size()); NodeList new_frontier; NodeList sizes((size_t)comm.size()), displacements((size_t)comm.size()); while (mpi::all_reduce(comm, (NodeId)frontier.size(), std::plus<NodeId>()) > 0) { for (NodeId u : frontier) for (int e = vertices[u]; e < vertices[u + 1]; ++e) { int v = edges[e]; send_buf[find_owner(v)].push_back(v); } for (int i = 0; i < comm.size(); ++i) { mpi::gather(comm, (NodeId)send_buf[i].size(), sizes.data(), i); if (i == comm.rank()) { for (int j = 1; j < comm.size(); ++j) displacements[j] = displacements[j - 1] + sizes[j - 1]; new_frontier.resize( (size_t)(displacements[comm.size()-1] + sizes[comm.size() - 1])); mpi::gatherv(comm, send_buf[i], new_frontier, sizes, displacements, i); } else { mpi::gatherv(comm, send_buf[i], i); } } for (size_t i = 0; i < comm.size(); ++i) send_buf[i].clear(); frontier.clear(); for (int v : new_frontier) { v -= first_vertex; if (distance[v] == infinity) { distance[v] = level; frontier.push_back(v); } } ++level; } }
static ssize_t send_data(int fd, const char *fmt, ...) { char buf[REMOTE_BUF_SIZE]; va_list ap; int ret; if (verbose) dbg("called %s(fd, \"%s\", ...)", __FUNCTION__, fmt); va_start(ap, fmt); ret = __prepare_data(buf, sizeof(buf), fmt, ap); va_end(ap); if (ret < 0) return ret; return send_buf(fd, buf, ret); }
void RDMACMSocket::setup_verbs_buf() { this->verbs_buf = Buffer::allocate(PACKET_SIZE * PACKET_WINDOW_SIZE * 2); this->verbs_mr = rdma_reg_msgs(this->client_id, this->verbs_buf.addr, this->verbs_buf.size); if (this->verbs_mr == NULL) { this->verbs_buf.free(); rdma_destroy_ep(this->client_id); perror("rdma_reg_msgs"); exit(1); } char* send_buf_begin = this->verbs_buf.addr + PACKET_SIZE * PACKET_WINDOW_SIZE; for (int i = 0; i < PACKET_WINDOW_SIZE; ++i) { Buffer recv_buf(this->verbs_buf.addr + i * PACKET_SIZE, PACKET_SIZE); post_recv(recv_buf); Buffer send_buf(send_buf_begin + i * PACKET_SIZE, PACKET_SIZE); send_bufs.push_back(send_buf); } }
/** @brief Dump general infos * * Reply fields: * - ROID (u8) * - SPM_PAGESIZE value (u16) * - supported features (SZ) * - supported commands (SZ) * * Supported features are: * - \c U if UART is enabled * - \c S if I2C (as slave) is enabled * - \c C if CRC check while programming is enabled * * @todo Return bitmasks, not strings. */ static void cmd_infos(void) { static const uint8_t infos_buf[] = { ROID, SPM_PAGESIZE&0xff, (SPM_PAGESIZE>>8)&0xff, // features #ifndef DISABLE_PROG_CRC 'C', #endif #ifdef ENABLE_UART 'U', #endif #ifdef ENABLE_I2C_SLAVE 'S', #endif 0, // commands 'i', 0xff, 'm', // commands which cannot be disabled #ifndef DISABLE_EXECUTE 'x', #endif #ifndef DISABLE_PROG_PAGE 'p', #endif #ifndef DISABLE_MEM_CRC 'c', #endif #ifndef DISABLE_FUSE_READ 'f', #endif #ifndef DISABLE_COPY_PAGES 'y', #endif #ifdef ENABLE_I2C_MASTER '<', '>', #endif 0 }; reply_success(sizeof(infos_buf)); send_buf(infos_buf, sizeof(infos_buf)); }
void CRClient::connectRenderer () { udp::resolver::query query(udp::v4(), renderer_ip.c_str(), renderer_port.c_str()); renderer_endpoint = *rresolver.resolve(query); rsocket.open(udp::v4()); rlisten (); //io_service.run(); char conn = CONNECT; boost::shared_ptr<std::string> send_buf(new std::string(&conn)); // while (!connection) { rsocket.async_send_to(boost::asio::buffer(*send_buf), renderer_endpoint, boost::bind(&CRClient::handle_rsend, this, send_buf, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); // } std::cout << "Renderer Connection status " << connection << std::endl; run(); }
static void *send_thread(void *data) { struct send_data *sd = data; int done; pthread_mutex_lock(&sd->mutex); do { while (!sd->has_data) { pthread_cond_wait(&sd->cond, &sd->mutex); } sd->ret = send_buf(sd->fd, sd->buf, sd->len, sd->pos, sd->is_pipe); if (sd->ret) sd->err_no = errno; done = (sd->len == 0 && sd->pos == 0); sd->has_data = 0; pthread_cond_signal(&sd->cond_sent); } while (!done); pthread_mutex_unlock(&sd->mutex); return NULL; }