I am putting together a fairly simple server that listens for a connection then creates this thread - textbook Java code - then accepts data on that connection.

I am following a protocol that the manufacturer has laid out for start of message(0xfd) and EOM( 0xfe) as below. I then simply populate a byte array with using a bytecounter.

I think this is the simplest doing so, and it seems to work fine. Is there any possible problem with taking this approach? I want to be sure using a bytecounter with an array is acceptable. I can't see anyway that bytecounter could get out of sync or anything like that. I like to keeps things simple. Is there anything wrong with this code with regard to stuffing the 'inbyte[]' array?

public void run() {

try {


    boolean socketalive = true;

    MSG_ID = 0;

    disIn = new DataInputStream( in  );
    disOut = new DataOutputStream ( out );

    String msg = null;

    StringBuilder hexforlog;

    byte[] c ;


    int i = 0;
    int bytecounter = 0;

    byte[] inbyte ;

    while( true ){



        i = 0;
        bytecounter = 0;

        inbyte = new byte[1024];

        byte b ;





        try{

            /* read from network until end of message byte is received */
            while( ( b = disIn.readByte() ) !=  (byte)0xfe ){

                /* checking for start of message */
                if( b == (byte)0xfd  ){


                    inbyte = new byte[1024];
                    inbyte[0] = b;
                    bytecounter = 1;


                }
                else {

                     inbyte[bytecounter] = b;
                     bytecounter++;

                }


            }

        }catch ( java.io.EOFException ioef ){
            System.out.println("EOF recieved bytes"  );
            break;
        }




        /*test for link verification */

        if( bytecounter == 15 ){


             byte SOURCEbyte = inbyte[2];
             byte DESTbyte = inbyte[3];

             /* swap bytes per protocol */
             inbyte[2] = (byte)DESTbyte;
             inbyte[3] = (byte)SOURCEbyte;


            disOut.write( java.util.Arrays.copyOfRange(inbyte,0,16) );
            disOut.flush();

        }





        /* process the data as per manufacturer spec */ 
        else if( bytecounter> 16  ){



            arrayindex = 12;

            int SOM = inbyte[0];
            int CLASS = inbyte[1];
            int SOURCE = inbyte[2];
            int DEST = inbyte[3];
            int MSG_PRG_NUMBER = inbyte[4];
            int SPARE1 = inbyte[5];
            int SPARE2 = inbyte[6];
            int SPARE3 = inbyte[7];

            LENGTH = twoBytesToInt( new byte[] { inbyte[8], inbyte[9] } );



            NUM_MSG = twoBytesToInt( new byte[] {  inbyte[10], inbyte[11]  } );

           System.out.println("LENGTH: " + LENGTH  + " NUM_MSG: " + NUM_MSG );
           System.out.println("Setting NUM_MSG to 1" );

            NUM_MSG = 1;




            for ( int j=0; j<NUM_MSG; j++  ) {


                MSG_ID = twoBytesToInt( new byte[] { inbyte[arrayindex],    
                     inbyte[arrayindex+1] } );

                System.out.println("MSG_ID: " + MSG_ID );

                MSG_LENGTH =twoBytesToInt( new byte[] { inbyte[arrayindex+2],  
                    inbyte[arrayindex+3] } );

                System.out.println("MSG_LENGTH: " + MSG_LENGTH  );

                arrayindex = arrayindex+4; //first go around 15



                currentarray = java.util.Arrays.copyOfRange( 
                   inbyte, arrayindex, arrayindex+MSG_LENGTH+1);

                arrayindex = arrayindex+MSG_LENGTH ;

                //process messages

                if(MSG_ID == 50){
                    processMessage50( currentarray );
                }
                else if(MSG_ID == 70){
                    processMessage70( currentarray);
                }


            }


        }






    }

    disIn.close();
    disOut.close();


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

}