Struct xpcom::interfaces::nsINetUtil

#[repr(C)]
pub struct nsINetUtil { /* fields omitted */ }

interface nsINetUtil : nsISupports

/**
 * nsINetUtil provides various network-related utility methods.
 */

Methods

impl nsINetUtil

pub fn coerce<T: nsINetUtilCoerce>(&self) -> &T

Cast this nsINetUtil to one of its base interfaces.

impl nsINetUtil

pub const ESCAPE_ALL: i64

ESCAPE_ALL: i64 = 0

/** Escape every character with its %XX-escaped equivalent */

pub const ESCAPE_XALPHAS: i64

ESCAPE_XALPHAS: i64 = 1

/** Leave alphanumeric characters intact and %XX-escape all others */

pub const ESCAPE_XPALPHAS: i64

ESCAPE_XPALPHAS: i64 = 2

/** Leave alphanumeric characters intact, convert spaces to '+',
      %XX-escape all others */

pub const ESCAPE_URL_PATH: i64

ESCAPE_URL_PATH: i64 = 4

/** Leave alphanumeric characters and forward slashes intact,
      %XX-escape all others */

pub const ESCAPE_URL_SCHEME: i64

ESCAPE_URL_SCHEME: i64 = 1

/** %XX-escape URL scheme */

pub const ESCAPE_URL_USERNAME: i64

ESCAPE_URL_USERNAME: i64 = 2

/** %XX-escape username in the URL */

pub const ESCAPE_URL_PASSWORD: i64

ESCAPE_URL_PASSWORD: i64 = 4

/** %XX-escape password in the URL */

pub const ESCAPE_URL_HOST: i64

ESCAPE_URL_HOST: i64 = 8

/** %XX-escape URL host */

pub const ESCAPE_URL_DIRECTORY: i64

ESCAPE_URL_DIRECTORY: i64 = 16

/** %XX-escape URL directory */

pub const ESCAPE_URL_FILE_BASENAME: i64

ESCAPE_URL_FILE_BASENAME: i64 = 32

/** %XX-escape file basename in the URL */

pub const ESCAPE_URL_FILE_EXTENSION: i64

ESCAPE_URL_FILE_EXTENSION: i64 = 64

/** %XX-escape file extension in the URL */

pub const ESCAPE_URL_PARAM: i64

ESCAPE_URL_PARAM: i64 = 128

/** %XX-escape URL parameters */

pub const ESCAPE_URL_QUERY: i64

ESCAPE_URL_QUERY: i64 = 256

/** %XX-escape URL query */

pub const ESCAPE_URL_REF: i64

ESCAPE_URL_REF: i64 = 512

/** %XX-escape URL ref */

pub const ESCAPE_URL_FILEPATH: i64

ESCAPE_URL_FILEPATH: i64 = 112

/** %XX-escape URL path - same as escaping directory, basename and extension */

pub const ESCAPE_URL_MINIMAL: i64

ESCAPE_URL_MINIMAL: i64 = 1023

/** %XX-escape scheme, username, password, host, path, params, query and ref */

pub const ESCAPE_URL_FORCED: i64

ESCAPE_URL_FORCED: i64 = 1024

/** Force %XX-escaping of already escaped sequences */

pub const ESCAPE_URL_ONLY_ASCII: i64

ESCAPE_URL_ONLY_ASCII: i64 = 2048

/** Skip non-ascii octets, %XX-escape all others */

pub const ESCAPE_URL_ONLY_NONASCII: i64

ESCAPE_URL_ONLY_NONASCII: i64 = 4096

/**
   * Skip graphic octets (0x20-0x7E) when escaping
   * Skips all ASCII octets (0x00-0x7F) when unescaping
   */

pub const ESCAPE_URL_COLON: i64

ESCAPE_URL_COLON: i64 = 16384

/** Force %XX-escape of colon */

pub const ESCAPE_URL_SKIP_CONTROL: i64

ESCAPE_URL_SKIP_CONTROL: i64 = 32768

/** Skip C0 and DEL from unescaping */

pub unsafe fn ParseRequestContentType(
    &self,
    aTypeHeader: &nsACString,
    aCharset: &mut nsACString,
    aHadCharset: *mut bool,
    _retval: &mut nsACString
) -> nsresult

/**
   * Parse a Content-Type header value in strict mode.  This is a more
   * conservative parser that reject things that violate RFC 7231 section
   * 3.1.1.1.  This is typically useful for parsing Content-Type header values
   * that are used for HTTP requests, and those that are used to make security
   * decisions.
   *
   * @param aTypeHeader the header string to parse
   * @param [out] aCharset the charset parameter specified in the
   *              header, if any.
   * @param [out] aHadCharset whether a charset was explicitly specified.
   * @return the MIME type specified in the header, in lower-case.
   */

AUTF8String parseRequestContentType (in AUTF8String aTypeHeader, out AUTF8String aCharset, out boolean aHadCharset);

pub unsafe fn ParseResponseContentType(
    &self,
    aTypeHeader: &nsACString,
    aCharset: &mut nsACString,
    aHadCharset: *mut bool,
    _retval: &mut nsACString
) -> nsresult

/**
   * Parse a Content-Type header value in relaxed mode.  This is a more
   * permissive parser that ignores things that go against RFC 7231 section
   * 3.1.1.1.  This is typically useful for parsing Content-Type header values
   * received from web servers where we want to make a best effort attempt
   * at extracting a useful MIME type and charset.
   *
   * NOTE: DO NOT USE THIS if you're going to make security decisions
   * based on the result.
   *
   * @param aTypeHeader the header string to parse
   * @param [out] aCharset the charset parameter specified in the
   *              header, if any.
   * @param [out] aHadCharset whether a charset was explicitly specified.
   * @return the MIME type specified in the header, in lower-case.
   */

AUTF8String parseResponseContentType (in AUTF8String aTypeHeader, out AUTF8String aCharset, out boolean aHadCharset);

pub unsafe fn ProtocolHasFlags(
    &self,
    aURI: *const nsIURI,
    aFlag: uint32_t,
    _retval: *mut bool
) -> nsresult

/**
   * Test whether the given URI's handler has the given protocol flags.
   *
   * @param aURI the URI in question
   * @param aFlags the flags we're testing for.
   *
   * @return whether the protocol handler for aURI has all the flags
   *         in aFlags.
   */

boolean protocolHasFlags (in nsIURI aURI, in unsigned long aFlag);

pub unsafe fn URIChainHasFlags(
    &self,
    aURI: *const nsIURI,
    aFlags: uint32_t,
    _retval: *mut bool
) -> nsresult

/**
   * Test whether the protocol handler for this URI or that for any of
   * its inner URIs has the given protocol flags.  This will QI aURI to
   * nsINestedURI and walk the nested URI chain.
   *
   * @param aURI the URI in question
   * @param aFlags the flags we're testing for.
   *
   * @return whether any of the protocol handlers involved have all the flags
   *         in aFlags.
   */

boolean URIChainHasFlags (in nsIURI aURI, in unsigned long aFlags);

pub unsafe fn ToImmutableURI(
    &self,
    aURI: *const nsIURI,
    _retval: *mut *const nsIURI
) -> nsresult

/**
   * Take aURI and produce an immutable version of it for the caller.  If aURI
   * is immutable this will be aURI itself; otherwise this will be a clone,
   * marked immutable if possible.  Passing null to this method is allowed; in
   * that case it will return null.
   */

nsIURI toImmutableURI (in nsIURI aURI);

pub unsafe fn NewSimpleNestedURI(
    &self,
    aURI: *const nsIURI,
    _retval: *mut *const nsIURI
) -> nsresult

/**
   * Create a simple nested URI using the result of
   * toImmutableURI on the passed-in aURI which may not be null.
   * Note: The return URI will not have had its spec set yet.
   */

nsIURI newSimpleNestedURI (in nsIURI aURI);

pub unsafe fn EscapeString(
    &self,
    aString: &nsACString,
    aEscapeType: uint32_t,
    _retval: &mut nsACString
) -> nsresult

/**
   * escape a string with %00-style escaping
   */

ACString escapeString (in ACString aString, in unsigned long aEscapeType);

pub unsafe fn EscapeURL(
    &self,
    aStr: &nsACString,
    aFlags: uint32_t,
    _retval: &mut nsACString
) -> nsresult

/**
   * %XX-Escape invalid chars in a URL segment.
   *
   * @param aStr the URL to be escaped
   * @param aFlags the URL segment type flags
   *
   * @return the escaped string (the string itself if escaping did not happen)
   *
   */

ACString escapeURL (in ACString aStr, in unsigned long aFlags);

pub unsafe fn UnescapeString(
    &self,
    aStr: &nsACString,
    aFlags: uint32_t,
    _retval: &mut nsACString
) -> nsresult

/**
   * Expands URL escape sequences
   *
   * @param aStr the URL to be unescaped
   * @param aFlags only ESCAPE_URL_ONLY_NONASCII and ESCAPE_URL_SKIP_CONTROL
   *               are recognized.  If |aFlags| is 0 all escape sequences are
   *               unescaped
   * @return unescaped string
   */

ACString unescapeString (in AUTF8String aStr, in unsigned long aFlags);

pub unsafe fn ExtractCharsetFromContentType(
    &self,
    aTypeHeader: &nsACString,
    aCharset: &mut nsACString,
    aCharsetStart: *mut int32_t,
    aCharsetEnd: *mut int32_t,
    _retval: *mut bool
) -> nsresult

/**
   * Extract the charset parameter location and value from a content-type
   * header.
   *
   * @param aTypeHeader the header string to parse
   * @param [out] aCharset the charset parameter specified in the
   *              header, if any.
   * @param [out] aCharsetStart index of the start of the charset parameter
   *              (the ';' separating it from what came before) in aTypeHeader.
   *              If this function returns false, this argument will still be
   *              set, to the index of the location where a new charset should
   *              be inserted.
   * @param [out] aCharsetEnd index of the end of the charset parameter (the
   *              ';' separating it from what comes after, or the end
   *              of the string) in aTypeHeader.  If this function returns
   *              false, this argument will still be set, to the index of the
   *              location where a new charset should be inserted.
   *
   * @return whether a charset parameter was found.  This can be false even in
   * cases when parseContentType would claim to have a charset, if the type
   * that won out does not have a charset parameter specified.
   */

boolean extractCharsetFromContentType (in AUTF8String aTypeHeader, out AUTF8String aCharset, out long aCharsetStart, out long aCharsetEnd);

pub unsafe fn ParseAttributePolicyString(
    &self,
    aPolicyString: &nsAString,
    _retval: *mut uint32_t
) -> nsresult

/**
   * Parse an attribute referrer policy string (no-referrer, origin, unsafe-url)
   * and return the according integer code (defined in nsIHttpChannel.idl)
   *
   * @param aPolicyString
   *        the policy string given as attribute
   * @return aPolicyEnum
   *         referrer policy code from nsIHttpChannel.idl, (see parser in
   *         ReferrerPolicy.h for details)
   */

unsigned long parseAttributePolicyString (in AString aPolicyString);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsINetUtil

const IID: nsIID

IID: nsIID = nsID(4263912940, 47236, 19953, [179, 156, 158, 131, 14, 71, 170, 148])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsINetUtil

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsINetUtil

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.