diff --git a/.gitignore b/.gitignore index cd531cf..d119bc8 100644 --- a/.gitignore +++ b/.gitignore @@ -52,3 +52,6 @@ Module.symvers Mkfile.old dkms.conf +#Bin +bin/* + diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..728bda3 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "C_Cpp.default.defines": ["_GNU_SOURCE"] +} \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5405da0 --- /dev/null +++ b/Makefile @@ -0,0 +1,17 @@ +CC = gcc +CFLAGS = -lm -Wall -O2 + +all: + make client + make server + +socket_wrapper.o: socket_wrapper.c socket_wrapper.h + $(CC) -c socket_wrapper.c -o socket_wrapper.o $(CFLAGS) + +client: socket_wrapper.o client.c + $(CC) -o client client.c socket_wrapper.o $(CFLAGS) +server: + $(CC) -o server server.c socket_wrapper.o $(CFLAGS) + +clean: + rm *.o server client diff --git a/client.c b/client.c new file mode 100644 index 0000000..1581068 --- /dev/null +++ b/client.c @@ -0,0 +1,196 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "socket_wrapper.h" + +/*======== + *Operation + *========*/ +/*send user error message +80 character limit +*/ +int send_fail(int sock,const char * msg){ + struct TransferResult res; + res.res = RES_USR_ERR; + res.file_size = 0; + res.err_number = 0; + res.error_msg_size = strlen(msg); + //os will be combining if tcp_autocorking emabled. + if(send(sock,&res,sizeof(res),0) < 0){ + perror("error msg send"); + return -1; + } + if (send(sock,msg,res.error_msg_size,0) < 0){ + perror("error msg send"); + return -1; + } + return 0; +} + +int send_errno(int sock){ + struct TransferResult r; + r.res = RES_ERR; + r.err_number = errno; + r.file_size = 0; + r.error_msg_size = 0; + if(send(sock,&r,sizeof(r),0)){ + perror("errno send"); + return -1; + } + return 0; +} +/* return fd, if success. +otherwise, return -1. +*/ +int read_request(int sock,uint8_t * buf,size_t bufsize){ + struct ReadOp p; + int fd; + ssize_t n = recv_until_byte(sock,&p,sizeof(p),TIMEOUT); + if (n < 0){ + if (n == -2) fprintf(stderr,"timeout!"); + else perror("receive fail"); + return -1; + } + if(bufsize <= p.file_url_size + sizeof(p) + 1){ + send_fail(sock,"buffer overflow"); + return -1; + } + else if(p.file_url_size + 1 > MAX_PATH_SIZE){ + send_fail(sock,"max path fail"); + return -1; + } + else if(p.file_url_size == 0){ + send_fail(sock,"filename zero fail"); + return -1; + } + n = recv_until_byte(sock,buf,p.file_url_size,TIMEOUT); + buf[p.file_url_size] = '\0'; + printf("str size: %d, request %s\n",p.file_url_size,buf); + if(strchr((char *)buf,'/') != NULL){ + send_fail(sock,"Illegal character /"); + return -1; + } + fd = open((char *)buf,O_RDONLY); + if(fd < 0){ + send_errno(sock); + close(fd); + return -1; + } + return fd; +} + +int send_response(int sock,int fd, uint8_t * buf, size_t bufsize){ + struct TransferResult r; + struct stat st; + off_t offset = 0; + ssize_t readed = 0; + r.res = RES_OK; + r.err_number = 0; + r.error_msg_size = 0; + if(fstat(fd,&st) < 0){ + return send_errno(sock); + } + if(S_ISDIR(st.st_mode)){ + return send_fail(sock,"is a directory"); + } + r.file_size = st.st_size; + if(send(sock,&r,sizeof(r),0)<0){ + perror("send fail"); + return -1; + } +#ifdef USE_SENDFILE + while (r.file_size != offset) + { + size_t count = SEND_FILE_CHUNK_SIZE < (r.file_size - offset) ? SEND_FILE_CHUNK_SIZE : (r.file_size - offset); + if((readed = sendfile(sock,fd,&offset,count)) < 0){ + perror("send file fail"); + return -1; + } + } +#else + while (offset < r.file_size) + { + readed = bufsize < (r.file_size - offset) ? bufsize : r.file_size - offset; + if(read(fd,buf,readed)<0){ + perror("send response read fail"); + return -1; + } + if(send(sock,buf,readed,0)<0){ + perror("send response send fail"); + return -1; + } + offset += readed; + } + +#endif + return 0; +} +static int sock; +void safe_exit(){ + close(sock); +} +int main(int argc, const char *argv[]){ + uint8_t * buf; + struct sockaddr_in addr; + struct sockaddr_in client_addr; + socklen_t client_addr_len = sizeof(client_addr); + int csock; + int bufsize; + register_alarm(); + sock = socket(AF_INET,SOCK_STREAM,0); + atexit(safe_exit); + if(sock < 0){ + perror("sock create fail"); + return 1; + } + bufsize = getBufferSizeFrom(sock); + buf = malloc(bufsize * sizeof(*buf)); + if (buf == NULL){ + fprintf(stderr,"lack of memory"); + return 1; + } + + addr.sin_addr.s_addr = htonl(INADDR_ANY); /*0.0.0.0 모든 네트워크 인터페이스에 묶임.*/ + addr.sin_family = AF_INET; + addr.sin_port = htons(SERVER_PORT); + + if(bind(sock, (struct sockaddr *)&addr,sizeof(addr)) < 0){ + perror("bind failed"); + return 1; + } + fprintf(stderr,"server bind on %s:%d\n",inet_ntoa(addr.sin_addr),SERVER_PORT); + + if(listen(sock,1) < 0){ + perror("listen failed"); + return 1; + } + + while ((csock = accept(sock, (struct sockaddr *)&client_addr,&client_addr_len)) >= 0) + { + int fd; + /*inet_ntoa is not reentrant function. do not use it in signal handler.*/ + printf("Connect : %s\n",(inet_ntoa(client_addr.sin_addr))); + if((fd = read_request(csock,buf,bufsize)) > 0){ + send_response(csock,fd,buf,bufsize); + close(fd); + } + + if(close(csock) < 0) + perror("csock close error"); + + } + free(buf); + perror("accept error"); + return 1; +} \ No newline at end of file diff --git a/hw12.c b/hw12.c new file mode 100644 index 0000000..53c5fdf --- /dev/null +++ b/hw12.c @@ -0,0 +1 @@ +#include diff --git a/server.c b/server.c new file mode 100644 index 0000000..e8e90ee --- /dev/null +++ b/server.c @@ -0,0 +1,159 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include "socket_wrapper.h" + +#ifdef USE_SENDFILE +#include +const size_t SEND_FILE_CHUNK_SIZE = 0x100000; /*1MB*/ +#endif + +/*======== + *Operation + *========*/ + +int sendReadOp(int sock,const char * filename){ + struct ReadOp op; + op.file_url_size = strlen(filename); + op.padding0 = 0; + if(send(sock,&op,sizeof(op),0)<0){ + perror("readop send fail"); + return -1; + } + if(send(sock,filename,op.file_url_size,0)<0){ + perror("readop filename send fail"); + return -1; + } + return 0; +} + +int recvFile(int sock, const char * filename,size_t file_size){ + int fd; + size_t count = 0; + int i; + int cur_progress = 1; + int return_value = 0; + int buf_sz = getBufferSizeFrom(sock); + uint8_t * buf = malloc(buf_sz*sizeof(*buf)); + if (buf == NULL){ + return -1; + } + fd = open(filename,O_WRONLY|O_CREAT|O_TRUNC,S_IRWXU|S_IRWXG|S_IROTH); + if (fd < 0) + { + perror("file open fail"); + return -1; + } + + while (file_size - count > 0) + { + int readed = buf_sz < file_size - count ? buf_sz : file_size - count; + if((i = recv_until_byte(sock,buf,readed,TIMEOUT)) < 0){ + if(i == -2) + fprintf(stderr,"recv file failed : timeout connetion lost\n"); + else perror("recv file failed"); + return_value = -1; + goto END; + } + if(write(fd,buf,readed)<0){ + perror("file write failed"); + return_value = -1; + goto END; + } + if( ((double)count / (double)file_size) * 100.0 > ((double)cur_progress) ){ + printf("\rprogress : %d%% current bytes: %ld bytes",cur_progress,count); + cur_progress = (int)((((double)count / (double)file_size)) * 100.0 + 1.0); + fflush(stdout); + } + count += readed; + } + printf("\rprogress : 100.00%% current bytes: %ld bytes\n",count); +END: + free(buf); + return return_value; +} + +int recvData(int sock,const char * filename){ + struct TransferResult res; + int i=0; + if((i=recv_until_byte(sock,&res,sizeof(res),TIMEOUT)) < 0){ + if (i == -2) fprintf(stderr,"timeout"); + else perror("recv fail"); + return -1; + } + static char error_meesage_buf[80] = ""; + switch(res.res){ + case RES_ERR: + fprintf(stderr,"Server Fail: %s", strerror(res.err_number)); + return -1; + case RES_USR_ERR: + assert(res.error_msg_size < 80);/*todo : fix*/ + if((i=recv_until_byte(sock,error_meesage_buf,res.error_msg_size,TIMEOUT)) < 0){ + if (i == -2) fprintf(stderr,"timeout"); + else perror("recv fail"); + return -1; + } + fprintf(stderr,"Error Message From Server: %s",error_meesage_buf); + return -1; + case RES_OK: + return recvFile(sock,filename,res.file_size); + break; + default: + fprintf(stderr,"unknown value!"); + return -1; + } + + return 0; +} + +int main(int argc, const char *argv[]){ + struct sockaddr_in addr; + const char * filename; + const char * server_name; + in_port_t server_port = SERVER_PORT; + int sock; + register_alarm(); + if (argc != 4){ + fprintf(stderr,"invaild arguments number."); + return 1; + } + server_name = argv[1]; + server_port = atoi(argv[2]); + filename = argv[3]; + if (server_port == 0) + { + fprintf(stderr,"port invalid"); + return 1; + } + + sock = socket(AF_INET,SOCK_STREAM,0); + if(sock < 0){ + perror("sock create fail"); + return 1; + } + addr.sin_addr.s_addr = inet_addr(server_name); + addr.sin_family = AF_INET; + addr.sin_port = htons(server_port); + if(connect(sock,(struct sockaddr *)&addr,sizeof(addr)) < 0){ + perror("connect failed"); + return 1; + } + if(sendReadOp(sock,filename) == 0){ + int ret = recvData(sock,filename); + close(sock); + return ret; + } + close(sock); + return 0; +} \ No newline at end of file diff --git a/socket_wrapper.c b/socket_wrapper.c new file mode 100644 index 0000000..f6dc431 --- /dev/null +++ b/socket_wrapper.c @@ -0,0 +1,71 @@ +#include +#include +#include +#include +#include +#include +#include "socket_wrapper.h" + +int getBufferSizeFrom(int sock){ + int buffer_sz; + socklen_t len = sizeof(buffer_sz); + if(getsockopt(sock,SOL_SOCKET,SO_SNDBUF,&buffer_sz,&len) < 0){ + perror("failed to get sock buffer size: getsockopt"); + buffer_sz = DEFAULT_BUF_SIZE;/*set to default*/ + } + if(buffer_sz < MINIMUM_BUF_SIZE) + buffer_sz = MINIMUM_BUF_SIZE; + return buffer_sz; +} + +static uint64_t timer_ticks = 0; +static void alarm_handler(int signum){ + timer_ticks++; +} + +void register_alarm(){ + struct sigaction sigact; + sigact.sa_flags = SA_INTERRUPT; + sigemptyset(&sigact.sa_mask); + sigaddset(&sigact.sa_mask,SIGALRM); + sigact.sa_handler = alarm_handler; + sigaction(SIGALRM, &sigact ,NULL); +} + +ssize_t timeout_recv(int fd,void * buf,size_t n,int timeout) +{ + ssize_t ret; + uint64_t cur = timer_ticks; + int die_count = 0; + for(;;){ + alarm(timeout); + ret = recv(fd,buf,n,0); + if (ret < 0 && errno == EINTR && cur != timer_ticks) + return -2; + alarm(0); + if (ret == 0){ + usleep(100000); + die_count++; + if(die_count > timeout*10){ + return -2; + } + } + else break; + } + return ret; +} + +ssize_t recv_until_byte(int fd,void * buf, size_t n,int timeout){ + ssize_t cur = 0; + uint8_t * b = buf; + while (cur < n) + { + ssize_t r = timeout_recv(fd,&b[cur],n-cur,timeout); + if (r < 0){ + return r; + } + cur += r; + } + assert(cur == n); + return cur; +} \ No newline at end of file diff --git a/socket_wrapper.h b/socket_wrapper.h new file mode 100644 index 0000000..6bb7fd7 --- /dev/null +++ b/socket_wrapper.h @@ -0,0 +1,60 @@ +#ifndef _SOCKET_WRAPPER_H_ +#define _SOCKET_WRAPPER_H_ +#include +#include +#include +#include +#include + +#ifdef USE_SENDFILE +#include +const size_t SEND_FILE_CHUNK_SIZE = 0x100000; /*1MB*/ +#endif + +static const in_port_t SERVER_PORT = 9091; +static const size_t DEFAULT_BUF_SIZE = 4096; +static const size_t MINIMUM_BUF_SIZE = 1024; +/*0 < x < MAX_PATH_SIZE*/ +static const uint16_t MAX_PATH_SIZE = 256; +static const int TIMEOUT = 5; + +enum{ + RES_OK = 0, + RES_ERR = 1, + RES_USR_ERR = 2 +}; + +#pragma pack(push,1) +struct ReadOp{ + uint16_t file_url_size;/* strlen(data) */ + uint16_t padding0; +}; +struct TransferResult{ + int16_t res; + int16_t error_msg_size; + int64_t file_size; /**/ + int32_t err_number; /*errno*/ +}; +#pragma pack(pop) + +#ifdef USE_GETADDRINFO + +#endif + +int getBufferSizeFrom(int sock); + +/*register alarm for timeout_recv()*/ +void register_alarm(); +/* +return -2 if timeout occur. +otherwise, implement equal to 'recv'. +you must call register_alarm() before you use this. +Since alarm() is called by internal implementation, don't use it if other alarms already exist. +*/ +ssize_t timeout_recv(int fd,void * buf,size_t n,int timeout); +/* +recieve data to buf until all bytes. +*/ +ssize_t recv_until_byte(int fd,void * buf, size_t n,int timeout); + +#endif \ No newline at end of file