🚀 go-pugleaf

Je moet je helemaal niets aantrekken van die filesize?
Schrijven doe je in blokken van 2^n byte-arrays tot er niets meer komt.
Een write geeft normaal gezien ook nog eens het aantal effectief geschreven bytes terug. Hetzelfde met een receive: zo weet je 
meteen hoe groot je array moet zijn, als je variabele lengtes zou gebruiken voor je array.

btw: kijk eens naar java.net.DatagramPacket en DatagramSocket


"Pieter Vandewoestyne" <pieter.vandewoestyne@howest.be> wrote in message news:r3rsh.300661$W33.6038622@phobos.telenet-ops.be...
> Hoi,
> Ik probeer een client/server applicatie te schrijven die een bestand van de client uploadt naar de server.
> Het probleem hierbij is dat ik in de code van mijn server zelf de bestandsgrootte hard gecodeerd moet meegeven.
> Hoe zou ik er voor kunnen zorgen dat de server zelf weet wat de bestandsgrootte zal zijn van het bestand dat binnenkomt?
> Mijn code ziet er als volgt uit:
>
> SERVER
> ----------
>
> class fserver {
>
>    public static void main(String [] args ) throws IOException {
>        int filesize=10722; // filesize temporary hardcoded
>
>        // create socket
>        ServerSocket servsock = new ServerSocket(1111);
>        System.out.println("Waiting for connection...");
>        Socket sock = servsock.accept();
>        System.out.println("Accepted connection");
>
>        byte [] mybytearray  = new byte [filesize];
>
>        BufferedInputStream bis = new BufferedInputStream(sock.getInputStream(),filesize);
>        //  bis.read(mybytearray,0,mybytearray.length);
>
>        int bytesRead = 0;
>        while ( bytesRead < filesize ) {
>            int off = bytesRead;
>            int len = filesize - bytesRead;
>
>            int readCount = bis.read( mybytearray, off, len );
>
>            if ( readCount == -1 ) {  // chech for EOF
>                System.err.println( "unexpected EOF" );
>                System.exit( 1 );
>            }
>
>            bytesRead += readCount;
>        }
>
>        FileOutputStream fos = new FileOutputStream("C:\\briefcopy.doc");
>        BufferedOutputStream bos = new BufferedOutputStream(fos);
>        fos.write(mybytearray,0,mybytearray.length);
>
>        // cleanup after file transfer
>        sock.close();
>        servsock.close();
>    }
>
> }
>
>
> CLIENT
> -----------
>
> class fclient {
>
>        public static void main (String [] args ) throws IOException {
>
>                // create socket
>                Socket sock = new Socket("127.0.0.1",1111);
>                System.out.println("Connecting...");
>
>                // get the file handle to send
>
>                File myFile = new File( "C:\\brief.doc" );
>                byte [] mybytearray  = new byte [(int)myFile.length()];
>                FileInputStream fis = new FileInputStream(myFile);
>                BufferedInputStream bis = new BufferedInputStream(fis);
>                bis.read(mybytearray,0,mybytearray.length);
>                OutputStream os;
>                DataOutputStream dos;
>                os=sock.getOutputStream();
>                dos=new DataOutputStream(os);
>                System.out.println("Sending...");
>                dos.write(mybytearray,0,mybytearray.length);
>
>                // cleanup
>
>                sock.close();
>
>        }
>
> }
>
>
> -------------------------------------------------------------------
>
> Alvast bedankt,
> Pieter
>
>
>
> 

Pieter Vandewoestyne wrote:
> Hoi,
> Ik probeer een client/server applicatie te schrijven die een bestand van de 
> client uploadt naar de server.
> Het probleem hierbij is dat ik in de code van mijn server zelf de 
> bestandsgrootte hard gecodeerd moet meegeven.
> Hoe zou ik er voor kunnen zorgen dat de server zelf weet wat de 
> bestandsgrootte zal zijn van het bestand dat binnenkomt?
> Mijn code ziet er als volgt uit:
> 
> SERVER
> ----------
> 
> class fserver {
> 
>     public static void main(String [] args ) throws IOException {
>         int filesize=10722; // filesize temporary hardcoded
> 
>         // create socket
>         ServerSocket servsock = new ServerSocket(1111);
>         System.out.println("Waiting for connection...");
>         Socket sock = servsock.accept();
>         System.out.println("Accepted connection");
> 
>         byte [] mybytearray  = new byte [filesize];
> 
>         BufferedInputStream bis = new 
> BufferedInputStream(sock.getInputStream(),filesize);
>         //  bis.read(mybytearray,0,mybytearray.length);
> 
>         int bytesRead = 0;
>         while ( bytesRead < filesize ) {
>             int off = bytesRead;
>             int len = filesize - bytesRead;
> 
>             int readCount = bis.read( mybytearray, off, len );
> 
>             if ( readCount == -1 ) {  // chech for EOF
>                 System.err.println( "unexpected EOF" );
>                 System.exit( 1 );
>             }
> 
>             bytesRead += readCount;
>         }
> 
>         FileOutputStream fos = new FileOutputStream("C:\\briefcopy.doc");
>         BufferedOutputStream bos = new BufferedOutputStream(fos);
>         fos.write(mybytearray,0,mybytearray.length);
> 
>         // cleanup after file transfer
>         sock.close();
>         servsock.close();
>     }
> 
> }
> 
> 
> CLIENT
> -----------
> 
> class fclient {
> 
>         public static void main (String [] args ) throws IOException {
> 
>                 // create socket
>                 Socket sock = new Socket("127.0.0.1",1111);
>                 System.out.println("Connecting...");
> 
>                 // get the file handle to send
> 
>                 File myFile = new File( "C:\\brief.doc" );
>                 byte [] mybytearray  = new byte [(int)myFile.length()];
>                 FileInputStream fis = new FileInputStream(myFile);
>                 BufferedInputStream bis = new BufferedInputStream(fis);
>                 bis.read(mybytearray,0,mybytearray.length);
>                 OutputStream os;
>                 DataOutputStream dos;
>                 os=sock.getOutputStream();
>                 dos=new DataOutputStream(os);
>                 System.out.println("Sending...");
>                 dos.write(mybytearray,0,mybytearray.length);
> 
>                 // cleanup
> 
>                 sock.close();
> 
>         }
> 
> }
> 
> 
> -------------------------------------------------------------------
> 
> Alvast bedankt,
> Pieter
> 
> 
> 
> 
Als je echt deze wijze wil gebruiken dan maak je eerst een protocol op. 
      Een soort van afspraak tussen client en server.  De client stuurt 
eerst in bv 32bytes(tekstvorm) de lengte op van het bestand, zo weet de 
server zijde hoeveel hij binnen moet krijgen.
Zelf gebruik ik headers en footers rond de berichten die ik zend.  Zo 
weet de server perfect wanneer hij een volledige boodschap heeft.

Hoop je hiermee verder op weg te helpen....

MS:  Je kan altijd FTP gebruiken........

Pascal

Ik heb het kunnen oplossen, maar nu zit ik met een ander probleem:
Wanneer ik meerdere files selecteer om te backuppen naar mijn server, 
schrijft hij enkel de eerste file weg, daarna hangt de applicatie vast en 
wordt er geen verdere code uitgevoerd.
Hieronder mijn code:

CLIENT-code
----------------
    private void btnBackupActionPerformed(java.awt.event.ActionEvent evt) {

        for (File f:backupfileslist) {

            try{

                client.sendMessage("Make Backup");
                System.out.println(f);

                String remoteFilename = f.getAbsolutePath();
                String localFilename = f.getAbsolutePath();
                InputStream socketIn = client.getLink().getInputStream();
                DataOutputStream socketOut = new 
DataOutputStream(client.getLink().getOutputStream());
                FileInputStream fis = new FileInputStream(localFilename);

                //writethe filename
                socketOut.writeUTF(remoteFilename);

                int bytesRead;
                byte[] buffer = new byte[3000];


              // write out the file
                while((bytesRead = fis.read(buffer, 0, buffer.length)) >= 0) 
{
                    socketOut.write(buffer, 0, bytesRead);
                    socketOut.flush();
                }

                fis.close();

            } catch (FileNotFoundException ex) {
                ex.printStackTrace();

            } catch (IOException ioe){
                ioe.printStackTrace();
            }
        }

    }


SERVER-code
-----------------

    public void checkMessage(String sMessage) {

        if (sMessage.startsWith("Make Backup")){

            try{

                // for reading the filename
                socketIn = new 
DataInputStream(clientSocket.getInputStream());

                //read the filename
                String filename = socketIn.readUTF();
                String remotefilename = filename.substring(3);
                String remotefilepath = "D:\\" + remotefilename;

                System.out.println("Sending file " + remotefilepath);

                // write the file
                FileOutputStream fos = new FileOutputStream(remotefilepath);

                int data;
                int totalDataRead;
                byte[] buffer = new byte[3000];
                boolean isLastPacket = false;


                // read file byte per byte
                totalDataRead =  socketIn.read(buffer, 0, buffer.length);

                if(totalDataRead >= 1024){
                    while (totalDataRead != -1) {
                        // write data
                        fos.write(buffer,0, totalDataRead);
                        fos.flush();

                        if(!isLastPacket){
                            totalDataRead =  socketIn.read(buffer, 0, 
buffer.length);
                            if (totalDataRead < 1024) {
                                isLastPacket = true;
                            }
                        } else {
                            totalDataRead = -1;
                            isLastPacket = false;
                        }
                    }
                } else {
                    fos.write(buffer,0, totalDataRead);
                    fos.flush();
                }

                clientSocket.close();
                socketIn.close();
                fos.close();

            }catch(Exception ex){
                System.out.println("file transfer failed");
            }

            System.out.println("File transfer complete");

        }

    }

-----------------------------------------------

Iemand die ziet wat ik hier verkeerd doe?
Groetjes,
Pieter