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