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_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 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 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;
}
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();
}
}
}
//Response sending routine
int send_resp(int sd, struct sockaddr_in* s, char* response)
{
int rc = UDP_Write(sd, s, response, MSG_BUFFER_SIZE);
#ifdef DEBUG
printf(" SERVER:: sending %d bytes (message: '%s')\n", rc, response);
#endif
return rc;
}
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;
}
//ATTEMPTS TO SEND A PACKET OVER THE UDP SOCKET
int sendpacket()
{
rc = UDP_Write(sd, &saddr, message, BUFFERSIZE);
if (DEBUG) printf("TX: command: %d, key: %c, id: %d, int1: %d, int2: %d\n", message[COMMAND_BYTE],
message[KEY_BYTE], message[MESSAGE_ID], message[CMD_INT1], message[CMD_INT2]);
memcpy(test, message, 4096);
test[4096] = '\0';
if (DEBUG) printf("data: %s\n", test);
assert(rc > -1);
return 0;
}
//Send the message packet
int send_msg()
{
int rc = UDP_Write(com_t.sd, &com_t.addr, com_t.message, MSG_BUFFER_SIZE);
if(rc < 0)
return -1;
else
{
printf(" CLIENT:: Sent %d bytes (message: '%s')\n", rc, com_t.message);
com_t.send_ack = 1;
}
return 0;
}
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);
}
void handleMessage(char * messageR){
msg_t* message = (msg_t*)messageR;
message->returnVal = -1;
int returnVal;
switch(message->msgType){
case INIT:
returnVal = serverInit(file);
message->returnVal = returnVal;
break;
case READ:
returnVal = serverRead(message->inum, message->buffer, message->block);
message->returnVal = returnVal;
break;
case LOOKUP:
returnVal = serverLookup(message->pinum, message->name);
message->returnVal = returnVal;
break;
case WRITE:
returnVal = serverWrite(message->inum, message->buffer, message->block);
message->returnVal = returnVal;
break;
case STAT:
returnVal = serverStat(message->inum, &(message->stat));
message->returnVal = returnVal;
break;
case CREATE:
returnVal = serverCreate(message->pinum, message->type, (message->name));
message->returnVal = returnVal;
break;
case UNLINK:
returnVal = serverUnlink(message->pinum, message->name);
message->returnVal = returnVal;
break;
case SHUTDOWN:
message->returnVal = 0;
memcpy(messageR, message, sizeof(*message));
UDP_Write(sd, &s, messageR, sizeof(msg_t));
//fsync(diskFD);
close(diskFD);
// printDisk();
exit(0);
break;
default:
message->returnVal = -1;
break;
}
memcpy(messageR, message, sizeof(*message));
}
int
UDP_Broadcast(int socket, const void *buf, int len)
{
int ret;
if (socket != net_broadcastsocket) {
if (net_broadcastsocket != 0)
Sys_Error("Attempted to use multiple broadcasts sockets");
ret = UDP_MakeSocketBroadcastCapable(socket);
if (ret == -1) {
Con_Printf("Unable to make socket broadcast capable\n");
return ret;
}
}
return UDP_Write(socket, buf, len, &broadcastaddr);
}
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_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_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 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);
}
void handleRequest(char *buffer)
{
msg_t *msg = (msg_t *)buffer;
switch(msg->func){
case LOOKUP:
msg->retCode=sLookup(msg->pinum, msg->name);
break;
case STAT:
msg->retCode=sStat(msg->inum, &(msg->stat));
break;
case WRITE:
//printf("Got\n%s\n", msg->buffer);
msg->retCode=sWrite(msg->inum, msg->buffer, msg->block);
break;
case READ:
msg->retCode=sRead(msg->inum, msg->buffer, msg->block);
break;
case CREAT:
{//need this bracket to define a scope for variable declaration
//MFS_Stat_t *stat = &(msg->stat);
msg->retCode=sCreat(msg->pinum, msg->type, msg->name);
break;
}
case UNLINK:
msg->retCode=sUnlink(msg->pinum, msg->name);
break;
case SHUTDOWN:
msg->retCode=0;
fsync(fdImage);
close(fdImage);
UDP_Write(sd,&addr,(char*)msg, sizeof(msg_t));
exit(0);
break;
default:
msg->retCode=-1;
break;
}
}
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
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
//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 command(message* msg, response* res) {
UDP_Write(fd, &addr, (char*) msg, sizeof(message));
UDP_Read(fd, &addr, (char*) res, sizeof(response));
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;
}
int
main(int argc, char *argv[])
{
// check for correct arguments
if(argc != 3) {
fprintf(stderr, "Usage: %s <port> <file-system-image>\n", argv[0]);
exit(1);
}
int portnum = atoi(argv[1]);
char *fs_image = argv[2];
int sd = UDP_Open(portnum);
assert(sd > -1);
int fd = open(fs_image, O_RDWR|O_CREAT, S_IRWXU);
if(fd < 0) {
fprintf(stderr, "Cannot open file image");
exit(1);
}
struct stat file_stat;
if(fstat(fd, &file_stat) < 0) {
fprintf(stderr, "Cannot open file image");
exit(1);
}
int i, j, rc;
MFS_Header_t *header;
int image_size;
free_bytes = MFS_BYTE_STEP_SIZE;
int entry_offset, inode_offset, new_dir_offset, parent_inode_offset;
int tmp_offset, tmp_inode_offset, tmp_imap_offset;
int done = 0;
MFS_Imap_t *imap_temp;
MFS_Inode_t *inode_temp;
MFS_Inode_t *new_inode;
MFS_DirEnt_t *entry_temp;
if(file_stat.st_size >= sizeof(MFS_Header_t)) {
image_size = file_stat.st_size + MFS_BYTE_STEP_SIZE;
printf("Using old file of size %d\n", (int)file_stat.st_size);
header = (MFS_Header_t *)malloc(image_size);
// Put text in memory
rc = read(fd, header, file_stat.st_size);
if(rc < 0){
fprintf(stderr, "Cannot open file");
exit(1);
}
} else {
//Initialize
image_size = sizeof(MFS_Header_t) + MFS_BYTE_STEP_SIZE;
header = (MFS_Header_t *)malloc(image_size);
// root initialization
inode_temp = allot_space(&header, sizeof(MFS_Inode_t), &tmp_inode_offset);
imap_temp = allot_space(&header, sizeof(MFS_Imap_t), &tmp_imap_offset);
imap_temp->inodes[0] = tmp_inode_offset;
prepare_inode(inode_temp, MFS_DIRECTORY, NULL);
for (i = 0; i < 14; i++) {
imap_temp->inodes[i] = -1;
}
// header initialization
for (i = 0; i < 4096/14; i++) {
header->map[i] = -1;
}
imap_temp->inodes[0] = tmp_inode_offset;
// add two default entries
entry_temp = allot_space(&header, MFS_BLOCK_SIZE, &tmp_offset);
entry_temp[0].name[0] = '.';
entry_temp[0].name[1] = '\0';
entry_temp[0].inum = 0;
entry_temp[1].name[0] = '.';
entry_temp[1].name[1] = '.';
entry_temp[1].name[2] = '\0';
entry_temp[1].inum = 0;
for (i = 2; i < MFS_BLOCK_SIZE/sizeof(MFS_DirEnt_t); i++) {
entry_temp[i].inum = -1;
}
inode_temp->data[0] = tmp_offset;
//Write to disk
header->map[0] = tmp_imap_offset;
flush(fd);
write_header(fd, header);
printf("Initializing new file\n");
}
void* header_ptr = (void*)header;
void* block_ptr = header_ptr + sizeof(MFS_Header_t);
prot_r = (MFS_Prot_t*)malloc(sizeof(MFS_Prot_t));
printf("Started listening at port %d\n", portnum);
while (1) {
struct sockaddr_in s;
rc = UDP_Read(sd, &s, (char*)prot_r, sizeof(MFS_Prot_t));
if (rc > 0) {
//Special case for shutdown
if(prot_r->cmd == CMD_INIT){
printf("Server initialized\n");
prot_r->ret = 0;
} else if(prot_r->cmd == CMD_LOOKUP){
prot_r->ret = -1;
MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);
prot_r->ret = lookup(block_ptr, parent_inode, &(prot_r->datapacket[0]));
} else if(prot_r->cmd == CMD_SHUTDOWN){
//Close file
rc = close(fd);
if(rc < 0){
fprintf(stderr, "Cannot open file");
exit(1);
}
prot_r->ret = 0;
if(UDP_Write(sd, &s, (char*)prot_r, sizeof(MFS_Prot_t)) < -1){
fprintf(stderr, "Unable to send result");
exit(1);
}
exit(0);
} else if(prot_r->cmd == CMD_UNLINK){
verify(&header, &block_ptr, 16384);
prot_r->ret = -1;
MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);
if(parent_inode != NULL && parent_inode->type == MFS_DIRECTORY){
int exist = lookup(block_ptr, parent_inode, &(prot_r->datapacket[0]));
if(exist != -1){
//Check if empty
MFS_Inode_t* this_inode = fix_inode(header, exist);
if(!(this_inode->type == MFS_DIRECTORY && this_inode->size != 0)){
//Need to remove
MFS_DirEnt_t* new_dir_entry = allot_space(&header, MFS_BLOCK_SIZE, &entry_offset);
MFS_Inode_t* new_parent_inode = allot_space(&header, sizeof(MFS_Inode_t), &parent_inode_offset);
prepare_inode(new_parent_inode, 0, parent_inode);
update_inode(&header, prot_r->pinum, parent_inode_offset);
i = 0, done = 0;
while(i < 14) {
if(parent_inode->data[i] != -1){
j = 0;
while(j < MFS_BLOCK_SIZE / sizeof(MFS_DirEnt_t)){
//printf("Parent node %d %d\n", inode->data[i], MFS_BLOCK_SIZE / sizeof(MFS_DirEnt_t) );
MFS_DirEnt_t* entry = (MFS_DirEnt_t*)(block_ptr + parent_inode->data[i] + (j * sizeof(MFS_DirEnt_t)));
if(entry->inum != -1 && strcmp(entry->name, prot_r->datapacket) == 0 ){
memcpy(new_dir_entry, block_ptr + parent_inode->data[i] , MFS_BLOCK_SIZE);
//We now know which entry
new_parent_inode->data[i] = entry_offset;
new_dir_entry[j].inum = -1;
update_inode(&header, exist, -1);
prot_r->ret = 0;
new_parent_inode->size--;
done = 1;
break;
}
j++;
}
if(done == 1) break;
}
i++;
}
}
}else{
prot_r->ret = 0;
}
}
} else if(prot_r->cmd == CMD_READ){
prot_r->ret = -1;
MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);
if(parent_inode != NULL && parent_inode->type == MFS_REGULAR_FILE && prot_r->block >= 0 && prot_r->block < 14){
//New inode
memcpy(prot_r->datapacket, block_ptr + parent_inode->data[prot_r->block], MFS_BLOCK_SIZE);
prot_r->ret = 0;
}
} else if(prot_r->cmd == CMD_STAT){
prot_r->ret = -1;
MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);
if(parent_inode != NULL && prot_r->block >= 0 && prot_r->block < 14){
//New inode
prot_r->block = parent_inode->size;
prot_r->datapacket[0] = parent_inode->type;
prot_r->ret = 0;
}
} else if(prot_r->cmd == CMD_WRITE){
verify(&header, &block_ptr, 16384);
prot_r->ret = -1;
MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);
int block_offset;
if(parent_inode != NULL && parent_inode->type == MFS_REGULAR_FILE && prot_r->block >= 0 && prot_r->block < 14){
//New inode
new_inode = (MFS_Inode_t*)allot_space(&header, sizeof(MFS_Inode_t), &inode_offset);
prepare_inode(new_inode, 0, parent_inode);
void* new_block = allot_space(&header, MFS_BLOCK_SIZE, &block_offset);
memcpy(new_block, prot_r->datapacket, MFS_BLOCK_SIZE);
i = prot_r->block;
while(new_inode->data[i] == -1 && i >= 0){
new_inode->size += MFS_BLOCK_SIZE;
new_inode->data[i] = block_offset;
i--;
}
new_inode->data[prot_r->block] = block_offset;
update_inode(&header, prot_r->pinum, inode_offset);
prot_r->ret = 0;
}
} else if(prot_r->cmd == CMD_CREAT){
verify(&header, &block_ptr, 16384);
prot_r->ret = -1;
MFS_Inode_t* parent_inode = fix_inode(header, prot_r->pinum);
int exist = lookup(block_ptr, parent_inode, &(prot_r->datapacket[1]));
if(exist == -1){
new_inode = allot_space(&header, sizeof(MFS_Inode_t), &inode_offset);
prepare_inode(new_inode, prot_r->datapacket[0], NULL);
int new_inode_inum = gen_inum(&header, inode_offset);
if(parent_inode != NULL && parent_inode->type == MFS_DIRECTORY && strlen(&(prot_r->datapacket[1])) <= 28 && new_inode_inum != -1){
//Check if the dir is full
MFS_DirEnt_t* entry;
//Initialize new data block for entries
MFS_DirEnt_t* new_entry = allot_space(&header, MFS_BLOCK_SIZE, &entry_offset);
MFS_Inode_t* new_parent_inode = allot_space(&header, sizeof(MFS_Inode_t), &parent_inode_offset);
prepare_inode(new_parent_inode, 0, parent_inode);
update_inode(&header, prot_r->pinum, parent_inode_offset);
//Copy new stuff
done = 0;
i = 0;
while(i < 14) {
if(parent_inode->data[i] != -1){
j = 0;
while(j < MFS_BLOCK_SIZE / sizeof(MFS_DirEnt_t)){
entry = (MFS_DirEnt_t*)(block_ptr + parent_inode->data[i] + (j * sizeof(MFS_DirEnt_t)));
if(entry->inum == -1){
//Copy the dir entry
memcpy(new_entry, block_ptr + parent_inode->data[i], MFS_BLOCK_SIZE);
new_parent_inode->data[i] = entry_offset;
new_entry[j].inum = new_inode_inum;
strcpy(new_entry[j].name, &(prot_r->datapacket[1]));
//printf("Name: %s - %s\n",entry->name, &(prot_r->datapacket[1]));
done = 1;
break;
}
j++;
}
if(done == 1) break;
}else{
//Create new node
//Initialize
for (j = 0; j < MFS_BLOCK_SIZE / sizeof(MFS_DirEnt_t); j++) {
new_entry[j].inum = -1;
}
new_parent_inode->data[i] = entry_offset;
new_entry[0].inum = new_inode_inum;
strcpy(new_entry[0].name, &(prot_r->datapacket[1]));
done = 1;
break;
}
i++;
}
if(done){
//Actually create the inode
//Add .. and . dirs
if(new_inode->type == MFS_DIRECTORY){
MFS_DirEnt_t* new_dir_entry = allot_space(&header, MFS_BLOCK_SIZE, &new_dir_offset);
for (i = 0; i < MFS_BLOCK_SIZE/sizeof(MFS_DirEnt_t); i++) {
new_dir_entry[i].inum = -1;
}
new_dir_entry[0].name[0] = '.';
new_dir_entry[0].name[1] = '\0';
new_dir_entry[0].inum = new_inode_inum;
new_dir_entry[1].name[0] = '.';
new_dir_entry[1].name[1] = '.';
new_dir_entry[1].name[2] = '\0';
new_dir_entry[1].inum = prot_r->pinum;
new_inode->data[0] = new_dir_offset;
}
//Write to block
new_parent_inode->size++;
header->total_inode++;
prot_r->ret = 0;
}else{
header->total_byte -= unwritten_bytes;
unwritten_bytes = 0;
}
}else{
header->total_byte -= unwritten_bytes;
unwritten_bytes = 0;
}
}else{
prot_r->ret = 0;
}
} else {
fprintf(stderr, "Unknown command");
exit(1);
continue;
}
flush(fd);
write_header(fd, header);
if(UDP_Write(sd, &s, (char*)prot_r, sizeof(MFS_Prot_t)) < -1){
fprintf(stderr, "Unable to send result");
exit(1);
}
}
}
return 0;
}
//sends packet out through socket
int sendpacket(char message[BUFFER_SIZE]){
if (DEBUG) printf("CLIENT:: about to send message (%d)\n", rc);
rc = UDP_Write(sd, &saddr, message, BUFFER_SIZE);
if (DEBUG) printf("CLIENT:: sent message (%d)\n", rc);
return 0;
}
int transmit() {
return UDP_Write(sd, &saddr, (char*) &message, sizeof(MFS_Transmit_t));
}
