/* Send a file. * Returns: * 0 OK * -1 error * -2 daemon cancelled (we must read the error message) */ int guestfs___send_file (guestfs_h *g, const char *filename) { char buf[GUESTFS_MAX_CHUNK_SIZE]; int fd, r = 0, err; g->user_cancel = 0; fd = open (filename, O_RDONLY|O_CLOEXEC); if (fd == -1) { perrorf (g, "open: %s", filename); send_file_cancellation (g); return -1; } fadvise_sequential (fd); /* Send file in chunked encoding. */ while (!g->user_cancel) { r = read (fd, buf, sizeof buf); if (r == -1 && (errno == EINTR || errno == EAGAIN)) continue; if (r <= 0) break; err = send_file_data (g, buf, r); if (err < 0) { if (err == -2) /* daemon sent cancellation */ send_file_cancellation (g); close (fd); return err; } } if (r == -1) { perrorf (g, "read: %s", filename); send_file_cancellation (g); close (fd); return -1; } if (g->user_cancel) { error (g, _("operation cancelled by user")); g->last_errnum = EINTR; send_file_cancellation (g); close (fd); return -1; } /* End of file, but before we send that, we need to close * the file and check for errors. */ if (close (fd) == -1) { perrorf (g, "close: %s", filename); send_file_cancellation (g); return -1; } return send_file_complete (g); }
void StatusResMsg:: send_file_payload(int sockfd, char* homeDir) { char msg_data[22 + hostInfoLen]; memset(msg_data, 0, 22 + hostInfoLen); memcpy(msg_data, UOID, 20); memcpy(msg_data + 20, &htons(hostInfoLen), 2); memcpy(msg_data + 22, &htons(hostPort), 2); memcpy(msg_data + 24, hostname, hostInfoLen - 2); if(send(sockfd, msg_data, 22 + hostInfoLen, 0) == -1) { printf("Server: client close socket to server\n"); exit(1); } for(size_t i = 0; i < recordLengths.size(); i++) { uint32_t recordLen = recordLengths[i]; uint32_t file_index = fileIndexes[i]; char msg_recordLen[4]; memset(msg_recordLen, 0, 4); memcpy(msg_recordLen, &htonl(recordLen), 4); if(send(sockfd, msg_recordLen, 4, 0) == -1) { printf("Server: client close socket to server\n"); exit(1); } if(fileState) //fileState = true means this file is in tempMeta directory { char tempMetaDataFileName[256]; memset(tempMetaDataFileName, 0, 256); create_tempMetaDataFilename(tempMetaDataFileName, homeDir, file_index); send_file_data(sockfd, tempMetaDataFileName, recordLen); remove(tempMetaDataFileName); } else { char metaDataFileName[256]; memset(metaDataFileName , 0, 256); create_metaDataFilename(metaDataFileName, homeDir, file_index); send_file_data(sockfd, metaDataFileName, recordLen); } } }
static void send_file_block(int para) { uint8_t buf[200]; cfs_seek(_f_reader.read_fd, _f_reader.read_cursor, CFS_SEEK_SET); _f_reader.sent_bytes = cfs_read(_f_reader.read_fd, buf, sizeof(buf)); send_file_data(para, buf, _f_reader.sent_bytes, send_file_callback, para); log_info("send_file_block(%d), %d, %d\n", para, _f_reader.sent_bytes, _f_reader.read_cursor); }
void do_file_senders(Tox *m) { int i; for (i = 0; i < max_file_senders_index; ++i) { if (!file_senders[i].active) continue; if (file_senders[i].queue_pos > 0) { --file_senders[i].queue_pos; continue; } ToxWindow *self = file_senders[i].toxwin; char *filename = file_senders[i].filename; int filenum = file_senders[i].filenum; int32_t friendnum = file_senders[i].friendnum; /* kill file transfer if chatwindow is closed */ if (self->chatwin == NULL) { close_file_sender(self, m, i, NULL, TOX_FILECONTROL_KILL, filenum, friendnum); continue; } /* If file transfer has timed out kill transfer and send kill control */ if (timed_out(file_senders[i].timestamp, get_unix_time(), TIMEOUT_FILESENDER)) { char msg[MAX_STR_SIZE]; snprintf(msg, sizeof(msg), "File transfer for '%s' timed out.", filename); close_file_sender(self, m, i, msg, TOX_FILECONTROL_KILL, filenum, friendnum); sound_notify(self, error, NT_NOFOCUS | NT_WNDALERT_2, NULL); if (self->active_box != -1) box_notify2(self, error, NT_NOFOCUS | NT_WNDALERT_2, self->active_box, "%s", msg); else box_notify(self, error, NT_NOFOCUS | NT_WNDALERT_2, &self->active_box, self->name, "%s", msg); continue; } send_file_data(self, m, i, friendnum, filenum, filename); file_senders[i].queue_pos = num_active_file_senders - 1; } }
void kermit_send(int fd_out, int fd_in, char *file_list[], int list_size) { unsigned char buffer[0x64], response[0x64]; unsigned char len, seq; int i, file, response_length; char *ptr; tabel = tabelcrc(CRCCCITT); seq = 0; init_alarm(); me.maxl = 79; me.time = 3; me.npad = 0; me.padc = 0x00; me.eol = '\r'; me.qctl = '#'; me.qbin = '&'; me.chkt = '1'; me.rept = '~'; len = 9 + 4; set_settings(buffer, me); set_hf_send_packet(fd_out, fd_in, buffer, len, &seq, 'S', response, &response_length); get_settings(response, &you); for(i = 0; i < list_size; i++) { file = open(file_list[i], O_RDONLY); if(file == -1) { fprintf(stderr, "sender: the file %s could not be opened\n", file_list[i]); continue; } ptr = strrchr(file_list[i], '/'); if(ptr == NULL) { len = strlen(file_list[i]); memcpy(buffer + 4, file_list[i], len); } else { len = strlen(ptr + 1); memcpy(buffer + 4, ptr + 1, len); } len += 4; set_hf_send_packet(fd_out, fd_in, buffer, len, &seq, 'F', response, &response_length); fprintf(stderr, "sender: sending file %s\n", file_list[i]); send_file_data(fd_out, fd_in, file, &seq); len = 4; set_hf_send_packet(fd_out, fd_in, buffer, len, &seq, 'Z', response, &response_length); close(file); } len = 4; set_hf_send_packet(fd_out, fd_in, buffer, len, &seq, 'B', response, &response_length); free(tabel); }
/* * This will handle connection for each client * */ void *client_handler(void *socketDescriptor){ // Get the socket descriptor int newSocket = *(int*) socketDescriptor; int readSize; char *message, *realMessage, clientMessage[2000]; int quit; struct message_s recv_message, send_message; int connected, authenticated; FILE *fb; char target_filename[1024]; char directory[1024 + 10]; authenticated = 0; connected = 0; quit = 0; while (quit == 0){ // Get message from client memset(recv_message.payload, '\0', 1024); readSize = recv(newSocket, (char *)&recv_message, sizeof(struct message_s), 0); // Print type, for debugging printf("recv_message.type is %x\n", recv_message.type); // Analyze message switch( recv_message.type ){ /******************************** * Handle OPEN_CONN_REQUEST * ********************************/ case (char) 0xA1: printf("Server - OPEN_CONN_REQUEST received\n"); send_open_conn_reply(newSocket); printf("Server - OPEN_CONN_REPLY sent\n"); connected = 1; break; /******************************** * Handle AUTH_REQUEST * ********************************/ case (char) 0xA3: printf("Server - AUTH_REQUEST received\n"); recv_message.payload[recv_message.length-5] = '\0'; printf("Server - Authenticating: %s\n",recv_message.payload); authenticated = check_auth(recv_message.payload); send_auth_reply(newSocket, check_auth(recv_message.payload)); printf("Server - AUTH_REPLY sent\n"); if( authenticated == 1) printf("\t(Server - Access Granted)\n"); else printf("\t(Server - Access Failed)\n"); break; /******************************** * Handle LIST_REQUEST * ********************************/ case (char) 0xA5: printf("Server - LIST_REQUEST received\n"); if (authenticated) { list_dir_send_list_reply(newSocket); printf("Server - LIST_REPLY sent\n"); } else { strcpy(send_message.payload, "Server - You are not authenticated!\n"); send_message.length = 12 + strlen(send_message.payload); while( send(newSocket, (char*)(&send_message),send_message.length, 0) != send_message.length ); } break; /******************************** * Handle GET_REQUEST * ********************************/ case (char) 0xA7: if (authenticated) { strncpy(target_filename, recv_message.payload,recv_message.length-12); target_filename[recv_message.length-12] = '\0'; printf("target filename: %s\n", target_filename); printf("GET_REQUEST: %s\n", recv_message.payload); strcpy(directory, "./filedir/"); strcat(directory, target_filename); if(fb = fopen(directory, "rb"), fb != NULL){ printf("Server - File found.\n"); printf("directory: %s\n", directory); send_get_reply(newSocket, 1); printf("GET_REPLY Sent!\n"); sleep(1); send_file_data(newSocket, fb); fclose(fb); } else { printf("Error: Server - File does not exist.\n"); send_get_reply(newSocket, 0); printf("GET_REPLY Sent\n"); } } else { strcpy(send_message.payload, "Server - You are not authenticated!\n"); send_message.length = 12 + strlen(send_message.payload); while( send(newSocket, (char*)(&send_message),send_message.length, 0) != send_message.length ); } break; /******************************** * Handle PUT_REQUEST * ********************************/ case (char) 0xA9: if (authenticated){ strncpy(target_filename, recv_message.payload,recv_message.length-12); target_filename[recv_message.length-12] = '\0'; printf("target filename: %s\n", target_filename); printf("PUT_REQUEST: %s\n", recv_message.payload); printf("PUT_REQUEST Received\n"); strcpy(directory, "./filedir/"); strcat(directory, target_filename); memset(send_message.payload, '\0', 1024); send_message.protocol[0] = 0xe3; strcat(send_message.protocol, "myftp"); send_message.type = 0xAA; send_message.length = 12; send(newSocket, (char*)(&send_message), send_message.length, 0); printf("PUT_REPLY Sent\n"); recv_file_data(newSocket, directory); } else { strcpy(send_message.payload, "Server - You are not authenticated!\n"); send_message.length = 12 + strlen(send_message.payload); while( send(newSocket, (char*)(&send_message),send_message.length, 0) != send_message.length ); } break; /******************************** * Handle QUIT_REQUEST * ********************************/ case (char) 0xAB: printf("Disconnecting by request. (socket: %d)\n", newSocket); send_message.protocol[0] = 0xe3; strcat(send_message.protocol, "myftp"); send_message.type = 0xAC; send_message.length = 12; while( send(newSocket, (char*)(&send_message),send_message.length, 0) !=12 ); close(newSocket); quit = 1; break; /* Invalid Protocol */ default: printf("Error: Server - Invalid Protocol Received"); quit = 1; break; } } puts("Client disconnected"); fflush(stdout); // Free the socket pointer free(socketDescriptor); printf("ending thread\n"); pthread_exit(NULL); }
void send_thread(void *args) { transfer_session *session; file_desc *f_desc; file_block_desc *b_desc; file_frame_data *file_frame; frame_index *f_index; frame_header *f_header; block_sent_frame bs; int qid; q_msg f_msg; int err; int frame_len = 0, len = 0, blk_count = 0; unsigned short b_index = 0; char buf_send[2061]; #if DEBUG char test[10]; FILE *fp; fp = fopen("receive.txt", "w"); #endif struct timeval start; struct timeval end; float time_used; char started = 0; int send_count = 0; int ret_val = 0; session = (transfer_session *)args; f_desc = session->f_desc; blk_count = f_desc->block_count; frame_block_sent_init(&bs); if((qid = session->data_qid) < 0) { printf("msg q error"); return; } frame_header_init(FRAME_TYPE_DATA, FRAME_DATA_MONITOR, &f_header); for(;;) { if (session->state != STATE_TRANSFER) { /* free the packages in the queue */ while(recv_msg_q(qid, &f_msg, sizeof(q_msg),\ MSG_TYPE_FILE_FRAME, IPC_NOWAIT) >= 0) { file_frame = (file_frame_data *)(f_msg.msg_buf.data); t_free(file_frame); } //t_free(f_header); //return; sleep(1); continue; } /* get frame from msg q */ if ((err = recv_msg_q(qid, &f_msg, sizeof(q_msg),\ MSG_TYPE_FILE_FRAME, IPC_NOWAIT)) < 0) { /* no msg in the queue, assum sending finished */ if(started) { gettimeofday(&end,NULL); time_used = (end.tv_sec - start.tv_sec) * 1000000\ + (end.tv_usec - start.tv_usec); time_used /= 1000000; printf("send_time_used = %f s\n", time_used); printf("send_frame_count = %d \n", send_count); send_count = 0; started = 0; } sleep(1); continue; } if(0 == started) { gettimeofday(&start, NULL); started = 1; } file_frame = (file_frame_data *)(f_msg.msg_buf.data); b_index = file_frame->block_index; /* encapusulate frame */ file_frame->file_id = HTONS(file_frame->file_id); file_frame->block_index = HTONS(file_frame->block_index); file_frame->frame_index = HTONS(file_frame->frame_index); //printf("send data block:%d, frame:%d\n", HTONS(file_frame->block_index), HTONS(file_frame->frame_index)); frame_len = frame_build(f_header, file_frame, sizeof(file_frame_data), buf_send); if(f_msg.msg_buf.data_len < FILE_FRAME_SIZE) { ((frame_header *)buf_send)->length = HTONS(f_msg.msg_buf.data_len + 11); frame_crc_gen((frame_header *)buf_send, (unsigned char *)buf_send + 6,\ f_msg.msg_buf.data_len + 6); } /* send file data frame */ ret_val = send_file_data(session, buf_send, f_msg.msg_buf.data_len + 13); if(ret_val < 0) { printf("return value:%d.\n", ret_val); perror("send to!"); } send_count++; if(!f_desc->frame_remain) { t_free(file_frame); continue; } f_desc->frame_remain[b_index - 1]--; if(f_desc->frame_remain[b_index - 1] == 0) { bs.file_id = HTONS(f_desc->file_id); bs.block_index = file_frame->block_index; frame_crc_gen(&(bs.f_header), (unsigned char*)(&bs.file_id), 4); if ((len = send(session->fd, (char *)(&bs), sizeof(block_sent_frame), 0))\ != sizeof(block_sent_frame)) { printf("send socket finished failed.\n"); session->state = STATE_CONN_LOST; t_free(file_frame); continue; } printf("block:%d has send completed.\n", HTONS(bs.block_index)); /* if all count have been sent, tansfer finished */ //blk_count--; //if(blk_count == 0) // session->state = STATE_TRANSFER_FIN; } /* free the data after send */ t_free(file_frame); } t_free(f_header); }