<dependency>
    <groupId>org.codelibs</groupId>
    <artifactId>jcifs</artifactId>
    <version>2.1.39</version>
</dependency>
```



## Features

### Protocol Support
The library supports a full range of SMB protocols with automatic negotiation:

**Supported Protocols:**
- **SMB1/CIFS**: Legacy support via `jcifs.smb1/` package
- **SMB 2.0.2**: Windows Vista+ (0x0202)
- **SMB 2.1**: Windows 7/Server 2008R2 (0x0210)

crawler.urlFilter.addInclude(".*\\.pdf$");

// Exclude patterns  
crawler.urlFilter.addExclude(".*\\.js$");
crawler.urlFilter.addExclude(".*login.*");
```

## Supported Protocols and Formats

### Protocols
- **HTTP/HTTPS**: Full web crawling support with cookies, authentication, redirects
- **File System**: Local and network file system access
- **FTP**: FTP server crawling with authentication

import jcifs.CIFSException;

/**
 * Unified authentication provider interface for SMB authentication
 *
 * This interface provides a consistent authentication mechanism across
 * SMB1, SMB2, and SMB3 protocols, addressing the issue of multiple
 * scattered authentication implementations.
 */
public interface AuthenticationProvider {

    /**
     * Authentication type enumeration
     */
    enum AuthType {

## Origin { #origin }

An origin is the combination of protocol (`http`, `https`), domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`), and port (`80`, `443`, `8080`).

So, all these are different origins:

* `http://localhost`
* `https://localhost`
* `http://localhost:8080`

Even if they are all in `localhost`, they use different protocols or ports, so, they are different "origins".

## Steps { #steps }

But it provides you the tools to simplify the process as much as possible without compromising flexibility, robustness, or security.

And you can use and implement secure, standard protocols, like OAuth2 in a relatively simple way.

        assertTrue(urlFilter.match("https://example.com/日本/page"));
        assertFalse(urlFilter.match("https://example.com/china/page"));
    }

    /**
     * Test URL with special protocols
     */
    public void test_specialProtocols() {
        String sessionId = "test-session-022";
        urlFilter.init(sessionId);

        urlFilter.addInclude("(http|https|ftp|file)://.*");

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.RuntimeCIFSException;
import jcifs.smb.RequestParam;

/**
 * This class simplifies communication for protocols that support
 * multiplexing requests. It encapsulates a stream and some protocol
 * knowledge (provided by a concrete subclass) so that connecting,
 * disconnecting, sending, and receiving can be syncronized

                }
            }
        }
    }

    /**
     * Initializes the minimum and maximum protocol versions from string values.
     *
     * @param minStr string representation of minimum protocol version
     * @param maxStr string representation of maximum protocol version
     */
    protected void initProtocolVersions(final String minStr, final String maxStr) {

        final Smb2TransformHeader header = new Smb2TransformHeader();

        // Check protocol ID
        final int protocolId = SMBUtil.readInt4(buffer, bufferIndex);
        if (protocolId != TRANSFORM_PROTOCOL_ID) {
            throw new IllegalArgumentException("Invalid transform header protocol ID: 0x" + Integer.toHexString(protocolId));
        }
        bufferIndex += 4;

        // Read signature

            }
        } else {
            failedValidations.incrementAndGet();
            log.warn("Invalid SMB protocol ID: 0x{}", Integer.toHexString(protocolId));
            throw new SmbException("Invalid SMB protocol identifier");
        }

        // Validate command is in valid range
        if (command < 0 || command > 255) {
            failedValidations.incrementAndGet();