int MFS_Write(int inum, char *buffer, int block) {
if(block>13)
return -1;
message.transmit = 3;
message.inum = inum;
message.block = block;
sprintf(message.name,"Write");
int rc;
WRITE:
rc = transmit();
struct sockaddr_in raddr;
// if(rc<0){
// printf("WRITE failed\n");
// return -1;
// }
// printf("MFS_Write CKP\n");
///////////////////////////////////////
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
struct timeval t;
t.tv_sec=5;
t.tv_usec=0;
rc = select(sd+1,&r,NULL,NULL,&t);
if(rc>0) {
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
}
else {
// printf("TIMEOUT\n");
goto WRITE;
}
WRITE2:
rc = UDP_Write(sd, &saddr, (char*) buffer, MFS_BLOCK_SIZE);
// fd_set r;
// FD_ZERO(&r);
// FD_SET(sd,&r);
// struct timeval t;
// t.tv_sec=5;
// t.tv_usec=0;
rc = select(sd+1,&r,NULL,NULL,&t);
if(rc>0) {
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
}
else {
// printf("TIMEOUT\n");
goto WRITE2;
}
return(reply_rec.return_val);
}
int MFS_Shutdown() {
// printf("MFS_Shutdown CKP\n");
//char temp[20];
// MFS_Transmit_t message;
sprintf(message.name,"Shutdown");
message.transmit=7;
int rc;
struct sockaddr_in raddr;
SHUTDOWN:
rc= transmit();
// if(rc<0)
// printf("ShutDown write failed!!\n");
// exit(0);
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
struct timeval t;
t.tv_sec=5;
t.tv_usec=0;
rc = select(sd+1,&r,NULL,NULL,&t);
if(rc>0) {
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
// printf("TIMEOUT\n");
// exit(1);
}
else {
// printf("TIMEOUT\n");
goto SHUTDOWN;
}
return(0);
}
int MFS_Unlink(int pinum, char *name) {
if(strlen(name)>=60) {
return -1;
}
message.transmit = 6;
message.pinum = pinum;
sprintf(message.name,name);
int rc ;
UNLINK:
rc= transmit();
struct sockaddr_in raddr;
// printf("MFS_Unlink CKP\n");
///////////////////////////////////////
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
struct timeval t;
t.tv_sec=5;
t.tv_usec=0;
rc = select(sd+1,&r,NULL,NULL,&t);
if(rc>0) {
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
}
else {
// printf("TIMEOUT\n");
goto UNLINK;
}
/////////////////
return(reply_rec.return_val);
}
int main(int argc, char *argv[])
{
if(argc!=3)
{
//fprintf(stderr,"Usage: server [portnum] [file-system-image]\n");
exit(0);
}
int portNum=atoi(argv[1]);
sprintf(imgName,argv[2]);
//Open the port
sd=UDP_Open(portNum);
assert(sd != -1);
initImage(imgName);
char buffer[sizeof(msg_t)];
//Server listening in loop
while(1)
{
//read incoming message from port
int rc=UDP_Read(sd, &addr, buffer, sizeof(msg_t));
if(rc>0)
{
handleRequest(buffer);
rc = UDP_Write(sd, &addr, buffer, sizeof(msg_t));//Send back the response to the client
}
}
return 0;
}
msg_t client(msg_t msg){
printf("CLIENT:: read %d bytes (message: '%s')\n", rc, msg.func);
printf("CLIENT:: read %d bytes (ret %d)\n", rc, msg.ret);
printf("CLIENT:: about to send message (%d)\n", rc);
rc = UDP_Write(sd, &saddr, (char *) &msg, sizeof(msg_t));
printf("CLIENT:: sent message rc = (%d)\n", rc);
fd_set r;
FD_ZERO(&r);
FD_SET(sd, &r);
struct timeval t;
t.tv_sec = 4;
t.tv_usec = 0;
rc = select(sd + 1, &r, NULL, NULL, &t);
int count = 0;
while (rc <= 0 && count < 10) {
printf("a\n");
rc = UDP_Write(sd, &saddr, (char *) &msg, sizeof(msg_t));
rc = select(sd + 1, &r, NULL, NULL, &t);
count ++;
}
if (rc > 0) {
struct sockaddr_in raddr;
int rc = UDP_Read(sd, &raddr,(char *) &msg, sizeof(msg_t));
printf("CLIENT:: read %d bytes (message: '%d')\n", rc, msg.ret);
}
else {
printf("maximum timeout reached, request not completed\n");
}
return msg;
}
int MFS_Read(int inum, char *buffer, int block){
/************ message server will process **********/
msg.msg_type = READ;
msg.inum = inum;
msg.block = block;
// send message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
// time out options
rc = rcv_msg();
if(rc > 0){
struct sockaddr_in raddr;
UDP_Read(sd, &raddr, (char*) &msg, sizeof(msg));
if(msg.rspns < 0)
return -1;
else{
strcpy(buffer, msg.buffer);
return 0;
}
}
else
return -1; // timed out
}
int MFS_Stat(int inum, MFS_Stat_t *m){
/************ message server will process **********/
msg.msg_type = STAT;
msg.inum = inum;
// sent message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
printf("stat message sent\n");
// time out options
rc = rcv_msg();
if(rc > 0){
struct sockaddr_in raddr;
rc = UDP_Read(sd, &raddr, (char*) &msg, sizeof(msg));
if(msg.rspns < 0)
return -1;
else{
m->type = msg.stat.type;
m->size = msg.stat.size;
return 0;
}
}
else
return -1;
}
int MFS_Lookup(int pinum, char* name){
/************ message server will process **********/
msg.msg_type = LOOKUP;
msg.pinum = pinum;
strcpy(msg.name, name);
// sent message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
printf("lookup message sent\n");
// time out options
rc = rcv_msg();
// recevice stuff from server
if(rc > 0){
struct sockaddr_in raddr;
UDP_Read(sd, &raddr, (char*)&msg, sizeof(msg));
// check the return inum item
if(msg.inum > 0)
return msg.inum;
else
return -1;
}
else{
printf("timed out\n");
return -1; // timed out
}
}
int
main(int argc, char *argv[])
{
int sd = UDP_Open(0);
assert(sd > -1);
struct sockaddr_in saddr;
int rc = UDP_FillSockAddr(&saddr, "localhost", 10000);
assert(rc == 0);
//message msg = {.func="shutdown", .int1 = 0,.int2=0,.ret=-1,.name="root"};
message msg = {.func="lookup", .int1 = 0,.int2=0,.ret=1,.name=".."};
printf("CLIENT:: about to send message (%d)\n", rc);
rc = UDP_Write(sd, &saddr, (char *) &msg, sizeof(message));
printf("CLIENT:: sent message (%d)\n", rc);
fd_set r;
FD_ZERO(&r);
FD_SET(sd, &r);
struct timeval t;
t.tv_sec = 4;
t.tv_usec = 0;
rc = select(sd + 1, &r, NULL, NULL, &t);
if (rc > 0) {
struct sockaddr_in raddr;
msg.ret = -19;
int rc = UDP_Read(sd, &raddr,(char *) &msg, sizeof(message));
printf("CLIENT:: read %d bytes (message: '%d')\n", rc, msg.ret);
}
else {
printf("client timed out\n");
//rc = UDP_Write(sd, &saddr, (char *) &msg, sizeof(message));
//rc = select(sd + 1, &r, NULL, NULL, &t);
}
return 0;
}
void serverListen(int port)
{
int sd = UDP_Open(port);
if(sd < 0)
{
printf("Error opening socket on port %d\n", port);
exit(1);
}
printf("Starting server...\n");
while (1) {
struct sockaddr_in s;
Net_Packet packet;
int rc = UDP_Read(sd, &s, (char *)&packet, sizeof(Net_Packet));
if (rc > 0) {
Net_Packet responsePacket;
switch(packet.message){
case PAK_LOOKUP :
responsePacket.inum = Server_Lookup(packet.inum, packet.name);
break;
case PAK_STAT :
responsePacket.inum = Server_Stat(packet.inum, &(responsePacket.stat));
break;
case PAK_WRITE :
responsePacket.inum = Server_Write(packet.inum, packet.buffer, packet.block);
break;
case PAK_READ:
responsePacket.inum = Server_Read(packet.inum, responsePacket.buffer, packet.block);
break;
case PAK_CREAT:
responsePacket.inum = Server_Creat(packet.inum, packet.type, packet.name);
break;
case PAK_UNLINK:
responsePacket.inum = Server_Unlink(packet.inum, packet.name);
break;
case PAK_SHUTDOWN:
break;
case PAK_RESPONSE:
break;
}
responsePacket.message = PAK_RESPONSE;
rc = UDP_Write(sd, &s, (char*)&responsePacket, sizeof(Net_Packet));
if(packet.message == PAK_SHUTDOWN)
Server_Shutdown();
}
}
}
int main(int argc, char *argv[]) {
if(argc<3) {
printf("Usage: server server-port-number file-system-image\n");
exit(1);
}
int portid = atoi(argv[1]);
char* fileSysImg = argv[2];
int sd = UDP_Open(portid);
assert(sd > -1);
server_MFS_Init(fileSysImg);
MFS_Details * details = (MFS_Details *)malloc(sizeof(MFS_Details));
metadataSize = BLOCKS*(sizeof(char) + sizeof(char) + sizeof(MFS_Stat_t));
printf("waiting in loop\n");
while (1) {
struct sockaddr_in s;
int rc = UDP_Read(sd, &s, (char *)details, sizeof(MFS_Details)); //read message buffer from port sd
if (rc > 0) {
if(!strcmp(details->operation,"lookup"))
{
details->returnVal = server_MFS_Lookup(details->dirEnt.inum, details->dirEnt.name);
}
/*
else if(!strcmp(details->operation,"stat"))
{
details->returnVal = server_MFS_Stat(details->dirEnt->inum, details->stat);
}
else if(!strcmp(details->operation,"write"))
{
details->returnVal = server_MFS_Write(details->dirEnt->inum, details->dirEnt->name, details->block);
}
else if(!strcmp(details->operation,"read"))
{
details->returnVal = server_MFS_Read(details->dirEnt->inum, details->dirEnt->name, details->block);
}
*/
else if(!strcmp(details->operation,"create"))
{
details->returnVal = server_MFS_Creat(details->dirEnt.inum, details->stat.type, details->dirEnt.name);
}
/*
else if(!strcmp(details->operation,"unlink"))
{
details->returnVal = server_MFS_Unlink(details->dirEnt->inum, details->dirEnt->name);
}
*/
rc = UDP_Write(sd, &s, (char *)details, sizeof(MFS_Details)); //write message buffer to port sd
}
}
return 0;
}
//reads packet from socket
int receive(){
if (rc > 0) {
struct sockaddr_in raddr;
rc = UDP_Read(sd, &raddr, buffer, BUFFER_SIZE);
char buffer[BUFFER_SIZE];
struct sockaddr_in saddr;
int sd, rc;
int messageid;
if (DEBUG) printf("CLIENT:: read %d bytes (message: '%s')\n", rc, buffer);
return 0;
}
return 1;
}
int MFS_Read(int inum, char *buffer, int block) {
if(block>13)
return -1;
message.transmit = 4;
message.inum = inum;
message.block = block;
sprintf(message.name,"Read");
int rc;
READ:
rc = transmit();
struct sockaddr_in raddr;
// if(rc<0){
// printf("READ failed\n");
// return -1;
// }
// printf("MFS_Read CKP = %d\n",reply_rec.return_val);
///////////////////////////////////////
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
struct timeval t;
t.tv_sec=5;
t.tv_usec=0;
rc = select(sd+1,&r,NULL,NULL,&t);
if(rc>0) {
rc = UDP_Read(sd, &raddr, (char*) buffer, MFS_BLOCK_SIZE);
rc = UDP_Read(sd, &raddr, (char*) &reply_rec, sizeof(MFS_Transmit_t));
}
else {
// printf("TIMEOUT\n");
goto READ;
}
return(reply_rec.return_val);
}
int MFS_Stat(int inum, MFS_Stat_t *m) {
message.transmit = 2;
message.inum=inum;
sprintf(message.name,"Stat");
int rc;
STAT:
rc=transmit();
// if(rc<0){
// printf("Write error\n");
// return(-1);
// }
struct sockaddr_in raddr;
///////////////////////////////////////
struct timeval t;
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
t.tv_sec=5;
t.tv_usec=0;
int rc2 = select(sd+1,&r,NULL,NULL,&t);
if(rc2>0) {
rc = UDP_Read(sd, &raddr, (char*)m, sizeof(MFS_Stat_t));
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
}
else {
// printf("TIMEOUT\n");
goto STAT;
}
// printf("Returned size = %d, type = %d\n",m->size,m->type);
// printf("CLIENT:: read %d bytes (message: %s) (return val:%d)\n", rc, reply_rec.reply,reply_rec.return_val);
// printf("MFS_Stat CKP\n");
return(reply_rec.return_val);
}
//Recieve the packet
int recv_msg() //TODO::Timeout functionality
{
if(!com_t.send_ack)
return -1;
struct sockaddr_in raddr;
memset(com_t.buffer, 0, MSG_BUFFER_SIZE); //Clear the recieving buffer
int rc = UDP_Read(com_t.sd, &raddr, com_t.buffer, MSG_BUFFER_SIZE);
if(rc < 0)
return -1;
else
printf(" CLIENT:: Recieved %d bytes (message: '%s')\n", rc, com_t.buffer);
return 0;
}
//ATTEMPTS TO RECIEVE A PACKET OVER THE UDP SOCKET
int receive()
{
rc = UDP_Read(sd, &raddr, response, BUFFERSIZE);
if (rc < 0)
{
return -1;
}
// printf("Client : Received message (%d bytes) (%s)\n.", rc, response);
if (DEBUG) printf("RX: command: %d, key: %c, id: %d, int1: %d, int2: %d\n", response[COMMAND_BYTE],
response[KEY_BYTE], response[MESSAGE_ID], response[CMD_INT1], response[CMD_INT2]);
memcpy(test, response, 4096);
test[4096] = '\0';
//if (DEBUG) printf("data: %s\n", test);
return rc;
}
int MFS_Shutdown(){
/************ message server will process **********/
msg.msg_type = SHUT;
printf("shut: msg_type: %d\n", msg.msg_type);
// send message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
// time out options
rc = rcv_msg();
if(rc > 0){
struct sockaddr_in raddr;
// server side will send -1 or 0 according to result
rc = UDP_Read(sd, &raddr, (char*)&msg, sizeof(msg));
printf("shut:msg_rs: %d\n", msg.rspns);
return msg.rspns;
}
else
return -1; // timed out
}
int MFS_Unlink(int pinum, char *name){
/************ message server will process **********/
msg.msg_type = UNLINK;
msg.pinum = pinum;
strcpy(msg.name, name);
// send message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
// time out options
rc = rcv_msg();
if(rc > 0){
struct sockaddr_in raddr;
// server side will send -1 or 0 according to result
UDP_Read(sd, &raddr, (char*)&msg, sizeof(msg));
return msg.rspns;
}
else
return -1; // timed out
}
int MFS_Creat(int pinum, int type, char *name){
/************ message server will process **********/
msg.msg_type = CREAT;
msg.pinum = pinum;
msg.type = type;
strcpy(msg.name, name);
// send message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
// time out options
rc = rcv_msg();
if(rc > 0){
struct sockaddr_in raddr;
UDP_Read(sd, &raddr, (char*)&msg, sizeof(msg));
return msg.rspns;
}
else
return -1; // timed out
}
int MFS_Write(int inum, char *buffer, int block){
/************ message server will process **********/
msg.msg_type = WRITE;
msg.inum = inum;
strcpy(msg.buffer, buffer);
msg.block = block;
// send message
int rc = UDP_Write(sd, &saddr, (char*)&msg, sizeof(msg));
rc = rcv_msg();
if(rc > 0){
struct sockaddr_in raddr;
UDP_Read(sd, &raddr, (char*)&msg, sizeof(msg));
return msg.rspns;
}
else
return -1; // timed out
}
int MFS_Init(char *hostname, int port) {
INIT:
// printf("MFS_Init CKP\n");
port_num=port;
sd = UDP_Open(0);
assert(sd > -1);
int rc = UDP_FillSockAddr(&saddr,hostname,port_num);
saddr=saddr;
assert(rc == 0);
struct sockaddr_in raddr;
// MFS_Transmit_t message;
sprintf(message.name,"Init");
message.transmit=0;
//INIT:
rc = transmit();
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
struct timeval t;
t.tv_sec=5;
t.tv_usec=0;
int rc2 = select(sd+1,&r,NULL,NULL,&t);
printf("Running %s on %d and select returned =%d\n",hostname,port_num,rc);
if(rc2>0) {
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
// printf("TIMEOUT\n");
// exit(1);
}
else {
// printf("TIMEOUT\n");
goto INIT;
}
return(0);
}
int sendPacket(char *hostname, int port, Net_Packet *sentPacket, Net_Packet *responsePacket, int maxTries)
{
int sd = UDP_Open(0);
if(sd < -1)
{
perror("Error opening connection.\n");
return -1;
}
struct sockaddr_in addr, addr2;
int rc = UDP_FillSockAddr(&addr, hostname, port);
if(rc < 0)
{
perror("Error looking up host.\n");
return -1;
}
fd_set rfds;
struct timeval tv;
tv.tv_sec=3;
tv.tv_usec=0;
do {
FD_ZERO(&rfds);
FD_SET(sd,&rfds);
UDP_Write(sd, &addr, (char*)sentPacket, sizeof(Net_Packet));
if(select(sd+1, &rfds, NULL, NULL, &tv))
{
rc = UDP_Read(sd, &addr2, (char*)responsePacket, sizeof(Net_Packet));
if(rc > 0)
{
UDP_Close(sd);
return 0;
}
}else {
maxTries -= 1;
}
}while(1);
}
int
main(int argc, char *argv[])
{
if(argc != 3){
fprintf(stderr,"usage: server <portnum> <filename>\n");
exit(0);
}
int port = atoi(argv[1]);
sprintf(file, argv[2]);
sd = UDP_Open(port);
assert(sd > -1);
serverInit(file);
memLoad();
printf("waiting in loop\n");
while (1) {
//use this to get the socket address
struct sockaddr_in y;
s = y;
char buffer[sizeof(msg_t)];
int rc = UDP_Read(sd, &s, buffer, sizeof(msg_t));
//figure out what kind of message this is - read, write, lookup etc
//when done go ahead and reply to it
if (rc > 0) {
// char reply[BUFFER_SIZE];
//sprintf(reply, "reply");
handleMessage (buffer);
//need a message struct casted as a char []
rc = UDP_Write(sd, &s, buffer, sizeof(msg_t));
}
}
return 0;
}
int MFS_Lookup(int pinum, char *name) {
if(strlen(name)>=60) {
printf("Too long name\n");
return -1;
}
message.transmit = 1;
message.pinum=pinum;
sprintf(message.name,name);
int rc;
LOOKUP:
rc=transmit();
// if(rc<0){
// printf("Write error\n");
// return(-1);
// }
struct sockaddr_in raddr;
// printf("MFS_Lookup CKP\n");
///////////////////////////////////////
fd_set r;
FD_ZERO(&r);
FD_SET(sd,&r);
struct timeval t;
t.tv_sec=5;
t.tv_usec=0;
rc = select(sd+1,&r,NULL,NULL,&t);
if(rc>0) {
rc = UDP_Read(sd, &raddr, (char*)&reply_rec, sizeof(return_struct_t));
}
else {
// printf("TIMEOUT\n");
goto LOOKUP;
}
return(reply_rec.return_val);
}
int
main(int argc, char *argv[])
{
int sd = UDP_Open(10000);
assert(sd > -1);
printf(" SERVER:: waiting in loop\n");
while (1) {
struct sockaddr_in s;
char buffer[BUFFER_SIZE];
int rc = UDP_Read(sd, &s, buffer, BUFFER_SIZE);
if (rc > 0) {
printf(" SERVER:: read %d bytes (message: '%s')\n", rc, buffer);
char reply[BUFFER_SIZE];
sprintf(reply, "reply");
rc = UDP_Write(sd, &s, reply, BUFFER_SIZE);
}
}
return 0;
}
int
main(int argc, char *argv[])
{
int sd = UDP_Open(0);
assert(sd > -1);
struct sockaddr_in saddr;
int rc = UDP_FillSockAddr(&saddr, "procyon.cs.wisc.edu", 1345);
assert(rc == 0);
printf("CLIENT:: about to send message (%d)\n", rc);
char message[BUFFER_SIZE];
sprintf(message, "hello world");
rc = UDP_Write(sd, &saddr, message, BUFFER_SIZE);
// printf("CLIENT:: sent message (%d)\n", rc);
if (rc > 0) {
struct sockaddr_in raddr;
int rc = UDP_Read(sd, &raddr, buffer, BUFFER_SIZE);
printf("CLIENT:: read %d bytes (message: '%s')\n", rc, buffer);
}
return 0;
}
int
main(int argc, char *argv[])
{
int port;
char* file_img;
int rfd;
//Get the arguments
get_args(&port, &file_img, argc, argv);
int sd = UDP_Open(port); //Creates a new socket and binds to a port to it
assert(sd > -1);
//Open the file image, if not present call file_create routine
disk_fd = open(file_img, O_RDWR);
if(disk_fd == -1)
{
#ifdef DEBUG
printf("----File image doesn't exist - Creating a new one\n");
#endif
rfd = create_img(file_img);
if(rfd == -1)
{
#ifdef DEBUG
printf("----Error Creating the file - Exiting\n");
#endif
return -1;
}
disk_fd = rfd;
}
#ifdef DEBUG
printf("----File descriptor open: %d\n", disk_fd);
#endif
printf(" SERVER:: waiting in loop\n");
while (1)
{
struct sockaddr_in s;
char buffer[MSG_BUFFER_SIZE]; //Redefined the size as, it may recieve more than 4096 bytes
int rc = UDP_Read(sd, &s, buffer, MSG_BUFFER_SIZE);
if (rc > 0)
{
printf(" SERVER:: Read %d bytes (message: '%s')\n", rc, buffer);
int ret_func = parse_msg(buffer); //Parse the message
//Common paramters across all routines
int pinum, inum, type, block, entries;
char name[NAME_SIZE];
char rw_buf[MFS_BLOCK_SIZE];
char buf[MSG_BUFFER_SIZE];
int res_t, ret; //res_t- return status of server side routines
S_Stat_t m;
switch(ret_func)
{
case 1:
ret = Lookup_parse(buffer, &pinum, &name);
if (!ret)
res_t = S_Lookup(pinum, name);
else
res_t = -1;
//MSG Format: Function_id, Success_state(-1 or inum)
memset(buf, 0, MSG_BUFFER_SIZE);
snprintf(buf, 2*sizeof(int) , "%d%d", ret_func, res_t);
send_resp(sd, &s, buf);
break;
case 2:
ret = Stat_parse(buffer, &inum);
if(!ret)
res_t = S_Stat(inum, &m);
else
res_t = -1;
//MSG Format: Function_id, Success_State, File_type, File_size
memset(buf, 0, MSG_BUFFER_SIZE);
snprintf(buf, 4*sizeof(int) , "%d%d%d%04d", ret_func, res_t, m.type, m.size);
send_resp(sd, &s, buf);
break;
case 3:
ret = Write_parse(buffer, &inum, &rw_buf, &block);
if(!ret)
res_t = S_Write(inum, rw_buf, block);
else
res_t = -1;
//MSG Format: Function_id, Success_state
memset(buf, 0, MSG_BUFFER_SIZE);
snprintf(buf, 2*sizeof(int) , "%d%d", ret_func, res_t);
send_resp(sd, &s, buf);
break;
case 4:
ret = Read_parse(buffer, &inum, &block);
if(!ret)
res_t = S_Read(inum, &rw_buf, block, &type, &entries);
else
res_t = -1;
//MSG Format: Function_id, Success_state, File_type, Num_of_entries, 4K buffer bytes read
memset(buf, 0, MSG_BUFFER_SIZE);
snprintf(buf, 4*sizeof(int) , "%d%d%d%02d", ret_func, res_t, type, entries);
strcat(buf, rw_buf);
send_resp(sd, &s, buf);
break;
case 5:
ret = Creat_parse(buffer, &pinum, &type, &name);
if(!ret)
res_t = S_Creat(pinum, type, name);
else
res_t = -1;
//MSG Format: Function_id, Success_state
memset(buf, 0, MSG_BUFFER_SIZE);
snprintf(buf, 2*sizeof(int) , "%d%d", ret_func, res_t);
send_resp(sd, &s, buf);
break;
case 6:
ret = Unlink_parse(buffer, &pinum, &name);
break;
case 7:
#ifdef DEBUG
printf("----MFS_Shutdown called\n");
#endif
break;
default:
#ifdef DEBUG
printf("Invalid Function Id\n");
#endif
ret = -1;
break;
}
} //rc > 0 loop
} //while loop
return 0;
}
int
main(int argc, char *argv[])
{
int port;
char* file_img;
int rfd;
//Get the arguments
get_args(&port, &file_img, argc, argv);
int sd = UDP_Open(port); //Creates a new socket and binds to a port to it
assert(sd > -1);
//Open the file image, if not present call file_create routine
disk_fd = open(file_img, O_RDWR);
if(disk_fd == -1)
{
#ifdef DEBUG
printf("File image doesn't exist - Creating a new one\n");
#endif
rfd = create_img(file_img);
if(rfd == -1)
{
#ifdef DEBUG
printf("Error Creating the file - Exiting\n");
#endif
return -1;
}
//disk_fd = rfd;
}
#ifdef DEBUG
printf("File descriptor open: %d\n", disk_fd);
#endif
//close(ofd);
/*
CR_t* cr;
lseek(ofd, 0, SEEK_SET);
int br = read(ofd, (void*)cr, 4);
printf("BR: %d\n", br);
printf("Log end: %d\n", cr->log_end);
printf("Imap_0 addr: %d\n", cr->imap_p[0]);
*/
printf(" SERVER:: waiting in loop\n");
Stat_t* m =(Stat_t*) malloc(sizeof(Stat_t));
sstat(10, m);
printf("file->size=%d\n File->type=%d\n", m->size, m->type);
while (1)
{
struct sockaddr_in s;
char buffer[BUFFER_SIZE];
int rc = UDP_Read(sd, &s, buffer, BUFFER_SIZE);
if (rc > 0)
{
printf(" SERVER:: read %d bytes (message: '%s')\n", rc, buffer);
char reply[BUFFER_SIZE];
sprintf(reply, "reply");
rc = UDP_Write(sd, &s, reply, BUFFER_SIZE);
}
}
return 0;
}
int main(int argc, char *argv[])
{
if(argc != 3){
fprintf(stderr,"usage: server [portnum] [file-system-image]\n");
fprintf(stderr,"you supplied %d args\n", argc);
exit(1);
}
int portnum = atoi( argv[1] );
if( ! (portnum > 0 ) ) {
fprintf(stderr, " portnum = %d; this should be a pos number",portnum);
}
const int sd = UDP_Open(portnum);
assert(sd > -1);
inode_table = (Inode_t *)malloc(MFS_BLOCK_NUMS * sizeof(Inode_t));
data_region = (Block_t *)malloc(MFS_BLOCK_NUMS * sizeof(Block_t));
if(inode_table == NULL || data_region == NULL){
fprintf(stderr, "malloc error\n");
exit(-1);
}
if( (image_fd = open(argv[2],O_RDWR)) == -1){
image_fd = Image_Init(argv[2]);
}
int rc = -1;
struct sockaddr_in s;
char buffer_read[ UDP_BUFFER_SIZE];
char buffer_reply[UDP_BUFFER_SIZE];
char buffer[BUFFER_SIZE];
char * ptr = buffer_read;
int block = -1;
int blocks = -1;
int pinum = -1;
int inum = -1;
int size = -1;
int status = -1;
int type = -1;
char * name = NULL;
int * iptr = NULL;
char * cptr = NULL;
MFS_Stat_t * mptr = NULL;
while (1) {
block = -1;
blocks = -1;
pinum = -1;
inum = -1;
size = -1;
status = -1;
type = -1;
name = NULL;
iptr = NULL;
cptr = NULL;
rc = UDP_Read(sd, &s, buffer_read, UDP_BUFFER_SIZE);
ptr = buffer_read;
if (rc < 1) {
rc = -1;
continue;
}
iptr = (int*) ptr;
int * op_id = iptr;
iptr++;
switch(*op_id)
{
case 0:
printf("op_id == 0 \n");
break;
case 1:
pinum = *( iptr );
iptr++;
cptr = (char*)iptr;
name = cptr;
inum = Server_LookUp(pinum, name );
iptr = (int*) buffer_reply;
*iptr = inum;
break;
case 2:
inum = *( iptr );
iptr++;
mptr = (MFS_Stat_t*)iptr;
status = Server_Stat(inum, mptr );
iptr = (int*) buffer_reply;
*iptr = status;
iptr++;
memcpy((void*) iptr, (void*)mptr, sizeof( MFS_Stat_t ) );
break;
case 3:
inum = *( iptr );
iptr++;
cptr = (char*)iptr;
memcpy( buffer, cptr, BUFFER_SIZE );
cptr += BUFFER_SIZE;
iptr = (int*) cptr;
block = *iptr;
status = Server_Write( inum, buffer, block );
iptr = (int *) buffer_reply;
*iptr = status;
break;
case 4:
inum = *( iptr );
iptr++;
cptr = (char*)iptr;
memcpy( buffer, cptr, BUFFER_SIZE );
cptr += BUFFER_SIZE;
iptr = (int*) cptr;
block = *iptr;
status = Server_Read( inum, buffer, block );
iptr = (int *) buffer_reply;
*iptr = status;
iptr++;
cptr = (char*) iptr;
memcpy(cptr, buffer, BUFFER_SIZE);
break;
case 5:
pinum = *( iptr );
iptr++;
type = *iptr;
iptr++;
name = (char*) iptr;
status = Server_Creat( pinum, type, name );
iptr = (int *) buffer_reply;
*iptr = status;
break;
case 6:
pinum = *(iptr++);
name = (char*)(iptr);
status = Server_Unlink( pinum, name );
iptr = (int*) buffer_reply;
*iptr = status;
break;
default:
fprintf(stderr, "bad function number %d\n", *op_id );
exit(1);
}
rc = UDP_Write(sd, &s, buffer_reply, UDP_BUFFER_SIZE);
}
return 0;
}
int
main(int argc, char *argv[]){
//Variables
int sd, fd, rc, returnCode, i, size;
struct sockaddr_in s;
int problem = sizeof(MFS_Dir_t) + sizeof(MFS_Inode_t) +
sizeof(MFS_InodeMap_t) + (2 * sizeof(MFS_DirEnt_t));
//Initialize the client and server messages
client = (ClientMessage_t *)malloc(sizeof(ClientMessage_t));
server = (ServerMessage_t *)malloc(sizeof(ServerMessage_t));
//Check for file image
/*
if(argc == 3){
sd = UDP_Open(atoi(argv[1]));
fd = open(argv[2], O_RDWR);
assert(sd > -1);
assert(fd > -1);
}
*/
if(argc == 3){
printf("Check: %d\n", atoi(argv[1]));
//Open the socket and the image
sd = UDP_Open(atoi(argv[1]));
//sd = UDP_Open(29344);
fd = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, S_IRWXU);
assert(sd > -1);
assert(fd > -1);
//Create image
imageSize = sizeof(MFS_Checkpoint_t) + (256 * sizeof(MFS_InodeMap_t)) +
(4096 * sizeof(MFS_Inode_t)) + (14 * 4096 * 4096);
image = malloc(imageSize);
if(image == NULL)
printf("MALLOC PROBLEM\n");
size = 0;
//Create and initialize the checkpoint
temp = image;
position = image;
end = image;
checkpoint = (MFS_Checkpoint_t *)temp;
position += sizeof(MFS_Checkpoint_t);
//Initialize the arrays
for(i = 0; i < 256; i++)
inodeMap[i] = NULL;
for(i = 0; i < 4096; i++)
inodes[i] = NULL;
//Create the root directory
rc = addDirectory(0, "/");
}
else{
printf("Usage: server portnum [file-system-image]\n");
exit(-1);
}
//Start server loop
while(1){
//Check to make sure size is okay
//Get the message from the Client
rc = UDP_Read(sd, &s, (char *)client, sizeof(ClientMessage_t));
//Perform the correct operation
if(rc > 0){
if(client->syscallNumber == LOOKUP){
//Lookup the file
returnCode = MyLookup(client->inum, client->buffer);
printf("RETURNCODE: %d\n", returnCode);
//Setup the return message
server->returnCode = returnCode;
printf("server server return: %d\n", server->returnCode);
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
}
else if(client->syscallNumber == STAT){
//Get the Stat info about the specific inum
returnCode = MyStat(client->inum);
//Setup the return message
server->returnCode = returnCode;
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
}
else if(client->syscallNumber == WRITE){
printf("ENTERED WRITE 1\n");
printf("here here here: %d\n", client->inum);
//Update image
returnCode = MyWrite(client->inum, client->buffer, client->block);
//Update checkpoint
checkpoint->end = end - image;
//Write to disk
rc = write(fd, image, imageSize);
if(rc <= 0)
exit(-1);
fsync(fd);
//Setup the return message
server->returnCode = returnCode;
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
}
else if(client->syscallNumber == READ){
//Read the specified block of data
returnCode = MyRead(client->inum, client->block);
printf("server server server buffer: %s\n", server->buffer);
//Setup the return message
server->returnCode = returnCode;
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
}
else if(client->syscallNumber == CREAT){
//Update image
returnCode = MyCreat(client->inum, client->type, client->buffer);
//Update checkpoint
checkpoint->end = end - image;
//Write to disk
rc = write(fd, image, imageSize);
if(rc <= 0)
exit(-1);
fsync(fd);
//Setup the return message
server->returnCode = returnCode;
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
}
else if(client->syscallNumber == UNLINK){
//Unlink and update message
returnCode = MyUnlink(client->inum, client->buffer);
//Update checkpoint
checkpoint->end = end - image;
//Write to disk
rc = write(fd, image, imageSize);
if(rc <= 0)
exit(-1);
fsync(fd);
//Setup the return message
server->returnCode = returnCode;
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
}
else{
//Update checkpoint
checkpoint->end = end - image;
//This is the case for shutdown
rc = write(fd, image, imageSize);
if(rc <= 0)
exit(-1);
fsync(fd);
//Set up the return message
server->returnCode = 0;
rc = UDP_Write(sd, &s, (char *)server, sizeof(ServerMessage_t));
exit(0);
}
}
}
return 0;
}
