static int fuse_unlink(const char *path)
{
int res;
char filename[MAXFILENAME];
printf("unlink\n");
strcpy(filename, path);
res = sfs_remove(filename);
if (res == -1)
return -errno;
return 0;
}
static int fuse_truncate(const char *path, off_t size)
{
char filename[MAXFILENAME];
int fd;
strcpy(filename, path);
fd = sfs_remove(filename);
if (fd == -1)
return -errno;
fd = sfs_fopen(filename);
sfs_fclose(fd);
return 0;
}
void browse_sfs(int sfs_handle)
{
int done;
char cmd[256], *fn;
int ret, perm;
done = 0;
printf("Welcome to SFS Browsing Shell v3.0\n\n");
printf("Block size : %d bytes\n", sb.block_size);
printf("Partition size : %d blocks\n", sb.partition_size);
printf("File entry size: %d bytes\n", sb.entry_size);
printf("Entry tbl size : %d blocks\n", sb.entry_table_size);
printf("Entry count : %d\n", sb.entry_count);
printf("\n");
init_browsing(sfs_handle);
while (!done)
{
printf(" $> ");
ret = scanf("%[^\n]", cmd);
if (ret < 0)
{
done = 1;
printf("\n");
continue;
}
else
{
getchar();
if (ret == 0) continue;
}
if (strcmp(cmd, "?") == 0)
{
usage();
continue;
}
else if (strcmp(cmd, "quit") == 0)
{
done = 1;
continue;
}
else if (strcmp(cmd, "list") == 0)
{
sfs_list(sfs_handle);
continue;
}
else if (strncmp(cmd, "create", 6) == 0)
{
if (cmd[6] == ' ')
{
fn = cmd + 7;
while (*fn == ' ') fn++;
if (*fn != '\0')
{
sfs_create(sfs_handle, fn);
continue;
}
}
}
else if (strncmp(cmd, "remove", 6) == 0)
{
if (cmd[6] == ' ')
{
fn = cmd + 7;
while (*fn == ' ') fn++;
if (*fn != '\0')
{
sfs_remove(sfs_handle, fn);
continue;
}
}
}
else if (strncmp(cmd, "chperm", 6) == 0)
{
if (cmd[6] == ' ')
{
perm = cmd[7] - '0';
if ((0 <= perm) && (perm <= 7) && (cmd[8] == ' '))
{
fn = cmd + 9;
while (*fn == ' ') fn++;
if (*fn != '\0')
{
sfs_chperm(sfs_handle, fn, perm);
continue;
}
}
}
}
else if (strncmp(cmd, "read", 4) == 0)
{
if (cmd[4] == ' ')
{
fn = cmd + 5;
while (*fn == ' ') fn++;
if (*fn != '\0')
{
sfs_read(sfs_handle, fn);
continue;
}
}
}
else if (strncmp(cmd, "write", 5) == 0)
{
if (cmd[5] == ' ')
{
fn = cmd + 6;
while (*fn == ' ') fn++;
if (*fn != '\0')
{
sfs_write(sfs_handle, fn);
continue;
}
}
}
printf("Unknown/Incorrect command: %s\n", cmd);
usage();
}
shut_browsing(sfs_handle);
}
/* The main testing program
*/
int
main(int argc, char **argv)
{
int i, j, k;
int chunksize;
char *buffer;
char fixedbuf[1024];
int fds[MAX_FD];
char *names[MAX_FD];
int filesize[MAX_FD];
int nopen; /* Number of files simultaneously open */
int ncreate; /* Number of files created in directory */
int error_count = 0;
int tmp;
mksfs(1); /* Initialize the file system. */
/* First we open two files and attempt to write data to them.
*/
for (i = 0; i < 2; i++) {
names[i] = rand_name();
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
fprintf(stderr, "ERROR: creating first test file %s\n", names[i]);
error_count++;
}
tmp = sfs_fopen(names[i]);
if (tmp >= 0 && tmp != fds[i]) {
fprintf(stderr, "ERROR: file %s was opened twice\n", names[i]);
error_count++;
}
filesize[i] = (rand() % (MAX_BYTES-MIN_BYTES)) + MIN_BYTES;
}
for (i = 0; i < 2; i++) {
for (j = i + 1; j < 2; j++) {
if (fds[i] == fds[j]) {
fprintf(stderr, "Warning: the file descriptors probably shouldn't be the same?\n");
}
}
}
printf("Two files created with zero length:\n");
sfs_ls();
printf("\n");
for (i = 0; i < 2; i++) {
for (j = 0; j < filesize[i]; j += chunksize) {
if ((filesize[i] - j) < 10) {
chunksize = filesize[i] - j;
}
else {
chunksize = (rand() % (filesize[i] - j)) + 1;
}
if ((buffer = malloc(chunksize)) == NULL) {
fprintf(stderr, "ABORT: Out of memory!\n");
exit(-1);
}
for (k = 0; k < chunksize; k++) {
buffer[k] = (char) (j+k);
}
printf("file: %d, chunksize: %d\n", i, chunksize);
sfs_ls();
sfs_fwrite(fds[i], buffer, chunksize);
free(buffer);
}
}
sfs_fclose(fds[1]);
printf("File %s now has length %d and %s now has length %d:\n",
names[0], filesize[0], names[1], filesize[1]);
sfs_ls();
fds[1] = sfs_fopen(names[1]);
printf("before doing reads\n\n");
for (i = 0; i < 2; i++) {
for (j = 0; j < filesize[i]; j += chunksize) {
if ((filesize[i] - j) < 10) {
chunksize = filesize[i] - j;
}
else {
chunksize = (rand() % (filesize[i] - j)) + 1;
}
if ((buffer = malloc(chunksize)) == NULL) {
fprintf(stderr, "ABORT: Out of memory!\n");
exit(-1);
}
printf("before sfs_read\n\n");
sfs_fread(fds[i], buffer, chunksize);
printf("After sfs_read\n\n");
/*
for (k = 0; k < chunksize; k++) {
if (buffer[k] != (char)(j+k)) {
fprintf(stderr, "ERROR: data error at offset %d in file %s (%d,%d)\n",
j+k, names[i], buffer[k], (char)(j+k));
error_count++;
break;
}
}
*/
free(buffer);
printf("After doing reads %d\n\n", i);
}
}
printf("After doing reads\n\n");
for (i = 0; i < 2; i++) {
sfs_fclose(fds[i]);
if (sfs_remove(names[i]) != 0) {
fprintf(stderr, "ERROR: deleting file %s\n", names[i]);
error_count++;
}
printf("After deleting file %s:\n", names[i]);
sfs_ls();
}
/* Now try to close and delete the closed and deleted files. Don't
* care about the return codes, really, but just want to make sure
* this doesn't cause a problem.
*/
for (i = 0; i < 2; i++) {
sfs_fclose(fds[i]);
if (sfs_remove(names[i]) == 0) {
fprintf(stderr, "Warning: deleting already deleted file %s\n", names[i]);
}
//free(names[i]);
names[i] = NULL;
}
/* Now just try to open up a bunch of files.
*/
ncreate = 0;
for (i = 0; i < MAX_FD; i++) {
names[i] = rand_name();
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
break;
}
sfs_fclose(fds[i]);
ncreate++;
}
printf("Created %d files in the root directory\n", ncreate);
nopen = 0;
for (i = 0; i < ncreate; i++) {
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
break;
}
nopen++;
}
printf("Simultaneously opened %d files\n", nopen);
for (i = 0; i < nopen; i++) {
sfs_fwrite(fds[i], test_str, strlen(test_str));
sfs_fclose(fds[i]);
}
/* Re-open in reverse order */
for (i = nopen-1; i >= 0; i--) {
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
fprintf(stderr, "ERROR: can't re-open file %s\n", names[i]);
}
}
/* Now test the file contents.
*/
for (j = 0; j < strlen(test_str); j++) {
for (i = 0; i < nopen; i++) {
char ch;
sfs_fread(fds[i], &ch, 1);
if (ch != test_str[j]) {
fprintf(stderr, "ERROR: Read wrong byte from %s at %d (%d,%d)\n",
names[i], j, ch, test_str[j]);
error_count++;
break;
}
}
}
/* Now close all of the open file handles.
*/
for (i = 0; i < nopen; i++) {
sfs_fclose(fds[i]);
}
/* Now we try to re-initialize the system.
*/
mksfs(0);
for (i = 0; i < nopen; i++) {
fds[i] = sfs_fopen(names[i]);
if (fds[i] >= 0) {
sfs_fread(fds[i], fixedbuf, sizeof(fixedbuf));
for (j = 0; j < strlen(test_str); j++) {
if (test_str[j] != fixedbuf[j]) {
fprintf(stderr, "ERROR: Wrong byte in %s at %d (%d,%d)\n",
names[i], j, fixedbuf[j], test_str[j]);
error_count++;
break;
}
}
sfs_fclose(fds[i]);
}
}
for (i = 0; i < ncreate; i++) {
sfs_remove(names[i]);
free(names[i]);
names[i] = NULL;
}
//-------- The following part tests sfs_fseek
printf("Tests sfs_fseek\n");
// Prepare a file
char* f_name = rand_name();
int f_id = sfs_fopen(f_name);
buffer = malloc(100);
for(i = 0; i < 10; i++)
{
sfs_fwrite(f_id, "0123456789", 10);
}
// sfs_fwrite shouldn't change read pointer
for(i = 0; i < 10; i++)
{
sfs_fread(f_id, buffer, 10);
if(0 != strncmp(buffer, "0123456789", 10))
{
fprintf(stderr, "ERROR: should read '0123456789'\n");
error_count++;
}
}
// sys_seek changes read pointer
for(i = 0; i < 100; i += 7)
{
sfs_fseek(f_id, i);
sfs_fread(f_id, buffer, 1);
if (buffer[0] - 48 != i % 10) {
fprintf(stderr, "ERROR: postion %d shoud be %c\n", i, i % 10);
error_count++;
}
}
sfs_fseek(f_id, 80);
sfs_fwrite(f_id, "9876543210", 10);
sfs_fseek(f_id, 85);
sfs_fread(f_id, buffer, 10);
if(0 != strncmp(buffer, "4321001234", 10))
{
fprintf(stderr, "ERROR: should read '4321001234'\n");
error_count++;
}
//free(buffer);
fprintf(stderr, "Test program exiting with %d errors\n", error_count);
return (error_count);
}
/* The main testing program
*/
int
main(int argc, char **argv)
{
int i, j, k;
int chunksize;
int readsize;
char *buffer;
char fixedbuf[1024];
int fds[MAX_FD];
char *names[MAX_FD];
int filesize[MAX_FD];
int nopen; /* Number of files simultaneously open */
int ncreate; /* Number of files created in directory */
int error_count = 0;
int tmp;
mksfs(1); /* Initialize the file system. */
/* First we open two files and attempt to write data to them.
*/
{
char fname[MAX_FILE_NAME+10];
int i;
for (i = 0; i < MAX_FILE_NAME+10; i++) {
if (i != 8) {
fname[i] = 'A' + (rand() % 26);
}
else {
fname[i] = '.';
}
}
fname[i] = '\0';
int derp = sfs_fopen(fname);
if (derp >= 0) {
fprintf(stderr, "ERROR: creating file with too long name\n");
error_count++;
}
}
for (i = 0; i < 2; i++) {
names[i] = rand_name();
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
fprintf(stderr, "ERROR: creating first test file %s\n", names[i]);
error_count++;
}
tmp = sfs_fopen(names[i]);
if (tmp >= 0 && tmp != fds[i]) {
fprintf(stderr, "ERROR: file %s was opened twice\n", names[i]);
error_count++;
}
filesize[i] = (rand() % (MAX_BYTES-MIN_BYTES)) + MIN_BYTES;
}
for (i = 0; i < 2; i++) {
for (j = i + 1; j < 2; j++) {
if (fds[i] == fds[j]) {
fprintf(stderr, "Warning: the file descriptors probably shouldn't be the same?\n");
}
}
}
printf("Two files created with zero length:\n");
for (i = 0; i < 2; i++) {
for (j = 0; j < filesize[i]; j += chunksize) {
if ((filesize[i] - j) < 10) {
chunksize = filesize[i] - j;
}
else {
chunksize = (rand() % (filesize[i] - j)) + 1;
}
if ((buffer = malloc(chunksize)) == NULL) {
fprintf(stderr, "ABORT: Out of memory!\n");
exit(-1);
}
for (k = 0; k < chunksize; k++) {
buffer[k] = (char) (j+k);
}
tmp = sfs_fwrite(fds[i], buffer, chunksize);
if (tmp != chunksize) {
fprintf(stderr, "ERROR: Tried to write %d bytes, but wrote %d\n",
chunksize, tmp);
error_count++;
}
free(buffer);
}
int tmp = sfs_getfilesize(names[i]);
if (filesize[i] != tmp) {
fprintf(stderr, "ERROR: mismatch file size %d, %d\n", filesize[i], tmp);
error_count++;
}
}
if (sfs_fclose(fds[1]) != 0) {
fprintf(stderr, "ERROR: close of handle %d failed\n", fds[1]);
error_count++;
}
/* Sneaky attempt to close already closed file handle. */
if (sfs_fclose(fds[1]) == 0) {
fprintf(stderr, "ERROR: close of stale handle %d succeeded\n", fds[1]);
error_count++;
}
printf("File %s now has length %d and %s now has length %d:\n",
names[0], filesize[0], names[1], filesize[1]);
/* Just to be cruel - attempt to read from a closed file handle.
*/
if (sfs_fread(fds[1], fixedbuf, sizeof(fixedbuf)) > 0) {
fprintf(stderr, "ERROR: read from a closed file handle?\n");
error_count++;
}
fds[1] = sfs_fopen(names[1]);
sfs_fseek(fds[0], 0);
sfs_fseek(fds[1], 0);
for (i = 0; i < 2; i++) {
for (j = 0; j < filesize[i]; j += chunksize) {
if ((filesize[i] - j) < 10) {
chunksize = filesize[i] - j;
}
else {
chunksize = (rand() % (filesize[i] - j)) + 1;
}
if ((buffer = malloc(chunksize)) == NULL) {
fprintf(stderr, "ABORT: Out of memory!\n");
exit(-1);
}
readsize = sfs_fread(fds[i], buffer, chunksize);
if (readsize != chunksize) {
fprintf(stderr, "ERROR: Requested %d bytes, read %d\n", chunksize, readsize);
readsize = chunksize;
}
for (k = 0; k < readsize; k++) {
if (buffer[k] != (char)(j+k)) {
fprintf(stderr, "ERROR: data error at offset %d in file %s (%d,%d)\n",
j+k, names[i], buffer[k], (char)(j+k));
error_count++;
break;
}
}
free(buffer);
}
}
for (i = 0; i < 2; i++) {
if (sfs_fclose(fds[i]) != 0) {
fprintf(stderr, "ERROR: closing file %s\n", names[i]);
error_count++;
}
}
/* Now try to close the files. Don't
* care about the return codes, really, but just want to make sure
* this doesn't cause a problem.
*/
for (i = 0; i < 2; i++) {
if (sfs_fclose(fds[i]) == 0) {
fprintf(stderr, "Warning: closing already closed file %s\n", names[i]);
}
}
sfs_remove(names[0]);
sfs_remove(names[1]);
/* Now just try to open up a bunch of files.
*/
ncreate = 0;
for (i = 0; i < MAX_FD; i++) {
names[i] = rand_name();
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
break;
}
sfs_fclose(fds[i]);
ncreate++;
}
printf("Created %d files in the root directory\n", ncreate);
nopen = 0;
for (i = 0; i < ncreate; i++) {
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
break;
}
nopen++;
}
printf("Simultaneously opened %d files\n", nopen);
for (i = 0; i < nopen; i++) {
tmp = sfs_fwrite(fds[i], test_str, strlen(test_str));
if (tmp != strlen(test_str)) {
fprintf(stderr, "ERROR: Tried to write %d, returned %d\n",
(int)strlen(test_str), tmp);
error_count++;
}
if (sfs_fclose(fds[i]) != 0) {
fprintf(stderr, "ERROR: close of handle %d failed\n", fds[i]);
error_count++;
}
}
/* Re-open in reverse order */
for (i = nopen-1; i >= 0; i--) {
fds[i] = sfs_fopen(names[i]);
if (fds[i] < 0) {
fprintf(stderr, "ERROR: can't re-open file %s\n", names[i]);
}
}
/* Now test the file contents.
*/
for (i = 0; i < nopen; i++) {
sfs_fseek(fds[i], 0);
}
for (j = 0; j < strlen(test_str); j++) {
for (i = 0; i < nopen; i++) {
char ch;
if (sfs_fread(fds[i], &ch, 1) != 1) {
fprintf(stderr, "ERROR: Failed to read 1 character\n");
error_count++;
}
if (ch != test_str[j]) {
fprintf(stderr, "ERROR: Read wrong byte from %s at %d (%d,%d)\n",
names[i], j, ch, test_str[j]);
error_count++;
break;
}
}
}
/* Now close all of the open file handles.
*/
for (i = 0; i < nopen; i++) {
if (sfs_fclose(fds[i]) != 0) {
fprintf(stderr, "ERROR: close of handle %d failed\n", fds[i]);
error_count++;
}
}
/* Now we try to re-initialize the system.
*/
mksfs(0);
for (i = 0; i < nopen; i++) {
fds[i] = sfs_fopen(names[i]);
sfs_fseek(fds[i], 0);
if (fds[i] >= 0) {
readsize = sfs_fread(fds[i], fixedbuf, sizeof(fixedbuf));
if (readsize != strlen(test_str)) {
fprintf(stderr, "ERROR: Read wrong number of bytes\n");
error_count++;
}
for (j = 0; j < strlen(test_str); j++) {
if (test_str[j] != fixedbuf[j]) {
fprintf(stderr, "ERROR: Wrong byte in %s at %d (%d,%d)\n",
names[i], j, fixedbuf[j], test_str[j]);
printf("%d\n", fixedbuf[1]);
error_count++;
break;
}
}
if (sfs_fclose(fds[i]) != 0) {
fprintf(stderr, "ERROR: close of handle %d failed\n", fds[i]);
error_count++;
}
}
}
printf("Trying to fill up the disk with repeated writes to %s.\n", names[0]);
printf("(This may take a while).\n");
/* Now try opening the first file, and just write a huge bunch of junk.
* This is just to try to fill up the disk, to see what happens.
*/
fds[0] = sfs_fopen(names[0]);
if (fds[0] >= 0) {
for (i = 0; i < 100000; i++) {
int x;
if ((i % 100) == 0) {
fprintf(stderr, "%d\r", i);
}
memset(fixedbuf, (char)i, sizeof(fixedbuf));
x = sfs_fwrite(fds[0], fixedbuf, sizeof(fixedbuf));
if (x != sizeof(fixedbuf)) {
/* Sooner or later, this write should fail. The only thing is that
* it should fail gracefully, without any catastrophic errors.
*/
printf("Write failed after %d iterations.\n", i);
printf("If the emulated disk contains just over %d bytes, this is OK\n",
(i * (int)sizeof(fixedbuf)));
break;
}
}
sfs_fclose(fds[0]);
}
else {
fprintf(stderr, "ERROR: re-opening file %s\n", names[0]);
}
printf("Directory listing\n");
char *filename = (char *)malloc(MAX_FILE_NAME);
int max = 0;
while (sfs_getnextfilename(filename)) {
if (strcmp(filename, names[max]) != 0) {
printf("ERROR misnamed file %d: %s %s\n", max, filename, names[max]);
error_count++;
}
max++;
}
/* Now, having filled up the disk, try one more time to read the
* contents of the files we created.
*/
for (i = 0; i < nopen; i++) {
fds[i] = sfs_fopen(names[i]);
sfs_fseek(fds[i], 0);
if (fds[i] >= 0) {
readsize = sfs_fread(fds[i], fixedbuf, sizeof(fixedbuf));
if (readsize < strlen(test_str)) {
fprintf(stderr, "ERROR: Read wrong number of bytes\n");
error_count++;
}
for (j = 0; j < strlen(test_str); j++) {
if (test_str[j] != fixedbuf[j]) {
fprintf(stderr, "ERROR: Wrong byte in %s at position %d (%d,%d)\n",
names[i], j, fixedbuf[j], test_str[j]);
error_count++;
break;
}
}
if (sfs_fclose(fds[i]) != 0) {
fprintf(stderr, "ERROR: close of handle %d failed\n", fds[i]);
error_count++;
}
}
}
for (i = 0; i < max; i++) {
sfs_remove(names[i]);
}
if (sfs_getnextfilename(filename)) {
fprintf(stderr, "ERROR: should be empty dir\n");
error_count++;
}
fprintf(stderr, "Test program exiting with %d errors\n", error_count);
return (error_count);
}
int main(int argc, char *argv[]) {
if ( argc == 2 ) {
port = strtol(argv[1], &endptr, 0);
if ( *endptr ) {
fprintf(stderr, "Invalid port number.\n");
exit(EXIT_FAILURE);
}
}
else if ( argc < 2 ) {
port = ecPort;
}
else {
fprintf(stderr, "Invalid arguments\n");
exit(EXIT_FAILURE);
}
fileSystemInit();
connection_setup();
if ( (connS = accept(listS, NULL, NULL) ) < 0 ) {
fprintf(stderr, "Error!!\n");
exit(EXIT_FAILURE);
}
header = (char *)malloc(2 * sizeof(int));
elreadmos = (char *)malloc(10000);
myLStable = (char *)malloc(100);
while ( 1 ) {
recieveing(connS, recEI, 2 * sizeof(int));
memcpy(&recvReq, recEI, sizeof(int));
memcpy(&recvSize, recEI +sizeof(int), sizeof(int));
switch (recvReq) {
case 1:
printf("root directory\n");
LStableAdd = sfs_ls();
strcpy(myLStable, LStableAdd);
size = strlen(myLStable);
DataSend = (char *)malloc(size);
memcpy(header, &lsCom, sizeof(int));
memcpy(header+sizeof(int), &size, sizeof(int));
memcpy(DataSend, myLStable, size);
Sending(connS, header, (2 * sizeof(int)));
Sending(connS, DataSend, size);
free(DataSend);
break;
case 2:
printf("open file\n");
recData = (char *)malloc(recvSize);
recieveing(connS, recData, recvSize);
memcpy(openReq, recData, recvSize);
openReq[recvSize] = 0;
remID = sfs_open(openReq);
DataSend = (char *)malloc(sizeof(int));
size = sizeof(int);
memcpy(header, &opCom, sizeof(int));
memcpy(header+sizeof(int), &size, sizeof(int));
memcpy(DataSend, &remID, size);
Sending(connS, header, (2 * sizeof(int)));
Sending(connS, DataSend, size);
free(recData);
free(DataSend);
break;
case 3:
printf("close file\n");
recData = (char *)malloc(recvSize);
recieveing(connS, recData, recvSize);
memcpy(&elremote, recData, sizeof(int));
sfs_close(elremote);
memcpy(header, &closeCom, sizeof(int));
memcpy(header+sizeof(int), &size, sizeof(int));
Sending(connS, header, (2 * sizeof(int)));
free(recData);
break;
case 4:
printf("write file\n");
recData = (char *)malloc(recvSize);
elWritBuf = (char *)malloc(recvSize);
recieveing(connS, recData, recvSize - 8);
memcpy(elWritBuf, recData, recvSize -8);
elWritBuf[recvSize - 8] = 0;
recieveing(connS, recData, sizeof(int));
memcpy(&remID, recData, sizeof(int));
recieveing(connS, recData, sizeof(int));
memcpy(&my_len, recData, sizeof(int));
sfs_write(remID, elWritBuf, my_len);
size = 0;
memcpy(header, &writCom, sizeof(int));
memcpy(header+sizeof(int), &size, sizeof(int));
Sending(connS, header, (2 * sizeof(int)));
free(recData);
free(elWritBuf);
break;
case 5:
printf("read file\n");
recData = (char *)malloc(recvSize);
recieveing(connS, recData, sizeof(int));
memcpy(&remID, recData, sizeof(int));
recieveing(connS, recData, sizeof(int));
memcpy(&my_len, recData, sizeof(int));
sfs_read(remID, elreadmos, my_len);
size = strlen(elreadmos);
memcpy(header, &readCom, sizeof(int));
memcpy(header+sizeof(int), &size, sizeof(int));
Sending(connS, header, (2 * sizeof(int)));
DataSend = (char *)malloc(size);
memcpy(DataSend, elreadmos, size);
DataSend[size] = 0;
puts(DataSend);
Sending(connS, DataSend, size);
break;
case 6:
printf("remove file\n");
recData = (char *)malloc(recvSize);
recieveing(connS, recData, recvSize);
memcpy(remReq, recData, recvSize);
remReq[recvSize] = 0;
printf("file to remove = %s\n",remReq);
if (sfs_remove(remReq) == -1){
size = strlen("Error: file doesnot exist\n");
DataSend = (char *)malloc(size);
strcpy(DataSend, "Error: file doesnt exist\n");
}
else{
size = strlen("file removed successfully\n");
DataSend = (char *)malloc(size);
strcpy(DataSend, "file remove successfull\n");
}
memcpy(header, &remCom, sizeof(int));
memcpy(header+sizeof(int), &size, sizeof(int));
Sending(connS, header, (2 * sizeof(int)));
Sending(connS, DataSend, size);
free(recData);
free(DataSend);
break;
default:
printf("Invalid input\n");
break;
}
}
}
