}
                } catch (Exception e) {
                    log.error("Failed to load handle file: " + handleFile, e);
                    Files.deleteIfExists(handleFile);
                }
            }
        } catch (IOException e) {
            log.error("Failed to load persisted handles", e);
        }
    }
    
    public void shutdown() {

     * @throws IOException if an I/O error occurs
     */
    public ACE[] getSecurity() throws IOException {
        return getSecurity(false);
    }

    /**
     * Returns the owner user SID for this file
     *
     * @return the owner user SID
     * @throws IOException if an I/O error occurs
     */
    public SID getOwnerUser() throws IOException {

     * Handles file download requests for SMB files.
     * @param req the HTTP servlet request
     * @param resp the HTTP servlet response
     * @param file the SMB file to download
     * @throws IOException if an I/O error occurs
     */
    protected void doFile(final HttpServletRequest req, final HttpServletResponse resp, final SmbFile file) throws IOException {
        final byte[] buf = new byte[8192];
        String url, type;

            try {
                // In real implementation: endpointGroup.close();
                log.info("DiSNI RDMA provider shut down");
            } catch (Exception e) {
                log.error("Error shutting down DiSNI", e);
            } finally {
                endpointGroup = null;
                endpoint = null;
                initialized = false;
            }
        }
    }

     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }

    /**

            }
        } catch (final Exception e) {
            logger.warn("Failed to {} user: username={}, id={}, error={}", isUpdate ? "update" : "create", username, user.getId(),
                    e.getMessage(), e);
            throw e;
        }
    }

    /**
     * Changes the password for a user identified by username.

                    log.warn(Arrays.toString(this.creationBacktrace));
                }
                emergencyCloseHandle();
            }
        } catch (Exception e) {
            log.error("Error during file handle finalization", e);
        } finally {
            super.finalize();
        }
    }

    /**
     * Emergency cleanup method to prevent resource leaks during finalization
     */

    public void setResponse(final CommonServerMessageBlockResponse msg) {

    }

    /**
     * Gets the error data associated with this message.
     *
     * @return the errorData
     */
    public final byte[] getErrorData() {
        return this.errorData;
    }

    /**
     * Gets the error context count for this message.
     *
     * @return the errorContextCount
     */

        // Test initial state
        assertTrue(response.hasMoreElements());

        // Test after setting error code (not status)
        response.setTestErrorCode(1); // Non-zero errorCode indicates error
        assertFalse(response.hasMoreElements());

        // Reset error and test hasMore flag
        response.setTestErrorCode(0);
        response.hasMore = false;

         * @throws ErrorResponseException If the server returns an error
         * @throws IllegalArgumentException If the arguments are invalid
         * @throws InsufficientDataException If insufficient data is available
         * @throws InternalException If an internal error occurs
         * @throws InvalidResponseException If the response is invalid