Bonjour depuis plusieurs semaines je develope un clien et un server qui transferent les fichiers, mais j'ai un probléme mon fichier est corompu si la taille de ma variable buffer est differente de 20 Je precise que cela n'arrive pas en local  .

C'est vraiment handicapant car certain fichier peuvent mettre 2 heure a arriver

Voila les bouts de code pour le transfert de fichier

Clien

            if((n = recv(sock, buffer,MAXl, 0)) < 0)//On reçoi le nom du fichier
            {
                perror("recv()");
                return errno;
            }
             pFile = fopen(buffer, "wb");
             clear(buffer);//cette fonction remplit le buffer avec '\0'
            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                    perror("recv()");
                    return errno;
            }
            while (strcmp(buffer,":exit"))//on continue tant qu'on ne reçoi pas exit (ordre de sortie)
            {
                fwrite(buffer,MAXl-2,1, pFile);
                if((n = recv(sock, buffer,MAXl, 0)) < 0)
                {
                    perror("recv()");
                    return errno;
                }
            }
        clear(buffer);
            if((n = recv(sock, buffer,MAXl, 0)) < 0)// on reçoi la taille du dernier packet
            {
                perror("recv()");
                return errno;
            }
        printf("[%s]",buffer);//debug
        size = atoi(buffer);//on converti buffer en int
        if((n = recv(sock, buffer,MAXl, 0)) < 0)
        {
            perror("recv()");
            return errno;
        }
        fwrite(buffer,size,1, pFile);
        fclose(pFile);

Server

            printf("\nname of the file to upload:\n-");
            Sleep(500);
            lire(buffer,MAXl);
            puts("loading...");
            size = sizefile(buffer);
            printf("[%d]",size);
            /*clear(buffer);
           strcat(buffer,"untitled.jpg");*/
            if(send(csock, buffer,MAXl, 0) < 0)//envoi du nom du fichier
            {
                perror("send()");
                closesocket(sock);
                closesocket(csock);
                end();
                exit(errno);
            }
            fichier = fopen(buffer, "rb");
            clear(buffer);
            if (fichier != NULL)
            {
                while (n != 0) // On lit le fichier tant qu'on ne reçoit pas d'erreur != 1
                {
                    clear(buffer);
                    n = fread(buffer,MAXl-2,1, fichier);
                    buffer[MAXl-1] = '\0';
                    if(n !=0 || sizeof(buffer) == 0)
                    {
                    printf("[%s]",buffer);
                    if(send(csock, buffer,MAXl, 0) < 0)
                        {
                            perror("send()");
                            closesocket(sock);
                            closesocket(csock);
                            end();
                            exit(errno);
                        }
                    }
                }
                clear(nbuf);
                strcat(nbuf,buffer);
                fclose(fichier);
                clear(buffer);
                strcat(buffer,":exit");
                if(send(csock, buffer,MAXl, 0) < 0)//envoi l'ordre de sortir de la boucle
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(errno);
                }
                clear(buffer);
                sprintf(buffer, "%d",size%(MAXl-2));//int to char
                if(send(csock, buffer,MAXl, 0) < 0)//envoie de la taille
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(errno);
                }
                if(send(csock,nbuf,MAXl, 0) < 0)//envoie du dernier packet
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(errno);
                }
        }

Je suis sous windows et j'utilise codeblock

Merci pour vos reponses 

Pas le temps de regarder en détail, mais souvent les problèmes de lenteur réseau sont liés au tampon de sortie.

Tant qu'il n'a pas été expédié, on peut attendre la réponse longtemps....

Faire un fflush pour forcer l'expédition du contenu du tampon, avant tout recv ou fread

-
Edité par michelbillaud 18 août 2019 à 18:40:49

Merci de ta reponse mais la lenteur ne vien pas du reseaux mais du fait d'envoyer des packets de 20 aux lieux de 1024 

C'est un peu difficile d'en dire quelque chose à partir de fragments de code, dont on n'a même pas la spécification exacte... On ne peut pas tester, on ne peut pas en déduire ce que ça fait, et donc on ne risque pas d'avoir une idée de pourquoi ça ne fait pas ce que ça devrait faire.

D'après ce que tu en dis, il y a un problème de taille de buffer : on ne voit pas les constantes que tu définis...

-
Edité par michelbillaud 19 août 2019 à 11:17:25

Voila le code complet 

clien

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#define MAXl 20 //Pourquoi 20 ? parce-que ça marche on ne sait pourquoi
static void init(void);
static void end(void);
void clear (char* buffer);
int mainclien ();
int main ()
{
    while (1)//pour ne pas fermer le clien
    {
        mainclien();
    }
}
int mainclien ()
{
    int size;
    init();
    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

    if(sock == INVALID_SOCKET)
    {

        perror("socket()");
        exit(errno);
    }

    struct hostent *hostinfo = NULL;
    SOCKADDR_IN sin = { 0 }; /* initialise la structure avec des 0 */
    const char *hostname = "L'ip qu'il faut";
    unsigned char buffer[MAXl] = {0};
    unsigned char nbuf[MAXl] = {0};
    char cmd[MAXl];
    int n = 0;

    hostinfo = gethostbyname(hostname); /* on récupère les informations de l'hôte auquel on veut se connecter */
    if (hostinfo == NULL) /* l'hôte n'existe pas */
    {
        fprintf (stderr, "Unknown host %s.\n", hostname);
        exit(EXIT_FAILURE);
    }
    FILE* pFile;
    sin.sin_addr = *(IN_ADDR *) hostinfo->h_addr; /* l'adresse se trouve dans le champ h_addr de la structure hostinfo */
    sin.sin_port = htons(463); /* on utilise htons pour le port */
    sin.sin_family = AF_INET;

    while (connect(sock,(SOCKADDR *) &sin, sizeof(SOCKADDR)) == SOCKET_ERROR)
    {
        perror("connect()");
    }
    while (strcmp(buffer,":exit"))
    {
         if((n = recv(sock, buffer,MAXl, 0)) < 0)
         {
             perror("recv()");
             return errno;
         }
           printf("buf:(%s)",buffer);
        if (!strcmp(buffer,":upload"))
        {
            puts("upload::");
            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                perror("recv()");
                return errno;
            }
             pFile = fopen(buffer, "wb");
             clear(buffer);
            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                    perror("recv()");
                    return errno;
            }
            while (strcmp(buffer,":exit"))
            {
                fwrite(buffer,MAXl-2,1, pFile);
                if((n = recv(sock, buffer,MAXl, 0)) < 0)
                {
                    perror("recv()");
                    return errno;
                }
            }
        clear(buffer);
            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                perror("recv()");
                return errno;
            }
        printf("[%s]",buffer);
        size = atoi(buffer);
        if((n = recv(sock, buffer,MAXl, 0)) < 0)
        {
            perror("recv()");
            return errno;
        }
        fwrite(buffer,size,1, pFile);
        fclose(pFile);
        }
        puts("fin du tour");
    }
    end();
    return 0;
}



static void init(void)
{
#ifdef WIN32
    WSADATA wsa;
    int err = WSAStartup(MAKEWORD(2, 2), &wsa);
    if(err < 0)
    {
        puts("WSAStartup failed !");
        exit(EXIT_FAILURE);
    }
#endif
}
void clear (char* buffer)
{
    int i=0;
    while (i < sizeof(buffer))
       {
        buffer[i] = 0;
       i++;
       }
}
static void end(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}



static void init(void)
{
#ifdef WIN32
    WSADATA wsa;
    int err = WSAStartup(MAKEWORD(2, 2), &wsa);
    if(err < 0)
    {
        puts("WSAStartup failed !");
        exit(EXIT_FAILURE);
    }
#endif
}
void clear (char* buffer)
{
    int i=0;
    while (i < sizeof(buffer))
       {
        buffer[i] = 0;
       i++;
       }
}

static void end(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}


int lire(char *chaine, int longueur)
{
    char *positionEntree = NULL;

    // On lit le texte saisi au clavier
    if (fgets(chaine, longueur, stdin) != NULL)  // Pas d'erreur de saisie ?
    {
        positionEntree = strchr(chaine, '\n'); // On recherche l'"Entrée"
        if (positionEntree != NULL) // Si on a trouvé le retour à la ligne
        {
            *positionEntree = '\0'; // On remplace ce caractère par \0
        }
        return 1; // On renvoie 1 si la fonction s'est déroulée sans erreur
    }
    else
    {
        return 0; // On renvoie 0 s'il y a eu une erreur
    }
}
long sizefile(char *addr)
{
    FILE *fichier;
    long size;

    fichier=fopen(addr,"rb");

    if(fichier)
    {
            fseek (fichier, 0, SEEK_END);   // non-portable
            size=ftell (fichier);
            fclose (fichier);
    }
    return size;
}

Serveur

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#include <string.h> // Penser à inclure string.h pour strchr()
#define MAXl 20
int lire(char *chaine, int longueur);
static void init(void);
static void end(void);
long sizefile(char *addr);
void clear (char* buffer);


int main()
{
    init();
    long long int size;
    int i;
     FILE* fichier = NULL;
    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

    if(sock == INVALID_SOCKET)
    {
        perror("socket()");
        exit(errno);
    }
    int n;
    SOCKADDR_IN sin = { 0 };

    sin.sin_addr.s_addr = htonl(INADDR_ANY); // nous sommes un serveur, nous acceptons n'importe quelle adresse

    sin.sin_family = AF_INET;

    sin.sin_port = htons(463);

    if(bind (sock, (SOCKADDR *) &sin, sizeof sin) == SOCKET_ERROR)
    {
        perror("bind()");
        exit(errno);
    }
    if(listen(sock, 5) == SOCKET_ERROR)
    {
        perror("listen()");
        exit(errno);
    }
    SOCKADDR_IN csin = { 0 };
    SOCKET csock;
    int sinsize = sizeof csin;

    csock = accept(sock, (SOCKADDR *)&csin, &sinsize);
     unsigned char buffer[MAXl] = {0};
     unsigned char nbuf[MAXl] = {0};
    if(csock == INVALID_SOCKET)
    {
        perror("accept()");
        exit(errno);
    }

    while (1)
    {
        printf("\n-");
        lire(buffer,MAXl);
        printf("buf:(%s)",buffer);
        if(send(csock, buffer,MAXl, 0) < 0)
        {
            perror("send()");
            exit(errno);
        }


        if(!strcmp(buffer,":upload"))//Si on recoit la commande pour upload
        {
            printf("\nname of the file to upload:\n-");
            Sleep(500);
            lire(buffer,MAXl);
            puts("loading...");
            size = sizefile(buffer);
            printf("[%d]",size);
            /*clear(buffer);
           strcat(buffer,"untitled.jpg");*/
            if(send(csock, buffer,MAXl, 0) < 0)
            {
                perror("send()");
                closesocket(sock);
                closesocket(csock);
                end();
                exit(errno);
            }
            fichier = fopen(buffer, "rb");
            clear(buffer);
            if (fichier != NULL)
            {
                while (n != 0) // On lit le fichier tant qu'on ne reçoit pas d'erreur != 1
                {
                    clear(buffer);
                    n = fread(buffer,MAXl-2,1, fichier);
                    buffer[MAXl-1] = '\0';
                    if(n !=0 || sizeof(buffer) == 0)
                    {
                    printf("[%s]",buffer);
                    if(send(csock, buffer,MAXl, 0) < 0)
                        {
                            perror("send()");
                            closesocket(sock);
                            closesocket(csock);
                            end();
                            exit(errno);
                        }
                    }
                }
                clear(nbuf);
                strcat(nbuf,buffer);
                fclose(fichier);
                clear(buffer);
                strcat(buffer,":exit");
                if(send(csock, buffer,MAXl, 0) < 0)
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(errno);
                }
                clear(buffer);
                sprintf(buffer, "%d",size%(MAXl-2));
                if(send(csock, buffer,MAXl, 0) < 0)
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(errno);
                }
                if(send(csock,nbuf,MAXl, 0) < 0)
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(errno);
                }
        }
        }else
        {
                if((n = recv(csock, buffer,MAXl, 0)) < 0)
                {
                    perror("recv()");
                    exit(errno);
                }
                printf("%s",buffer);
        }
    }

    getchar();
    closesocket(sock);
    closesocket(csock);
    end();
    printf("Hello world!\n");
    return 0;
}



static void init(void)
{
#ifdef WIN32
    WSADATA wsa;
    int err = WSAStartup(MAKEWORD(2, 2), &wsa);
    if(err < 0)
    {
        puts("WSAStartup failed !");
        exit(EXIT_FAILURE);
    }
#endif
}
void clear (char* buffer)
{
    int i=0;
    while (i < sizeof(buffer))
       {
        buffer[i] = 0;
       i++;
       }
}

static void end(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}


int lire(char *chaine, int longueur)
{
    char *positionEntree = NULL;

    // On lit le texte saisi au clavier
    if (fgets(chaine, longueur, stdin) != NULL)  // Pas d'erreur de saisie ?
    {
        positionEntree = strchr(chaine, '\n'); // On recherche l'"Entrée"
        if (positionEntree != NULL) // Si on a trouvé le retour à la ligne
        {
            *positionEntree = '\0'; // On remplace ce caractère par \0
        }
        return 1; // On renvoie 1 si la fonction s'est déroulée sans erreur
    }
    else
    {
        return 0; // On renvoie 0 s'il y a eu une erreur
    }
}
long sizefile(char *addr)
{
    FILE *fichier;
    long size;

    fichier=fopen(addr,"rb");

    if(fichier)
    {
            fseek (fichier, 0, SEEK_END);   // non-portable
            size=ftell (fichier);
            fclose (fichier);
    }
    return size;
}

-
Edité par AyeinLas 19 août 2019 à 13:25:05

Pour que ça marche, il faut probablement être sûr que les tailles de tampons sont les mêmes des deux côtés, client et serveur.

Quelques remarques

• c'est un programme non portable, avec un fichier d'entete spécifique Windows.
• la constante qui donne la taille des tampons pourrait s'appeler, euh, TAILLE_TAMPON ?
• pourquoi MAXl-2 ?
• la fabrication des adresses par gethostbyname et bidouillage de champs date du siècle dernier. getaddrinfo est bien plus pratique, et traite IPv4 et IPv6 d'un coup. Voir 7.3  dans  https://www.labri.fr/perso/billaud/travaux/SYSRESEAU/polycop.pdf

- coté client, du genre

struct addrinfo * adr_premier_resultat ;
getaddrinfo ( "www.elysee.fr " , " http " , NULL, & adr_premier_resultat ) ;

int fd = socket ( adr_premier_resultat −> ai_family , SOCK_STREAM, 0) ;

-
Edité par michelbillaud 19 août 2019 à 15:29:09

michelbillaud a écrit:

Pour que ça marche, il faut probablement être sûr que les tailles de tampons sont les mêmes des deux côtés, client et serveur..

Les tailles sont les mêmes côtés client et serveur ça j'en suis sur.

michelbillaud a écrit:

c'est un programme non portable, avec un fichier d'entete spécifique Windows.

Oui mon code non portable  mais de toute  façon  le reste de mon code ne l'est pas non plus, j'ai donc supprimé les 15 lignes pour la compatibilité Linux 

michelbillaud a écrit:

la constante qui donne la taille des tampons pourrait s'appeler, euh, TAILLE_TAMPON ?

Oui si on veut 

michelbillaud a écrit:

• pourquoi MAXl-2 ?

Le problème n'arrive que sur les fichiers binaire je crois  ou alors je ne fait pas de fichier assez long surement une piste.

Si c'est pour envoyer tous les octets d'un tampon  de taille N, alors c'est N, pas N-1....

Et si on fait un atoi pour avoir la valeur d'un nombre qui est sous forme de chaine dans un tampon, il vaut mieux que le tampon contienne le caractère nul qui termine la chaine. Et donc l'avoir transmis.

-
Edité par michelbillaud 19 août 2019 à 23:01:22

A tu pu essayer le code en reseaux ? Je ne peux mois même pas le tester car je n'ai qu'un seul pc pour l'instant a part mon raspberry mais il n'a pas windows 

-
Edité par AyeinLas 19 août 2019 à 23:25:06

Non parce qu'il y a des spécificités Windows, que je n'ai pas Windows, et que je n'ai pas envie de faire le portage d'une application qui ne marche pas, avec un main de 150 lignes, et dont je n'ai même pas le mode d'emploi.

C'est normal que ça ne marche pas avec des fichiers binaires. Tu utilises des fonctions (strcat) qui agissent sur des chaînes, et s'arrêtent sur le premier caractère nul, dont les fichiers binaires sont pleins.

Même chose pour ton histoire de caractère nul dans le tampon.

Ps pour moins t'embêter, au lieu de faire des  send et recv,  emploie fread fwrite  getline fscanf.... sur le FILE*  retourné par fdopen   à partir d'un descripteur de socket.

-
Edité par michelbillaud 20 août 2019 à 9:09:46

michelbillaud a écrit:

Ps pour moins t'embêter, au lieu de faire des  send et recv,  emploie fread fwrite  getline fscanf.... sur le FILE*  retourné par fdopen   à partir d'un descripteur de socket.

Alors la rien comprit 

Forcément, quand on n'a pas le bonheur d'avoir la science infuse, il faut se renseigner  pour savoir de quoi il s'agit, et ça demande un peu de travail :-)

-
Edité par michelbillaud 20 août 2019 à 14:17:18

Après recherche je cite

Un socket est une des extrémités d'une connexion réseau.
Tu as des socket TCP, UDP, des socket clients, des sockets serveur.
Sur une socket (je ne sais pas d'ailleurs si c'est masculin ou féminin), tu peux appliquer des opérations réseau (send(), recv(), close(), sendto(), recvfrom() et d'autres choses encore. De toute façon, une socket est un descripteur (un handle dans le monde Microsoft) sur un truc réseau.

Un descripteur c'est une généralisation. C'est aussi un handle sur des objets génériques avec des méthodes génériques (open(), close(), read(), write(), ...).

Comme conceptuellement, les opérations que l'on peut faire sur une socket ressemblent aux opérations que l'on peut faire sur les fichiers, on peut parler de descripteur pour des socket et des fichiers (et aussi des pipes et probablement d'autres objets encore).

Attention, cette généralisation n'est valable que dans le monde unix. L'API Native Microsoft fait une différence entre un descripteur de fichiers et un descripteur de socket.

Est-ce portable ?

-
Edité par AyeinLas 20 août 2019 à 14:39:20

Pour la compatibilité, voir par là.

https://broux.developpez.com/articles/c/sockets/

-
Edité par michelbillaud 20 août 2019 à 17:15:47

Normalement le code est maintenant portable 

clien

#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32 /* si vous êtes sous Windows */

#include <winsock2.h>

#elif defined (linux) /* si vous êtes sous Linux */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h> /* close */
#include <netdb.h> /* gethostbyname */
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
typedef struct in_addr IN_ADDR;

#else /* sinon vous êtes sur une plateforme non supportée */

#error not defined for this platform

#endif
#define MAXl 1024 //Longeur du buffer
static void init(void);
static void end(void);
void clear (char* buffer);

int main()
{
    int size;
    init();
    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

    if(sock == INVALID_SOCKET)
    {

        perror("socket()");
        exit(errno);
    }

    struct hostent *hostinfo = NULL;
    SOCKADDR_IN sin = { 0 }; /* initialise la structure avec des 0 */
    const char *hostname = "127.0.0.1";
    unsigned char buffer[MAXl] = {0};
    unsigned char nbuf[MAXl] = {0};
    char cmd[MAXl];
    int n = 0;

    hostinfo = gethostbyname(hostname); /* on récupère les informations de l'hôte auquel on veut se connecter */
    if (hostinfo == NULL) /* l'hôte n'existe pas */
    {
        fprintf (stderr, "Unknown host %s.\n", hostname);
        exit(EXIT_FAILURE);
    }
    FILE* pFile;
    sin.sin_addr = *(IN_ADDR *) hostinfo->h_addr; /* l'adresse se trouve dans le champ h_addr de la structure hostinfo */
    sin.sin_port = htons(463); /* on utilise htons pour le port */
    sin.sin_family = AF_INET;

    while (connect(sock,(SOCKADDR *) &sin, sizeof(SOCKADDR)) == SOCKET_ERROR)
    {
        perror("connect()");
    }

            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                perror("recv()");
                return -1;
            }
             pFile = fopen(buffer, "wb");
             clear(buffer);
            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                    perror("recv()");
                    return -1;
            }
            while (strcmp(buffer,":exit"))
            {
                fwrite(buffer,MAXl-2,1, pFile);
                if((n = recv(sock, buffer,MAXl, 0)) < 0)
                {
                    perror("recv()");
                    return -1;
                }
            }
            clear(buffer);
            if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {
                perror("recv()");
                return -1;
            }
        printf("[%s]",buffer);
        size = atoi(buffer);

        if((n = recv(sock, buffer,MAXl, 0)) < 0)
            {perror("recv()");return -1;}

        fwrite(buffer,size,1, pFile);
        fclose(pFile);
    end();
    return 0;
}
static void init(void)
{
#ifdef WIN32
    WSADATA wsa;
    int err = WSAStartup(MAKEWORD(2, 2), &wsa);
    if(err < 0)
    {
        puts("WSAStartup failed !");
        exit(EXIT_FAILURE);
    }
#endif
}
void clear (char* buffer)
{
    int i=0;
    while (i < MAXl-1)
       {
        buffer[i] = 0;
       i++;
       }
}
void setcharto (char* buffer,char* content)
{
    int i=0;
    while (i < MAXl-1)
       {
           if (i < strlen(content)){buffer[i] = content[i];}
           else{buffer[i] = 0;}i++;
       }
}
static void end(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}

serveur

#include <stdio.h>
#include <stdlib.h>
#ifdef WIN32 /* si vous êtes sous Windows */

#include <winsock2.h>

#elif defined (linux) /* si vous êtes sous Linux */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h> /* close */
#include <netdb.h> /* gethostbyname */
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define closesocket(s) close(s)
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
typedef struct in_addr IN_ADDR;

#else /* sinon vous êtes sur une plateforme non supportée */

#error not defined for this platform

#endif
#include <string.h> // Penser à inclure string.h pour strchr()
#define MAXl 1024
int lire(char *chaine, int longueur);
static void init(void);
static void end(void);
long sizefile(char *addr);
void setcharto (char* buffer,char* content);


int main()
{
    init();
    long long int size;
    int i;
     FILE* fichier = NULL;
    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

    if(sock == INVALID_SOCKET)
    {
        perror("socket()");
        exit(errno);
    }
    int n;
    SOCKADDR_IN sin = { 0 };

    sin.sin_addr.s_addr = htonl(INADDR_ANY); // nous sommes un serveur, nous acceptons n'importe quelle adresse

    sin.sin_family = AF_INET;

    sin.sin_port = htons(463);

    if(bind (sock, (SOCKADDR *) &sin, sizeof sin) == SOCKET_ERROR)
    {
        perror("bind()");
        exit(errno);
    }
    if(listen(sock, 5) == SOCKET_ERROR)
    {
        perror("listen()");
        exit(errno);
    }
    SOCKADDR_IN csin = { 0 };
    SOCKET csock;
    int sinsize = sizeof csin;

    csock = accept(sock, (SOCKADDR *)&csin, &sinsize);
     unsigned char buffer[MAXl] = {0};
     unsigned char nbuf[MAXl] = {0};
    if(csock == INVALID_SOCKET)
    {
        perror("accept()");
        exit(errno);
    }

            printf("\nname of the file to upload:\n-");
            Sleep(500);
            lire(buffer,MAXl);
            puts("loading...");
            size = sizefile(buffer);
            printf("[%d]",size);
            /*clear(buffer);
           strcat(buffer,"untitled.jpg");*/
            if(send(csock, buffer,MAXl, 0) < 0)
            {
                perror("send()");
                closesocket(sock);
                closesocket(csock);
                end();
                exit(-1);
            }
            fichier = fopen(buffer, "rb");
            clear(buffer);n=1;
            if (fichier != NULL)
            {
                puts("file open succefully");
                while (n != 0) // On lit le fichier tant qu'on ne reçoit pas d'erreur != 1
                {
                    clear(buffer);
                    n = fread(buffer,MAXl-2,1, fichier);
                    buffer[MAXl-1] = '\0';
                    if(n !=0 || sizeof(buffer) == 0)
                    {
                    printf("[%s]",buffer);
                    if(send(csock, buffer,MAXl, 0) < 0)
                        {
                            perror("send()");
                            closesocket(sock);
                            closesocket(csock);
                            end();
                            exit(-1);
                        }
                    }
                }
                setcharto(nbuf,buffer);
                setcharto(buffer,":exit");
                if(send(csock, buffer,MAXl, 0) < 0)
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(-1);
                }
                clear(buffer);
                sprintf(buffer,"%d",size%(MAXl-2));
                if(send(csock, buffer,MAXl, 0) < 0)
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(-1);
                }
                if(send(csock,nbuf,MAXl, 0) < 0)
                {
                    perror("send()");
                    closesocket(sock);
                    closesocket(csock);
                    end();
                    exit(-1);
                }

        }
        fclose(fichier);



    getchar();
    closesocket(sock);
    closesocket(csock);
    end();
    printf("Hello world!\n");
    return 0;
}



static void init(void)
{
#ifdef WIN32
    WSADATA wsa;
    int err = WSAStartup(MAKEWORD(2, 2), &wsa);
    if(err < 0)
    {
        puts("WSAStartup failed !");
        exit(EXIT_FAILURE);
    }
#endif
}
void setcharto (char* buffer,char* content)
{
    int i = 0;
    while (i < MAXl-1)
       {
           if (i < strlen(content)){buffer[i] = content[i];}
           else{buffer[i] = 0;}i++;
       }
}
void clear (char* buffer)
{
    int i=0;
    while (i < MAXl-1)
       {
        buffer[i] = 0;
       i++;
       }
}
static void end(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}
int lire(char *chaine, int longueur)
{
    char *positionEntree = NULL;

    // On lit le texte saisi au clavier
    if (fgets(chaine, longueur, stdin) != NULL)  // Pas d'erreur de saisie ?
    {
        positionEntree = strchr(chaine, '\n'); // On recherche l'"Entrée"
        if (positionEntree != NULL) // Si on a trouvé le retour à la ligne
        {
            *positionEntree = '\0'; // On remplace ce caractère par \0
        }
        return 1; // On renvoie 1 si la fonction s'est déroulée sans erreur
    }
    else
    {
        return 0; // On renvoie 0 s'il y a eu une erreur
    }
}
long sizefile(char *addr)
{
    FILE *fichier;
    long size;

    fichier=fopen(addr,"rb");

    if(fichier)
    {
            fseek (fichier, 0, SEEK_END);   // non-portable
            size=ftell (fichier);
            fclose (fichier);
    }
    return size;
}

-
Edité par AyeinLas 20 août 2019 à 23:20:35

Retour a la case depart