File Transfer returns weird characters

Question

So I'm trying to create a simple file transfer method. It's completely working for small files (a few bytes). But if I want to transfer a file with the size of 2 kB, it returns unicode characters instead of that what's inside the file.

Server:

void DownloadFile(SOCKET Socket){
    if(Socket == NULL){
        return;
    }
    while(1){
        char filename[1024];
        recv(Socket, filename, sizeof(filename), 0);
        if(filename[0] == '.'){
            break;
        }
        FILE* fp = fopen(filename, "r");
        fseek(fp, 0, SEEK_END);
        long FileSize = ftell(fp);
        char GotFileSize[1024];
        _itoa_s(FileSize, GotFileSize, 10);
        send(Socket, GotFileSize, 1024, 0);
        rewind(fp);


        long SizeCheck = 0;
        char* mfcc;

        if(FileSize > 1499){
            mfcc = (char*)malloc(1500);
            while(1){
                if(SizeCheck >= FileSize){
                    fclose(fp);
                    Sleep(500);
                    free(mfcc);
                    break;
                }
                fread_s(mfcc, 1499, sizeof(char), 1499, fp);
                send(Socket, mfcc, FileSize, 0);
                SizeCheck += strlen(mfcc);
            }
        }
        else{
            mfcc = (char*)malloc(FileSize + 1);
            fread_s(mfcc, FileSize, sizeof(char), FileSize, fp);
            send(Socket, mfcc, FileSize, 0);
            fclose(fp);
            Sleep(500);
            free(mfcc);
        }
    }
    return;
}

Client:

void DownloadFile(SOCKET Socket){
    if(Socket == NULL){
        return;
    }
    while(1){
        printf("Input local filename: ");
        char localfile[1024];
        gets_s(localfile, 1024);
        if(localfile[0] == '.'){
            send(mySocket, localfile, sizeof(localfile), 0);
            break;
        }
        printf("Input remote filename: ");
        char filename[1024];
        gets_s(filename, 1024);
        if(filename[0] == '.'){
            send(mySocket, filename, sizeof(filename), 0);
            break;
        }
        send(mySocket, filename, sizeof(filename), 0);
        char GotFileSize[1024];
        recv(mySocket, GotFileSize, 1024, 0);
        long FileSize = atoi(GotFileSize);
        long SizeCheck = 0;
        FILE *fp = fopen(localfile, "w");
        char* mfcc;
        if(FileSize > 1499){
            mfcc = (char*)malloc(1500);
            while(1){
                if(SizeCheck >= FileSize){
                    fclose(fp);
                    Sleep(500);
                    free(mfcc);
                    break;
                }
                recv(mySocket, mfcc, 1499, 0);
                fprintf(fp, "%s", mfcc);
                SizeCheck += strlen(mfcc);
            }
        }
        else{
            mfcc = (char*)malloc(FileSize + 1);
            recv(mySocket, mfcc, FileSize, 0);
            fprintf(fp, "%s", mfcc);
            fclose(fp);
            Sleep(500);
            free(mfcc);
        }
    }
}

Now, if I transfer this file:

Testtesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttest

The transfered file contains this:

Testtesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttest
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
𭺫«««««««îþîþtesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesº««««««««îþîþttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttestesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttesttest
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
ð­º
𭺫«««««««îþîþ

Answer 1

Fixed it. A newline is 2 bytes in size, but my program only counted it as one. I figured this because the difference between Filesize and Sizecheck is in fact the amount of lines in the file.

New loop:

char* mfcc;
mfcc = (char*)malloc(FileSize + 1);
while(SizeCheck {issmallerthan} FileSize){
    int Received = recv(mySocket, mfcc, FileSize, 0);
    int Written = fwrite(mfcc, sizeof(char), Received, fp);
    SizeCheck += Written;
    for(int i = 0; i {issmallerthan} Written; i++){
        if(mfcc[i] == '\n'){
            SizeCheck += 1;
        }
    }
}
fclose(fp);
free(mfcc);

The sender part is like this one.

Thanks for the help all. :3

Case closed. :D

Answer 2

Why this:

            fread_s(mfcc, 1499, sizeof(char), 1499, fp);
            send(Socket, mfcc, FileSize, 0);

you are sending FileSize bytes but you don't even know how much you've read. Check the return value of the read, don't use strlen() for this for you don't know if the file contains 0 bytes.