docs: public boolean read(ByteBuffer fileBuffer)
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "read", new Object[] { fileBuffer, this });
  
          long checkDate = -1;
          long checkFirstRecordSequenceNumber = -1;
          int dataLength = -1;
          boolean valid = false;
          _status = STATUS_INVALID;
  
          // Only if the header is decoded sucessfully will the _compatible field be
          // set to true. By default, assume that the header is incompatible.
          _compatible = false;
  
          try
          {
              // The first n-bytes in the file (typically 4) contain an integer which
              // holds the length of header data. The header data starts on the first
              // byte after this integer.
              int headerLength = fileBuffer.getInt();
  
              // If the header length is positive and there are enough bytes in the file
              // to support this length header then attempt to load it from the file.
              if ((headerLength > 0) && (headerLength <= (fileBuffer.capacity() - fileBuffer.position())))
              {
                  // Read the "MAGIC" number at the top of the header. This is to help
                  // identify the file as a WebSphere recovery log file.
                  byte[] magicNumberBuffer = new byte[LogFileHeader.MAGIC_NUMBER.length];
                  fileBuffer.get(magicNumberBuffer);
  
                  if (validMagicNumber(magicNumberBuffer))
                  {
                      // RLS Version number
                      _creatorRLSVersionNumber = fileBuffer.getInt();
  
                      if (tc.isDebugEnabled())
                          Tr.debug(tc, "Recovery log creator version is " + _creatorRLSVersionNumber);
                      if (tc.isDebugEnabled())
                          Tr.debug(tc, "Current recovery log version is " + Configuration.RLS_VERSION);
  
                      // Now we need to examine this field to see if this version of the file can be parsed
                      // by this level of the code.
                      int i = 0;
  
                      while (!_compatible && (i < Configuration.COMPATIBLE_RLS_VERSIONS.length))
                      {
                          if (_creatorRLSVersionNumber == Configuration.COMPATIBLE_RLS_VERSIONS[i])
                          {
                              _compatible = true;
                          }
                          i++;
                      }
  
                      if (_compatible)
                      {
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "This version of recovery log file can be parsed by this level of the RLS");
  
                          // Status field
                          _status = fileBuffer.getInt();
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file state is " + LogFileHeader.statusToString(_status));
  
                          // Date of file creation/update
                          _date = fileBuffer.getLong();
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file date (long) is " + _date);
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file date (date) is " + new Date(_date).toString());
  
                          // Sequence Number of first entry
                          _firstRecordSequenceNumber = fileBuffer.getLong();
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file first record sequence number is " + _firstRecordSequenceNumber);
  
                          // Server Name
                          int stringLength = fileBuffer.getInt();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Reading String of length " + stringLength);
                          byte[] serverNameBytes = new byte[stringLength];
                          fileBuffer.get(serverNameBytes);
                          _serverName = new String(serverNameBytes);
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file created on server " + _serverName);
  
                          // Service Name
                          stringLength = fileBuffer.getInt();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Reading String of length " + stringLength);
                          byte[] serviceNameBytes = new byte[stringLength];
                          fileBuffer.get(serviceNameBytes);
                          _serviceName = new String(serviceNameBytes);
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file created by service " + _serviceName);
  
                          // Service Version
                          _serviceVersion = fileBuffer.getInt();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file created by service version" + _serviceVersion);
  
                          // Log Name
                          stringLength = fileBuffer.getInt();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Reading String of length " + stringLength);
                          byte[] logNameBytes = new byte[stringLength];
                          fileBuffer.get(logNameBytes);
                          _logName = new String(logNameBytes);
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log name was " + _logName);
  
                          // Length of Service Data and Service Data
                          dataLength = fileBuffer.getInt();
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file contains " + dataLength + " bytes of service specific information");
  
                          if (dataLength > 0)
                          {
                              // check if we have RLS variable header
                              byte[] varHeaderTest = new byte[VARIABLE_FIELD_HEADER.length];
                              int currPosition = fileBuffer.position();
                              fileBuffer.get(varHeaderTest);
  
                              if (_useVariableFieldHeader && Arrays.equals(varHeaderTest, VARIABLE_FIELD_HEADER))
                              {
                                  // length of variable RLS header
                                  int rlsVarFieldLength = fileBuffer.getInt();
  
                                  if (rlsVarFieldLength > 0)
                                  {
                                      _variableFieldData = new byte[rlsVarFieldLength];
                                      fileBuffer.get(_variableFieldData);
                                      parseVariableFieldData();
                                  }
  
                                  if (dataLength - rlsVarFieldLength - VARIABLE_FIELD_HEADER.length - RLSUtils.INT_SIZE > 0)
                                  {
                                      // we also have service data
                                      _serviceData = new byte[dataLength - rlsVarFieldLength];
                                      fileBuffer.get(_serviceData);
                                  }
                              }
                              else
                              {
                                  // we just have service data
                                  _variableFieldData = null; // not inited because we don't want to write it in this cycle unless it was there already
                                  fileBuffer.position(currPosition);
                                  _serviceData = new byte[dataLength];
                                  fileBuffer.get(_serviceData);
                              }
                          }
                          else
                          {
                              _variableFieldData = null; // not inited because we don't want to write it in this cycle unless it was there already
                              _serviceData = null;
                          }
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "RLS var data Information is [" + RLSUtils.toHexString(_variableFieldData, RLSUtils.MAX_DISPLAY_BYTES) + "]");
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Service Specific Information is [" + RLSUtils.toHexString(_serviceData, RLSUtils.MAX_DISPLAY_BYTES) + "]");
  
                          // Date Of Creation (re-written to provide validation of previous information)
                          checkDate = fileBuffer.getLong();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file check date (long) is " + checkDate);
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file check date (date) is " + new Date(checkDate).toString());
  
                          // Sequence Number of first entry (re-written to provide validation of previous information)
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Reading FRSN from position " + fileBuffer.position());
  
                          checkFirstRecordSequenceNumber = fileBuffer.getLong();
  
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Recovery log file check first record sequence number is " + checkFirstRecordSequenceNumber);
  
                          // Now determine if this header was valid or not.
                          if ((_date == checkDate) &&
                              (_firstRecordSequenceNumber == checkFirstRecordSequenceNumber) &&
                              (_date > 0))
                          {
                              valid = true;
                          }
                          else
                          {
                              changeStatus(STATUS_INVALID);
                              if (tc.isEventEnabled())
                                  Tr.event(tc, "Error processing recovery log file header - integrity check failed");
                          }
                      }
                      else
                      {
                          reset();
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "This version of recovery log file can not be parsed by this level of the RLS");
                      }
                  }
              }
          } catch (BufferUnderflowException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogFileHeader.read", "603", this);
              if (tc.isEventEnabled())
                  Tr.event(tc, "Error processing recovery log file header", exc.toString());
              changeStatus(STATUS_INVALID);
          } catch (Throwable exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogFileHeader.read", "609", this);
              if (tc.isEventEnabled())
                  Tr.event(tc, "Error processing recovery log file header", exc.toString());
              changeStatus(STATUS_INVALID);
          }
  
          boolean readOK = (_compatible && valid);
  
          if (_logFileHeaderReadCallback != null)
          {
              // exceptions from here don't change the outcome as they are handled in LogFileHandle.readFileHeader()
              _logFileHeaderReadCallback.readComplete(this, readOK);
          }
          if (tc.isEntryEnabled())
              Tr.exit(tc, "read", new Boolean(readOK));
  
          return readOK;
      }