Etablir une connexion entre deux postes

**blondelle** · 18/09/2006, 23h09

J'ai trouve un lien en Delphi qui pourrait interressant pour la copie de fichier sur un serveur.

http://delphi.developpez.com/faq/?pa...ansfertfichier

**blondelle** · 18/09/2006, 23h38

J'ai trouve un exemple en Delphi de copie de fichier apparament le fichier est envoye par morceaux.
le lien

http://delphi.developpez.com/sources...no40source0015

**blondelle** · 19/09/2006, 14h51

Je pense utiliser l'idee en Delphi "le dernier lien poste" d'envoyer un fichier en morceau sur le poste distant il me faut comprendre dans un premier temps comment ouvrir et decouper le fichier, ensuite on verra comment recomposer le fichier.

**blondelle** · 20/09/2006, 14h34

J'ai commence a convertir en BCB le programme de copy de fichier sur un serveur local.
Je suis parti de la source originale en Delphi ici.

http://delphi.developpez.com/sources...no40source0015

La conversion est assez avancee mais j'ai des problemes pour certains morceaux de programme, je poste le source actuel qui provoque des erreurs donc non fonctionnel

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
#include "SysUtils.hpp"
#include "ExtCtrls.hpp"
#pragma link "ScktComp"
#include "serveur.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
//unit Unit1;
//
// Sujet : Programme exemple de transfert de fichier par Client/ServerSocket
//
// Par Nono40 : http://nono40.developpez.com   http://nono40.fr.st
//              mailTo:nono40@fr.st
//
// Le 30/06/2002
//
//   Ce programme n'est pas fait pour remplacer des logiciels de transfert. Mais
//   il présente la méthode pour envoyer un fichier d'un ordinateur à un autre via
//   un réseau supportant TCPIP.
//
//   P.S. : la procédure d'affichage des codes d'erreur est issue d'un source publié par djtexas.
//
/*
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ScktComp, ExtCtrls;
*/
/*
type
  TForm1 = class(TForm)
    Client: TClientSocket;
    Serveur: TServerSocket;
    GroupBox1: TGroupBox;
    btnOpen: TButton;
    btnClose: TButton;
    MemoServeur: TMemo;
    GroupBox2: TGroupBox;
    btnEnvoyer: TButton;
    btnStop: TButton;
    Edit1: TEdit;
    Ouvrir: TOpenDialog;
    MemoClient: TMemo;
    RetardDebut: TTimer;
    procedure btnOpenClick(Sender: TObject);
    procedure btnCloseClick(Sender: TObject);
    procedure ServeurClientConnect(Sender: TObject;
      Socket: TCustomWinSocket);
    procedure ServeurClientDisconnect(Sender: TObject;
      Socket: TCustomWinSocket);
    procedure ServeurClientError(Sender: TObject; Socket: TCustomWinSocket;
      ErrorEvent: TErrorEvent; var ErrorCode: Integer);
    procedure ServeurClientRead(Sender: TObject; Socket: TCustomWinSocket);
    procedure ClientConnect(Sender: TObject; Socket: TCustomWinSocket);
    procedure ClientDisconnect(Sender: TObject; Socket: TCustomWinSocket);
    procedure ClientError(Sender: TObject; Socket: TCustomWinSocket;
      ErrorEvent: TErrorEvent; var ErrorCode: Integer);
    procedure btnEnvoyerClick(Sender: TObject);
    procedure ClientRead(Sender: TObject; Socket: TCustomWinSocket);
    procedure btnStopClick(Sender: TObject);
    procedure RetardDebutTimer(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
 
implementation
 
{$R *.dfm}
*/
//**************************************************************************************
//
//  Principe :
//    le fichier envoyé en coupé en tranches de taille identiques et e transmises au serveur
//    dans l'ordre du fichier.
//
//    - Le client se connecte au serveur.
//    - Si la connection est OK alors il envoie un trame du type ci-dessous avec ttType=1
//      signalant qu'il s'agit du nom du fichier. ttNomFichier est alors le nom du fichier
//      transféré.
//    - Si le serveur accepte la demande, alors le fichier est envoyé par morceau avec le même
//      type de trame. ttType = 2 pour signaler qu'il s'agit un morceau du fichier. ttDebut
//      donne l'adresse du bloc dans le fichier et ttLong la taille du bloc.
//    - Le client se deconnecte, ce qui ferme le fichier sur le serveur.
//
//**************************************************************************************
//**************************************************************************************
//  Procédure d'affichage en clair des erreurs socket
//  merci à djtexas
Function MessageErreurSocket( ErrorEvent: TErrorEvent, var ErrorCode: Integer)
{
String ErrorMsg;
 
    // définition du message d'erreur en fonction du code d'erreur
    switch (ErrorCode)
    {
        case 10004 :
        ErrorMsg = "Interrupted function call.";
        case 10013 :
        ErrorMsg = "Permission Refusée.";
        case 10014 :
        ErrorMsg = "Mauvaise adresse.";
        case 10022 :
        ErrorMsg = "Arguments Invalides.";
        case 10024 :
        ErrorMsg = "Trop de fichiers ouverts.";
        case 10035 :
        ErrorMsg = "Resource temporarily unavailable.";
        case 10036 :
        ErrorMsg = "Operation en cours.";
        case 10037 :
        ErrorMsg = "Operation déjà en cours.";
        case 10038 :
        ErrorMsg = "Socket operation on non-socket.";
        case 10039 :
        ErrorMsg = "Destination address required.";
        case 10040 :
        ErrorMsg = "Message trop long.";
        case 10041 :
        ErrorMsg = "Protocol wrong type for socket.";
        case 10042 :
        ErrorMsg = "Bad protocol option.";
        case 10043 :
        ErrorMsg = "Protocol not supported.";
        case 10044 :
        ErrorMsg = "Socket type not supported.";
        case 10045 :
        ErrorMsg = "Operation not supported.";
        case 10046 :
        ErrorMsg = "Protocol family not supported.";
        case 10047 :
        ErrorMsg = "Address family not supported by protocol family.";
        case 10048 :
        ErrorMsg = "Address already in use.";
        case 10049 :
        ErrorMsg = "Cannot assign requested address.";
        case 10050 :
        ErrorMsg = "Network is down.";
        case 10051 :
        ErrorMsg = "Network is unreachable.";
        case 10052 :
        ErrorMsg = "Network dropped connection on reset.";
        case 10053 :
        ErrorMsg = "Software caused connection abort.";
        case 10054 :
        ErrorMsg = "Connection reset by peer.";
        case 10055 :
        ErrorMsg = "No buffer space available.";
        case 10056 :
        ErrorMsg = "Socket is already connected.";
        case 10057 :
        ErrorMsg = "Socket is not connected.";
        case 10058 :
        ErrorMsg = "Cannot send after socket shutdown.";
        case 10060 :
        ErrorMsg = "Connection timed out.";
        case 10061 :
        ErrorMsg = "Connection refused.";
        case 10064 :
        ErrorMsg = "Host is down.";
        case 10065 :
        ErrorMsg = "No route to host.";
        case 10067 :
        ErrorMsg = "Too many processes.";
        case 10091 :
        ErrorMsg = "Network subsystem is unavailable.";
        case 10092 :
        ErrorMsg = "WINSOCK.DLL version out of range.";
        case 10093 :
        ErrorMsg = "Successful WSAStartup not yet performed.";
        case 10094 :
        ErrorMsg = "Graceful shutdown in progress.";
        case 11001 :
        ErrorMsg = "Host not found.";
        case 11002 :
        ErrorMsg = "Non-authoritative host not found.";
        case 11003 :
        ErrorMsg = "This is a non-recoverable error.";
        case 11004 :
        ErrorMsg = "Valid name, no data record of requested type.";
        default :
        // erreur inconnue
        ErrorMsg = "Unknown socket error.";
}
    // mise en forme de la signification de l'erreur
ErrorMsg = "Socket Error n°" + IntToStr(ErrorCode) + " : " + ErrorMsg;
    // l'erreur est traitée
ErrorCode = 0;
    // définition du type d'erreur
    switch (ErrorEvent)
    {
        case eeSend :
        ErrorMsg = "Writing " + ErrorMsg;
        case eeReceive       :
        ErrorMsg = "Reading " + ErrorMsg;
        case eeConnect :
        ErrorMsg = "Connecting " + ErrorMsg;
        case eeDisconnect :
        ErrorMsg = "Disconnecting " + ErrorMsg;
        case eeAccept :
        ErrorMsg = "Accepting " + ErrorMsg;
        default :
        // erreur inconnue
        ErrorMsg = "Unknown " + ErrorMsg;
}
    Result = ErrorMsg;
}
//**************************************************************************************
//**************************************************************************************
//    Structure de la trame utilisée pour les échanges
//
{
Const int TailleBloc = 256;
 
Type
  TIPTrame = Packed Record;
 
int ttType;                          // ttType précise le type de la trame
                                                    //  =1 quand c'est un nom de fichier
    switch (ttType)
{                                                //  =2 quand c'est un morceau du fichier
    case 1:
    ( ttNomFichier:String[255];                   // Nom du fichier
     );
    case 2:
    ( int ttDebut;                          // Adresse de début des données dans le fichier
      int ttLong;                          // Longueur des données envoyées
      ttDatas = Array[0..TailleBloc-1] Of Byte; )  // Données envoyées
}
}
//
//**************************************************************************************
//**************************************************************************************
//  SERVEUR
//  Cette partie ne concerne que le serveur
Var
bool ServeurEnReception = False;     // =True quand une réception est en cours
String ServeurAdresseClient = "";        // Adresse du client connecté
File ServeurFichier;                // Fichier utilisé pour la sauvegarde des morceaux
 
//---------------------------------------------------------------------------
void __fastcall TForm1::btnOpenClick(TObject *Sender)
{
  // Bouton de mise en écoute du serveur, c'est tout simple
  Serveur->Open;
  MemoServeur->Lines->Add("Serveur en écoute");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnCloseClick(TObject *Sender)
{
  // Bouton de fermeture du serveur, c'est aussi tout simple
  If ServeurEnReception
     And (MessageDlg("Un transfert est en cours, fermer le serveur ?", mtConfirmation, [mbYes,mbNo], 0) = mrYes)
        {
    Serveur->Close;
    MemoServeur->Lines->Add("Serveur desactivé");
        }
}
 
//
// évènements du socket serveur
//
 
//---------------------------------------------------------------------------
void __fastcall TForm1::ServeurClientConnect(TObject *Sender,
      TCustomWinSocket *Socket)
{
  // C'est juste pour signaler
  MemoServeur->Lines->Add("OnConnect: " + Socket->RemoteAddress);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServeurClientDisconnect(TObject *Sender,
      TCustomWinSocket *Socket)
{
  MemoServeur->Lines->Add("OnDisconnect: " + Socket->RemoteAddress);
  // Le client se deconnecte => ou ferme le fichier en cours si besoin
  If (ServeurEnReception)
{
    CloseFile(ServeurFichier);
    ServeurEnReception = False;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServeurClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
  // On ne fait que signaler l'erreur
  MemoServeur->Lines->Add("OnClientError: " + Socket->RemoteAddress + #13 + MessageErreurSocket(ErrorEvent, ErrorCode));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServeurClientRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
Var Buffer:TIPTrame;
int Erreur;
int Recus;
  // C'est ici la partie principale du serveur
  // Cette procédure est appelée à chaque écriture d'un client
 
  Erreur = 0;
  Recus = Socket->ReceiveLength;    // Longueur reçue ( en octets )
  MemoServeur->Lines->Add("OnRead " + Socket->RemoteAddress + " reçus " + IntToStr(Recus));
 
  If Recus <= SizeOf(Buffer)         // On vérifie que la longueur reçue tient dans la trame
                                    // sinon attention au plantage !!!
  Then With Buffer Do Begin
    // Lecture de la trame reçue
    Socket->ReceiveBuf(Buffer, Recus);
 
    // En fonction du type de la trame on effectue les traitements
    switch (ttType)
{
      case 1:
      {
        // C'est une nouvelle demande, on vérifie le nom du fichier
        // La longueur de la trame doit être au minimumu de
        //   4 ( taille de ttType ) + 1 ( longueur de la chaine ttNomFichier ) + Length(ttNomFichier)
        If ((Recus >= 5) And (Recus >= (5 + Length(ttNomFichier))))
        {
          // La longueur est bonne, on accepte la demande
          MemoServeur->Lines->Add(ttNomFichier);
        }
          // On ferme le fichier précédent au cas ou
          If (ServeurEnReception)
{
          CloseFile(ServeurFichier);
}
          // On ouvre le fichier de réception en écriture
          AssignFile(ServeurFichier, ExtractFilePath(ParamStr(0)) + ttNomFichier);
          try
            Rewrite(ServeurFichier, 1);
            ServeurEnReception = True;
            Erreur = 0;
          catch
            Erreur = 5; // Erreur de création du fichier
          }
        }
        Else Erreur = 2; // La longueur reçue est trop courte
      }
 
      case 2:
      {
        // On reçoit un morceau de fichier
        // La longueur de la trame doit être au minimumu de
        //   4 ( taille de ttType ) + 4 ( taille de ttDebut ) + 4 ( taille de ttLong )
        //    + ttLong ( nombre de données envoyées )
        If (Recus >= 12) And (Recus >= (12 + ttLong))
        {
          // Le morceau n'est accepté que si une demande est en cours
          If ServeurEnReception
          {
            // Le morceau n'est accepté que si le début du fichier à déjà été reçu
            If (ttDebut >= 0)And(ttDebut <= FileSize(ServeurFichier))
            {
              try
                // Si tout est bon on écrit le morceau dans le fichier
                Seek(ServeurFichier, ttDebut);
                BlockWrite(ServeurFichier, ttDatas, ttLong);
                Erreur = 0;  // C'est bon
              catch
                Erreur = 6; // Erreur d'écriture du fichier
              }
            }
            Else Erreur = 4; // La position 'début' n'est pas correcte
          }
          Else Erreur = 3; // On n'a pas reçue de demande
        }
        Else Erreur = 2; // La longueur reçue est trop courte
      }
 
    };// fin du case
  }
  Else Erreur = 1; // La longueur reçue est trop grande
 
  // Dans tout les cas on envoie le code d'erreur au client
  Socket->SendBuf(Erreur,4);
  MemoServeur->Lines->Add("  Code de retour : " + IntToStr(Erreur));
}
// fin de la partie serveur
}
//**************************************************************************************
//**************************************************************************************
 
//  CLIENT
//  Cette partie ne concerne que le client
Var
  ClientFichier   : File;       // Fichier en cours d'envoi
  ClientTrame     : TIPTrame;   // Copie de la dernière trame envoyée
 
//---------------------------------------------------------------------------
void __fastcall TForm1::btnEnvoyerClick(TObject *Sender)
{
  // Bouton envoyer, c'est le début
  // On demande bien sur en premier le nom de fichier à transférer
  If (Not Ouvrir->Execute)
  {
  Exit;
  }
  AssignFile(ClientFichier, Ouvrir->FileName);
 
  // On ouvre le fichier en lecture
  Reset(ClientFichier, 1);
 
  // On essaye de se connecter au serveur
  Client->Address = Edit1->Text;
  Client->Open;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::ClientConnect(TObject *Sender,
      TCustomWinSocket *Socket)
{
  // La connection est réussie
  MemoClient->Lines->Add("OnConnect: " + Socket->RemoteAddress);
 
  // On demande alors l'envoi de la trame d'entête
  ClientTrame->ttType = 1;
  ClientTrame->ttNomFichier = ExtractFileName(Ouvrir->FileName);
 
  // La demande est différée par un petit timer car il est interdit
  // d'écrire dans un OnConnect
  btnEnvoyer->Enabled = False;
  RetardDebut->Enabled = True;
}
//---------------------------------------------------------------------------
procedure TForm1.RetardDebutTimer(Sender: TObject)
{
  // Cette demande n'est faite qu'une fois par fichier
  RetardDebut->Enabled = False;
 
  // On envoie au serveur la trame avec le nom du fichier
  Client->Socket->SendBuf(ClientTrame, 4 + Length(ClientTrame->ttNomFichier) + 1);
  MemoClient->Lines->add("Envoi de l''entête");
}
//---------------------------------------------------------------------------
Procedure EnvoiBlocEnCours;
{
  With ClientTrame Do
  {
    // Procédure d'envoi d'un morceau de fichier
    // est appelée par ClientRead
 
    // C'est une trame de type morceau de fichier
    ttType = 2;
 
    // Lecture dans le fichier
    Seek(ClientFichier, ttDebut);
    BlockRead(ClientFichier, ttDatas, TailleBloc, ttLong);
 
    // Envoi du morceau
    // La longueur envoyée est
    //   4 ( taille de ttType ) + 4 ( taille de ttDebut ) + 4 ( taille de ttLong )
    //    + ttLong ( nombre de données envoyé )
    Form1->Client->Socket->SendBuf(ClientTrame, ttLong+12);
    Form1->MemoClient->Lines->add("Envoi du morceau " + IntToStr(ttDebut) + "[" + IntToStr(ttLong) + "]");
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ClientRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
int CodeRetour;
 
  With ClientTrame Do
{
    // On reçoit le code d'erreur du serveur, on le traite suivant les cas
    MemoClient->Lines->Add("OnRead: " + Socket->RemoteAddress);
    Socket->ReceiveBuf(CodeRetour,4);
 
    switch (ttType)
    {
      case 1:
      {
          // La dernière demande était un nom de fichier
          // On teste le code de retour
          If CodeRetour = 0
          {
            // Par d'erreur, l'envoi réel peut donc commencer
            ttDebut = 0;
            EnvoiBlocEnCours;
         }
          Else
          {
            // Le serveur refuse le fichier demandé => on arrète
            MemoClient->Lines->Add("Erreur "+IntToStr(CodeRetour));
            Client->Close;
          }
        }
 
      case 2:
      {
          // La dernière demande était un morceau de fichier
          // On teste le code de retour
          If CodeRetour = 0
          {
            // Pas d'erreur on avance dans le fichier de la longueur envoyée précédemment
            Inc(ttDebut, ttLong);
            If ttDebut >= FileSize(ClientFichier)
              Then Client->Close        // C'est la fin du fichier, on ferme la connection
              Else EnvoiBlocEnCours;   // ce n'est pas la fin, on envoie le morceau
          }
          Else
          {
            // Une erreur à eut lieu, on envoie le même morceau
            MemoClient->Lines->Add("Erreur "+IntToStr(CodeRetour));
            EnvoiBlocEnCours;
          }
        }
 
      Else
        // Normalement on ne doit pas passer ici.
        // au cas ou, on ferme la connection
        Client->Close;
    }
  }
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ClientDisconnect(TObject *Sender,
      TCustomWinSocket *Socket)
{
  // à la déconnection on ferme le fichier est cours de lecture
  MemoClient->Lines->Add("OnDisonnect: " + Socket->RemoteAddress);
  btnEnvoyer->Enabled = True;
  CloseFile(ClientFichier);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
  // On ne fait que signaler l'erreur
  MemoServeur->Lines->Add("OnClientError: " + Socket->RemoteAddress + #13 + MessageErreurSocket(ErrorEvent, ErrorCode));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnStopClick(TObject *Sender)
{
  // Arrêt du transfert en cours
  RetardDebut->Enabled = False;
  Client->Close;
  // fin de la partie client
}
//---------------------------------------------------------------------------

J'ai releve les erreurs que je n'arrive pas a solutionner actuellement.

sur cette fonction j'ai une erreur
Function MessageErreurSocket( ErrorEvent: TErrorEvent, var ErrorCode: Integer)
[C++ Error] serveur.cpp(107): E2451 Undefined symbol 'ErrorEvent'

sur cette declaration j'ai une erreur
[C++ Error] serveur.cpp(244): E2223 Too many decimal points
ttDatas = Array[0..TailleBloc-1] Of Byte;

sur cette declaration j'ai une erreur
[C++ Error] serveur.cpp(254): E2141 Declaration syntax error
File ServeurFichier;

sur cette fonction j'ai une erreur
[C++ Error] serveur.cpp(305): E2206 Illegal character '#' (0x23)
MemoServeur->Lines->Add("OnClientError: " + Socket->RemoteAddress + #13 + MessageErreurSocket(ErrorEvent, ErrorCode));

Il y a des fonctions qui ne sont pas evidentes a convertir si quelqu'un peu m'aider ce serait sympa si le source devient fonctionnel je le proposerais pour la FAQ.

**pottiez** · 20/09/2006, 18h33

Pour la fonction MessageErreurSocket, je croit que tu dois prendre l'evenement d'erreur du composant socket, et mettre le code dans cet evenement.

Remplace le #13 par '\n', et pour le File, il faut que tu gere ton fichier autrement, car ce n'est pas la même gestion des fichier, enfin pour la deuxieme erreur je ne sais pas.

**blondelle** · 20/09/2006, 18h56

pottiez a ecrit:

Pour la fonction MessageErreurSocket, je croit que tu dois prendre l'evenement d'erreur du composant socket, et mettre le code dans cet evenement.

Remplace le #13 par '\n', et pour le File, il faut que tu gere ton fichier autrement, car ce n'est pas la même gestion des fichier, enfin pour la deuxieme erreur je ne sais pas.

Merci pour tes reponses je vais deja corriger en fonction de tes reponses je continue a chercher.
A+

**blondelle** · 20/09/2006, 21h35

Pour mon erreur:

sur cette fonction j'ai une erreur
Function MessageErreurSocket( ErrorEvent: TErrorEvent, var ErrorCode: Integer)
[C++ Error] serveur.cpp(107): E2451 Undefined symbol 'ErrorEvent'

J'ai trouve TErrorEvent type qui semble correspondre, mais je ne vois pas comment l'utiliser.

**pottiez** · 20/09/2006, 22h39

De la même facon, avec le switch non ?

**blondelle** · 21/09/2006, 22h18

La je suis un peu pome, quels mots de commande utiliser pour boucler sur un fichier binaire ou texte, et en extraire une chaine, et pouvoir retrouver l'endroit ou s'est arretee l'extraction, pour en extraire une suivante je n'ai pas trouve d'exemple en BCB et dans l'aide en ligne il y en a trop, je ne sais plus quoi utiliser.

**pottiez** · 21/09/2006, 22h27

regarde du coté de la classe fstream, par contre ya pratiquement pas de doc dessus.

**pottiez** · 21/09/2006, 22h31

Si tu veut je peut te passer une classe de ma composition qui lit et ecrie des fichiers, mais elle n'est pas commanté et lit tout le fichier d'un coup, par contre tu as le contenue du fichier dans un AnsiString et apres tu en fait se que tu veut, le découper en plusieur morceau par exemple

**blondelle** · 21/09/2006, 23h34

pottiez a ecrit:

Si tu veut je peut te passer une classe de ma composition qui lit et ecrie des fichiers, mais elle n'est pas commanté et lit tout le fichier d'un coup, par contre tu as le contenue du fichier dans un AnsiString et apres tu en fait se que tu veut, le découper en plusieur morceau par exemple

Je veu bien la documentation est vraiment minime et il n'y a pas beaucoup d'exemples

**pottiez** · 22/09/2006, 13h43

Je t'envoye ca par mail ce soir, j'ai pas mes fichiers sous la main

**blondelle** · 22/09/2006, 13h58

Merci pottiez

**blondelle** · 26/09/2006, 21h34

J'ai reussi en C a envoyer des paquets de caracteres d'un TEdit a un autre je n'ai pas trouve comment faire en C++ ou en BCB.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
// voir dans decoupe
void __fastcall TForm1::Button1Click(TObject *Sender)
{
FILE *input;
int i;
i = 0;
char lettre;
String chaine;
String chaine1;
 
input = fopen("c:\\testrows.txt", "r");
 
while ((lettre = fgetc(input)) != EOF)
{
i = i++;
chaine = chaine + lettre;
if (i >= 5)
{
Label1->Caption = i; // NB caracteres envoyes
Edit1->Text = chaine; // chaines envoyees
Edit2->Text = Edit2->Text + chaine; // chaine reconstituee
chaine = "";
i = 0;
}
}
// on termine l'envoie avec ce qui reste
Label1->Caption = i; // NB caracteres envoyes
Edit1->Text = chaine; // chaines envoyees
Edit2->Text = Edit2->Text + chaine; // chaine reconstituee
}

Si on pouvait m'orienter sur la facon de faire en BCB ce serait super

**Bily.sdi** · 01/10/2006, 12h48

slt

J'ai trouve ce lien pour commencer

Citation:
http://www.developpez.org/club/g3dbu...t/tutoriel.htm

avant de commencer pense que dans le futur tu connectera plus d'un pc a ton serveur et surtout que tu voudras peut etre communiquer dans les 2 sens !!

que fairas tu ? cree des socket client statique sur ton appcliation serveur (pas bonne idée)

j'ai trouver ce super exmple pour toi !! il est bcp plus pro !!

auteur Neo41
http://ayman-ajaj.developpez.com

@+

Etablir une connexion entre deux postes

C++Builder

Discussions similaires

Partager

Partager