mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
dc33cae831
There's no longer any reason why "certificate principals" need to be principals at all. I tried to rip them out entirely, but it looks like they're still used vestigially at XPI install time to display author information. But there's no reason that they have to be porkbarreled into the security-critical objects that we pass around all over the place. So let's make them their own deal. I was tempted to call them "certificate holders", but that would involve renaming methods and cause more compat fuss than necessary. --HG-- rename : caps/idl/nsISignatureVerifier.idl => security/manager/ssl/public/nsISignatureVerifier.idl
240 lines
9.4 KiB
Plaintext
240 lines
9.4 KiB
Plaintext
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsISupports.idl"
|
|
|
|
interface nsIUTF8StringEnumerator;
|
|
interface nsIInputStream;
|
|
interface nsIFile;
|
|
interface nsICertificatePrincipal;
|
|
|
|
[scriptable, uuid(e1c028bc-c478-11da-95a8-00e08161165f)]
|
|
interface nsIZipEntry : nsISupports
|
|
{
|
|
/**
|
|
* The type of compression used for the item. The possible values and
|
|
* their meanings are defined in the zip file specification at
|
|
* http://www.pkware.com/business_and_developers/developer/appnote/
|
|
*/
|
|
readonly attribute unsigned short compression;
|
|
/**
|
|
* The compressed size of the data in the item.
|
|
*/
|
|
readonly attribute unsigned long size;
|
|
/**
|
|
* The uncompressed size of the data in the item.
|
|
*/
|
|
readonly attribute unsigned long realSize;
|
|
/**
|
|
* The CRC-32 hash of the file in the entry.
|
|
*/
|
|
readonly attribute unsigned long CRC32;
|
|
/**
|
|
* True if the name of the entry ends with '/' and false otherwise.
|
|
*/
|
|
readonly attribute boolean isDirectory;
|
|
/**
|
|
* The time at which this item was last modified.
|
|
*/
|
|
readonly attribute PRTime lastModifiedTime;
|
|
/**
|
|
* Use this attribute to determine whether this item is an actual zip entry
|
|
* or is one synthesized for part of a real entry's path. A synthesized
|
|
* entry represents a directory within the zip file which has no
|
|
* corresponding entry within the zip file. For example, the entry for the
|
|
* directory foo/ in a zip containing exactly one entry for foo/bar.txt
|
|
* is synthetic. If the zip file contains an actual entry for a directory,
|
|
* this attribute will be false for the nsIZipEntry for that directory.
|
|
* It is impossible for a file to be synthetic.
|
|
*/
|
|
readonly attribute boolean isSynthetic;
|
|
};
|
|
|
|
[scriptable, uuid(38d6d07a-8a58-4fe7-be8b-ef6472fa83ff)]
|
|
interface nsIZipReader : nsISupports
|
|
{
|
|
/**
|
|
* Opens a zip file for reading.
|
|
* It is allowed to open with another file,
|
|
* but it needs to be closed first with close().
|
|
*/
|
|
void open(in nsIFile zipFile);
|
|
|
|
/**
|
|
* Opens a zip file inside a zip file for reading.
|
|
*/
|
|
void openInner(in nsIZipReader zipReader, in AUTF8String zipEntry);
|
|
|
|
/**
|
|
* The file that represents the zip with which this zip reader was
|
|
* initialized.
|
|
*/
|
|
readonly attribute nsIFile file;
|
|
|
|
/**
|
|
* Closes a zip reader. Subsequent attempts to extract files or read from
|
|
* its input stream will result in an error.
|
|
*/
|
|
void close();
|
|
|
|
/**
|
|
* Tests the integrity of the archive by performing a CRC check
|
|
* on each item expanded into memory. If an entry is specified
|
|
* the integrity of only that item is tested. If null (javascript)
|
|
* or EmptyCString() (c++) is passed in the integrity of all items
|
|
* in the archive are tested.
|
|
*/
|
|
void test(in AUTF8String aEntryName);
|
|
|
|
/**
|
|
* Extracts a zip entry into a local file specified by outFile.
|
|
* The entry must be stored in the zip in either uncompressed or
|
|
* DEFLATE-compressed format for the extraction to be successful.
|
|
* If the entry is a directory, the directory will be extracted
|
|
* non-recursively.
|
|
*/
|
|
void extract(in AUTF8String zipEntry, in nsIFile outFile);
|
|
|
|
/**
|
|
* Returns a nsIZipEntry describing a specified zip entry.
|
|
*/
|
|
nsIZipEntry getEntry(in AUTF8String zipEntry);
|
|
|
|
/**
|
|
* Checks whether the zipfile contains an entry specified by entryName.
|
|
*/
|
|
boolean hasEntry(in AUTF8String zipEntry);
|
|
|
|
/**
|
|
* Returns a string enumerator containing the matching entry names.
|
|
*
|
|
* @param aPattern
|
|
* A regular expression used to find matching entries in the zip file.
|
|
* Set this parameter to null (javascript) or EmptyCString() (c++) or "*"
|
|
* to get all entries; otherwise, use the
|
|
* following syntax:
|
|
*
|
|
* o * matches anything
|
|
* o ? matches one character
|
|
* o $ matches the end of the string
|
|
* o [abc] matches one occurrence of a, b, or c. The only character that
|
|
* must be escaped inside the brackets is ]. ^ and - must never
|
|
* appear in the first and second positions within the brackets,
|
|
* respectively. (In the former case, the behavior specified for
|
|
* '[^az]' will happen.)
|
|
* o [a-z] matches any character between a and z. The characters a and z
|
|
* must either both be letters or both be numbers, with the
|
|
* character represented by 'a' having a lower ASCII value than
|
|
* the character represented by 'z'.
|
|
* o [^az] matches any character except a or z. If ] is to appear inside
|
|
* the brackets as a character to not match, it must be escaped.
|
|
* o pat~pat2 returns matches to the pattern 'pat' which do not also match
|
|
* the pattern 'pat2'. This may be used to perform filtering
|
|
* upon the results of one pattern to remove all matches which
|
|
* also match another pattern. For example, because '*'
|
|
* matches any string and '*z*' matches any string containing a
|
|
* 'z', '*~*z*' will match all strings except those containing
|
|
* a 'z'. Note that a pattern may not use '~' multiple times,
|
|
* so a string such as '*~*z*~*y*' is not a valid pattern.
|
|
* o (foo|bar) will match either the pattern foo or the pattern bar.
|
|
* Neither of the patterns foo or bar may use the 'pat~pat2'
|
|
* syntax described immediately above.
|
|
* o \ will escape a special character. Escaping is required for all
|
|
* special characters unless otherwise specified.
|
|
* o All other characters match case-sensitively.
|
|
*
|
|
* An aPattern not conforming to this syntax has undefined behavior.
|
|
*
|
|
* @throws NS_ERROR_ILLEGAL_VALUE on many but not all invalid aPattern
|
|
* values.
|
|
*/
|
|
nsIUTF8StringEnumerator findEntries(in AUTF8String aPattern);
|
|
|
|
/**
|
|
* Returns an input stream containing the contents of the specified zip
|
|
* entry.
|
|
* @param zipEntry the name of the entry to open the stream from
|
|
*/
|
|
nsIInputStream getInputStream(in AUTF8String zipEntry);
|
|
|
|
/**
|
|
* Returns an input stream containing the contents of the specified zip
|
|
* entry. If the entry refers to a directory (ends with '/'), a directory stream
|
|
* is opened, otherwise the contents of the file entry is returned.
|
|
* @param aJarSpec the Spec of the URI for the JAR (only used for directory streams)
|
|
* @param zipEntry the name of the entry to open the stream from
|
|
*/
|
|
nsIInputStream getInputStreamWithSpec(in AUTF8String aJarSpec, in AUTF8String zipEntry);
|
|
|
|
/**
|
|
* Returns an object describing the entity which signed
|
|
* an entry. parseManifest must be called first. If aEntryName is an
|
|
* entry in the jar, getInputStream must be called after parseManifest.
|
|
* If aEntryName is an external file which has meta-information
|
|
* stored in the jar, verifyExternalFile (not yet implemented) must
|
|
* be called before getPrincipal.
|
|
*/
|
|
nsICertificatePrincipal getCertificatePrincipal(in AUTF8String aEntryName);
|
|
|
|
readonly attribute uint32_t manifestEntriesCount;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// nsIZipReaderCache
|
|
|
|
[scriptable, uuid(72fc56e5-3e6e-4d11-8967-26ab96071032)]
|
|
interface nsIZipReaderCache : nsISupports
|
|
{
|
|
/**
|
|
* Initializes a new zip reader cache.
|
|
* @param cacheSize - the number of released entries to maintain before
|
|
* beginning to throw some out (note that the number of outstanding
|
|
* entries can be much greater than this number -- this is the count
|
|
* for those otherwise unused entries)
|
|
*/
|
|
void init(in unsigned long cacheSize);
|
|
|
|
/**
|
|
* Returns a (possibly shared) nsIZipReader for an nsIFile.
|
|
*
|
|
* If the zip reader for given file is not in the cache, a new zip reader
|
|
* is created, initialized, and opened (see nsIZipReader::init and
|
|
* nsIZipReader::open). Otherwise the previously created zip reader is
|
|
* returned.
|
|
*
|
|
* @note If someone called close() on the shared nsIZipReader, this method
|
|
* will return the closed zip reader.
|
|
*/
|
|
nsIZipReader getZip(in nsIFile zipFile);
|
|
|
|
/**
|
|
* Returns a (possibly shared) nsIZipReader for a zip inside another zip
|
|
*
|
|
* See getZip
|
|
*/
|
|
nsIZipReader getInnerZip(in nsIFile zipFile, in AUTF8String zipEntry);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
%{C++
|
|
|
|
#define NS_ZIPREADER_CID \
|
|
{ /* 88e2fd0b-f7f4-480c-9483-7846b00e8dad */ \
|
|
0x88e2fd0b, 0xf7f4, 0x480c, \
|
|
{ 0x94, 0x83, 0x78, 0x46, 0xb0, 0x0e, 0x8d, 0xad } \
|
|
}
|
|
|
|
#define NS_ZIPREADERCACHE_CID \
|
|
{ /* 608b7f6f-4b60-40d6-87ed-d933bf53d8c1 */ \
|
|
0x608b7f6f, 0x4b60, 0x40d6, \
|
|
{ 0x87, 0xed, 0xd9, 0x33, 0xbf, 0x53, 0xd8, 0xc1 } \
|
|
}
|
|
|
|
%}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|