Senden Sie die binäre Datei über TCP/IP-Verbindung

Werde ich umformulieren, die ganze Frage hier, so dass es zu vertreten hat.

Ich bin in der Lage zu kopieren Binärdatei perfekt in der gleichen Maschine nicht über sockets, sondern nur eine einfache Kopie-Funktion. Zu versuchen, diesen code für das kopieren auf eine TCP/IP Verbindung, aber kann nicht ankommen es zu wirken.

FILE *filehandle = fopen("imagefile.jpg", "rb");
FILE *dest  =fopen("imagecopy.jpg", "wb");    //copied image file
fseek(filehandle, 0, SEEK_END);
unsigned long filesize = ftell(filehandle);
char *buffer = (char*)malloc(sizeof(char)*filesize);
rewind(filehandle);
int bytesread = fread(buffer, sizeof(char), filesize, filehandle);
for( int i=0; i<filesize; i++ )
{
    fputc(buffer[i], filehandle);    //copies all the contents to dest
}

Den code oben funktioniert perfekt für das kopieren einer image-Datei im computer aber wenn umgesetzt, um die Kopie auf dem server, ist es schwierig, darüber zu gehen.

Ich bin versucht, senden Sie eine image-Datei von einer server zu einem client beiden denen gemacht wurden manuell in C. Die Länge der Datei, die vom server gesendet wurden, ist nur bekannt auf dem server, wenn es beim senden der Datei, damit der Puffer wird dynamisch generiert, in den server, so etwas wie dieses:

SERVER

fseek(filehandle, 0, SEEK_END);
long filesize = ftell(filehandle);    //file could be 11000bytes
char *buffer = (char*)malloc(sizeof(char)*filesize);    //char buffer with 11000 bytes to store the data from the file.
//then I call the send() function
rewind(filehandle);    //go back to beginning
send(clientsocket, buffer, filesize, 0);    //this is being sent perfectly, no errors because in the actual code, I am checking for errors

CLIENT

//here is where I don't understand how to dynamically allocate the 11000 bytes to store the data in a client buffer
//the filesize is not necessarily going to be 11000 so need to dynamically allocate
//I did the following:
#define BUFSIZE 10
FILE *filehandle = fopen("imagefile.jpg", "wb");    //image file created by client
char *buffer = (char*)malloc(sizeof(char)*BUFSIZE);
int bytesread = recv(buffer, 1, strlen(buffer), 0);
if( bytesread > 0 )
{
    printf("Bytes read: %d\n", bytesread);    //bytes read is 5
    printf("Buffer: %s\n", buffer);    //but buffer shows all the binary text like it normally would
    //when I try to store buffer in a file, it doesn't put full buffer because only 5 characters are written
    for( int i=0; i<bytesread; i++ )
    {
        fputc(buffer[i], filehandle);    //this doesn't create full image
    }
}

Wie kann ich dynamisch reservieren die 11000 bytes, die vom server gesendet?

Sie Fragen sich, warum der code, den Sie nicht zeigen, nicht funktioniert?
Undefiniertes Verhalten ist genau das – nicht definiert. Es ist nicht erforderlich, zum Absturz zu bringen.
es ist unklar, warum Sie mit printf("%s" Anzeige einer Bild-Datei
und sizeof bufffer ist die Größe der Zeiger, nicht der Speicherblock, der es Punkte zu.
Dies ist nicht ganz das, UB, wenn er fixiert das sizeof bufffer Teil - es würde nicht wirklich überrannt, da der code übergeben, die Länge der kleinen zugewiesenen Puffer geändert wird (oder zumindest versucht), um recv.
Haben den server senden, die Größe der Datei erst, dann kann der client verwenden, um über die Größe des Puffers zuweisen.
ich dachte an das, aber es ist nicht zur Arbeit gehen, weil dann würde ich noch zuteilen müssen die char für eingehende filesize Länge, die ich brauche, um zu wissen, die genaue Größe zu erhalten, die image-Datei korrekt über den server zum client.
WIRD es funktionieren. Sie NICHT (und SOLLTE NICHT) weisen einen einzigen Puffer zum senden/empfangen der gesamte Inhalt der Datei auf einmal. Insbesondere bei großen Dateien. Griff es fester Länge Blöcken statt. Auch die variable enthält die Dateigröße selbst behandelt werden können als in einem fixed-size-buffer. Siehe meine Antwort für ein Beispiel. Es sendet die Dateigröße gefolgt von der Datei, die Daten, liest dann die Dateigröße gefolgt von der Datei Daten.

InformationsquelleAutor Hawk | 2014-09-03

c c++file-io malloc winsock

Müssen Sie eine Schleife sowohl das senden und empfangen. Weder send() noch recv() sind garantiert zu senden/Lesen so viele bytes, wie von Ihnen gewünscht.

Sollten Sie auch senden Sie die Größe der Datei, bevor die Datei Daten, damit der Empfänger weiß, wie viele bytes zu erwarten ist und Wann Sie aufhören zu Lesen.

Versuchen, so etwas wie dieses:

SERVER

bool senddata(SOCKET sock, void *buf, int buflen)
{
    unsigned char *pbuf = (unsigned char *) buf;

    while (buflen > 0)
    {
        int num = send(sock, pbuf, buflen, 0);
        if (num == SOCKET_ERROR)
        {
            if (WSAGetLastError() == WSAEWOULDBLOCK)
            {
                //optional: use select() to check for timeout to fail the send
                continue;
            }
            return false;
        }

        pbuf += num;
        buflen -= num;
    }

    return true;
}

bool sendlong(SOCKET sock, long value)
{
    value = htonl(value);
    return senddata(sock, &value, sizeof(value));
}

bool sendfile(SOCKET sock, FILE *f)
{
    fseek(f, 0, SEEK_END);
    long filesize = ftell(f);
    rewind(f);
    if (filesize == EOF)
        return false;
    if (!sendlong(sock, filesize))
        return false;
    if (filesize > 0)
    {
        char buffer[1024];
        do
        {
            size_t num = min(filesize, sizeof(buffer));
            num = fread(buffer, 1, num, f);
            if (num < 1)
                return false;
            if (!senddata(sock, buffer, num, 0))
                return false;
            filesize -= num;
        }
        while (filesize > 0);
    }
    return true;
}

FILE *filehandle = fopen("imagefile.jpg", "rb");
if (filehandle != NULL)
{
    sendfile(clientsocket, filehandle);
    fclose(filehandle);
}

CLIENT

bool readdata(SOCKET sock, void *buf, int buflen)
{
    unsigned char *pbuf = (unsigned char *) buf;

    while (buflen > 0)
    {
        int num = recv(sock, pbuf, buflen, 0);
        if (num == SOCKET_ERROR)
        {
            if (WSAGetLastError() == WSAEWOULDBLOCK)
            {
                //optional: use select() to check for timeout to fail the read
                continue;
            }
            return false;
        }
        else if (num == 0)
            return false;

        pbuf += num;
        buflen -= num;
    }

    return true;
}

bool readlong(SOCKET sock, long *value)
{
    if (!readdata(sock, value, sizeof(value)))
        return false;
    *value = ntohl(*value);
    return true;
}

bool readfile(SOCKET sock, FILE *f)
{
    long filesize;
    if (!readlong(sock, &filesize))
        return false;
    if (filesize > 0)
    {
        char buffer[1024];
        do
        {
            int num = min(filesize, sizeof(buffer));
            if (!readdata(sock, buffer, num))
                return false;
            int offset = 0;
            do
            {
                size_t written = fwrite(&buffer[offset], 1, num-offset, f);
                if (written < 1)
                    return false;
                offset += written;
            }
            while (offset < num);
            filesize -= num;
        }
        while (filesize > 0);
    }
    return true;
}

FILE *filehandle = fopen("imagefile.jpg", "wb");
if (filehandle != NULL)
{
    bool ok = readfile(clientsocket, filehandle);
    fclose(filehandle);

    if (ok)
    {
        //use file as needed...
    }
    else
        remove("imagefile.jpg");
}

nicht der Puffer 1024 zu klein für die Dateigröße, die vom server gesendet?
Nein, da der receiver ist looping, Lesen in 1024 byte-Blöcken, bis das Ende der Datei wurde empfangen.
Sie müssen aufhören zu versuchen, reserviert einen Puffer für die gesamte Datei auf einmal. Man, dass ist nicht effizient. Zwei, Sie verschwenden Zeit und Speicher für große Dateien. Senden Sie die Quell-Datei in Stücke, wie Sie Lesen. Schreiben Sie die Ziel-Datei in Stücke, wie Sie sind, es zu empfangen.
Bekomme ich den code jetzt @RemyLebeau, ich verstehe, wie es funktioniert, aber ich fand einen anderen Weg, es zu tun. Senden Sie einfach eine header-zunächst nur als T. C beschrieben. Es funktioniert und dieser code ist auch gut so, ich werde es akzeptieren, wie die Antwort.
Dies ersparte mir eine ganze Menge Frust, vielen Dank für den Austausch.
Tolle und bereichernde Antwort! Es ist ein bisschen bedauerlich, dass der Autor der post gewählt worden, negativ. Er schreibt auf diesem forum um Hilfe zu bitten, und obwohl seine Frage hat einige Kritik, seine post-led eine nützliche Antwort wie diese

InformationsquelleAutor Remy Lebeau

2

Konnten wir vermeiden, die Kopfzeile, enthält das Bild der Größe, aber die, die wir gerade Lesen, um das Ende der gesendeten Daten. Über die Größe des Puffers, konnten wir eine Feste Zahl wie z.B. 10 * 1024, als wir einige Daten von dem server, wir speichern es in eine Datei entsprechend der tatsächlichen empfangenen Daten Länge.
```
//please open a file ...
FILE * fp;
//...
const int LENGTH = 10 * 1024;

int len = 0;
char * buffer = (char *)malloc(LENGTH);
while ((len = recv(socket, buffer, LENGTH, 0)) > 0) {
    fwrite(buffer, 1, len, fp);
}
free(buffer);
//close the file
```
@T. C: ich denke, wir können nicht reservieren eines Puffers entsprechend der Größe vom server gesendet, im Falle, dass das Bild zu groß zum speichern innerhalb der client-Speicher. Nicht zu erwähnen, der server ist fake, und bestimmt sind, um jeden Angriff.
- den Speicher LÄNGE ist 10240 bytes, nehme ich an..aber die image-Datei ist 11656 bytes, dadurch wird die Datei nicht kopiert werden voll.
- Sie postet Kommentare, die nahelegen, dass Sie NICHT verstehen, wie Schleifen funktionieren. Ist das wirklich der Fall? Wenn dem so ist, müssen Sie stoppen, was Sie tun und gehen Sie zurück, um zu lernen, grundlegende Programmierung-Grundlagen. Dieser code wird halten Sie zu Lesen, in LENGTH Brocken, schreiben jedes chunk fp, bis entweder das socket geschlossen ist oder recv() bricht mit einer Fehlermeldung ab. Das bedeutet, dass dieser code benötigt der Absender, um in der Nähe der Steckdose, wenn es geschieht, indem die Datei, ohne das senden der Datei die Größe vorher.
InformationsquelleAutor Chandler

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.