SECStatus
SECU_FileToItem(SECItem *dst, PRFileDesc *src)
{
PRFileInfo info;
PRInt32 numBytes;
PRStatus prStatus;
if (src == PR_STDIN)
return secu_StdinToItem(dst);
prStatus = PR_GetOpenFileInfo(src, &info);
if (prStatus != PR_SUCCESS) {
PORT_SetError(SEC_ERROR_IO);
return SECFailure;
}
/* XXX workaround for 3.1, not all utils zero dst before sending */
dst->data = 0;
if (!SECITEM_AllocItem(NULL, dst, info.size))
goto loser;
numBytes = PR_Read(src, dst->data, info.size);
if (numBytes != info.size) {
PORT_SetError(SEC_ERROR_IO);
goto loser;
}
return SECSuccess;
loser:
SECITEM_FreeItem(dst, PR_FALSE);
dst->data = NULL;
return SECFailure;
}
static SECStatus nss_load_crl(const char* crlfilename)
{
PRFileDesc *infile;
PRFileInfo info;
SECItem filedata = { 0, NULL, 0 };
SECItem crlDER = { 0, NULL, 0 };
char *body;
infile = PR_Open(crlfilename, PR_RDONLY, 0);
if(!infile)
return SECFailure;
if(PR_SUCCESS != PR_GetOpenFileInfo(infile, &info))
goto fail;
if(!SECITEM_AllocItem(NULL, &filedata, info.size + /* zero ended */ 1))
goto fail;
if(info.size != PR_Read(infile, filedata.data, info.size))
goto fail;
/* place a trailing zero right after the visible data */
body = (char*)filedata.data;
body[--filedata.len] = '\0';
body = strstr(body, "-----BEGIN");
if(body) {
/* assume ASCII */
char *trailer;
char *begin = PORT_Strchr(body, '\n');
if(!begin)
begin = PORT_Strchr(body, '\r');
if(!begin)
goto fail;
trailer = strstr(++begin, "-----END");
if(!trailer)
goto fail;
/* retrieve DER from ASCII */
*trailer = '\0';
if(ATOB_ConvertAsciiToItem(&crlDER, begin))
goto fail;
SECITEM_FreeItem(&filedata, PR_FALSE);
}
else
/* assume DER */
crlDER = filedata;
PR_Close(infile);
return nss_cache_crl(&crlDER);
fail:
PR_Close(infile);
SECITEM_FreeItem(&filedata, PR_FALSE);
return SECFailure;
}
static int
xmlSecNssAppReadSECItem(SECItem *contents, const char *fn) {
PRFileInfo info;
PRFileDesc *file = NULL;
PRInt32 numBytes;
PRStatus prStatus;
int ret = -1;
xmlSecAssert2(contents != NULL, -1);
xmlSecAssert2(fn != NULL, -1);
file = PR_Open(fn, PR_RDONLY, 00660);
if (file == NULL) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"PR_Open",
XMLSEC_ERRORS_R_IO_FAILED,
"filename=%s",
xmlSecErrorsSafeString(fn));
goto done;
}
prStatus = PR_GetOpenFileInfo(file, &info);
if (prStatus != PR_SUCCESS) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"PR_GetOpenFileInfo",
XMLSEC_ERRORS_R_IO_FAILED,
"filename=%s",
xmlSecErrorsSafeString(fn));
goto done;
}
contents->data = 0;
if (!SECITEM_AllocItem(NULL, contents, info.size)) {
xmlSecError(XMLSEC_ERRORS_HERE,
NULL,
"SECITEM_AllocItem",
XMLSEC_ERRORS_R_CRYPTO_FAILED,
XMLSEC_ERRORS_NO_MESSAGE);
goto done;
}
numBytes = PR_Read(file, contents->data, info.size);
if (numBytes != info.size) {
SECITEM_FreeItem(contents, PR_FALSE);
goto done;
}
ret = 0;
done:
if (file) {
PR_Close(file);
}
return (ret);
}
int
GetLen(PRFileDesc* fd)
{
PRFileInfo info;
if (PR_SUCCESS != PR_GetOpenFileInfo(fd, &info)) {
return -1;
}
return info.size;
}
/*
* XXX This is a generic function that would probably make a good
* replacement for SECU_DER_Read (which is not at all specific to DER,
* despite its name), but that requires fixing all of the tools...
* Still, it should be done, whenenver I/somebody has the time.
* (Also, consider whether this actually belongs in the security
* library itself, not just in the command library.)
*
* This function takes an open file (a PRFileDesc *) and reads the
* entire file into a SECItem. (Obviously, the file is intended to
* be small enough that such a thing is advisable.) Both the SECItem
* and the buffer it points to are allocated from the heap; the caller
* is expected to free them. ("SECITEM_FreeItem(item, PR_TRUE)")
*/
static SECItem *
read_file_into_item (PRFileDesc *in_file, SECItemType si_type)
{
PRStatus prv;
SECItem *item;
PRFileInfo file_info;
PRInt32 bytes_read;
prv = PR_GetOpenFileInfo (in_file, &file_info);
if (prv != PR_SUCCESS)
return NULL;
if (file_info.size == 0) {
/* XXX Need a better error; just grabbed this one for expediency. */
PORT_SetError (SEC_ERROR_INPUT_LEN);
return NULL;
}
if (file_info.size > 0xffff) { /* I think this is too big. */
PORT_SetError (SEC_ERROR_NO_MEMORY);
return NULL;
}
item = PORT_Alloc (sizeof (SECItem));
if (item == NULL)
return NULL;
item->type = si_type;
item->len = (unsigned int) file_info.size;
item->data = PORT_Alloc ((size_t)item->len);
if (item->data == NULL)
goto loser;
bytes_read = PR_Read (in_file, item->data, (PRInt32) item->len);
if (bytes_read < 0) {
/* Something went wrong; error is already set for us. */
goto loser;
} else if (bytes_read == 0) {
/* Something went wrong; we read nothing. But no system/nspr error. */
/* XXX Need to set an error here. */
goto loser;
} else if (item->len != (unsigned int)bytes_read) {
/* Something went wrong; we read less (or more!?) than we expected. */
/* XXX Need to set an error here. */
goto loser;
}
return item;
loser:
SECITEM_FreeItem (item, PR_TRUE);
return NULL;
}
SECStatus
SECU_TextFileToItem(SECItem *dst, PRFileDesc *src)
{
PRFileInfo info;
PRInt32 numBytes;
PRStatus prStatus;
unsigned char *buf;
if (src == PR_STDIN)
return secu_StdinToItem(dst);
prStatus = PR_GetOpenFileInfo(src, &info);
if (prStatus != PR_SUCCESS) {
PORT_SetError(SEC_ERROR_IO);
return SECFailure;
}
buf = (unsigned char *)PORT_Alloc(info.size);
if (!buf)
return SECFailure;
numBytes = PR_Read(src, buf, info.size);
if (numBytes != info.size) {
PORT_SetError(SEC_ERROR_IO);
goto loser;
}
if (buf[numBytes - 1] == '\n')
numBytes--;
#ifdef _WINDOWS
if (buf[numBytes - 1] == '\r')
numBytes--;
#endif
/* XXX workaround for 3.1, not all utils zero dst before sending */
dst->data = 0;
if (!SECITEM_AllocItem(NULL, dst, numBytes))
goto loser;
memcpy(dst->data, buf, numBytes);
PORT_Free(buf);
return SECSuccess;
loser:
PORT_Free(buf);
return SECFailure;
}
int
readInputFile(const char *filename, SECItem *result)
{
PRFileDesc *file /* = PR_OpenFile(input_file, 0) */;
PRFileInfo info;
PRStatus s;
PRInt32 count;
int retval = -1;
file = PR_Open(filename, PR_RDONLY, 0);
if (!file) {
if (verbose)
PR_fprintf(pr_stderr, "Open of file %s failed\n", filename);
goto loser;
}
s = PR_GetOpenFileInfo(file, &info);
if (s != PR_SUCCESS) {
if (verbose)
PR_fprintf(pr_stderr, "File info operation failed\n");
goto file_loser;
}
result->len = info.size;
result->data = (unsigned char *)PR_Malloc(result->len);
if (!result->data) {
if (verbose)
PR_fprintf(pr_stderr, "Allocation of buffer failed\n");
goto file_loser;
}
count = PR_Read(file, result->data, result->len);
if (count != result->len) {
if (verbose)
PR_fprintf(pr_stderr, "Read failed\n");
goto file_loser;
}
retval = 0;
file_loser:
PR_Close(file);
loser:
return retval;
}
void
beginReadingRDFFile (RDFFile file)
{
char *url;
int method = 0;
#ifndef MOZILLA_CLIENT
/* If standalone, we just use to open the file */
NET_StreamClass stream;
PRFileDesc *fd;
PRFileInfo fi;
PRBool bSuccess = FALSE;
url = file->url;
fd = CallPROpenUsingFileURL(url, PR_RDONLY, 0);
if(fd)
{
if(PR_GetOpenFileInfo(fd, &fi) == PR_SUCCESS)
{
char* buf = malloc(fi.size);
if(PR_Read(fd, buf, fi.size))
{
stream.data_object = file;
if(parseNextRDFXMLBlob (&stream, buf, fi.size))
bSuccess = TRUE;
}
free(buf);
}
PR_Close(fd);
}
if(bSuccess == TRUE)
rdf_complete(&stream);
#else
url = file->url;
if (file->fileType == ES_RT) method = URL_INDEX_METHOD;
rdf_GetURL (gRDFMWContext(file->db), method, NULL, file);
#endif
}
nsresult
nsEmbedChromeRegistry::ReadChromeRegistry()
{
nsresult rv;
nsCOMPtr<nsIProperties> directoryService =
do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsILocalFile> listFile;
rv = directoryService->Get(NS_APP_CHROME_DIR, NS_GET_IID(nsILocalFile),
getter_AddRefs(listFile));
if (NS_FAILED(rv)) return rv;
rv = listFile->AppendRelativeNativePath(NS_LITERAL_CSTRING("installed-chrome.txt"));
if (NS_FAILED(rv)) return rv;
PRFileDesc *file;
rv = listFile->OpenNSPRFileDesc(PR_RDONLY, 0, &file);
if (NS_FAILED(rv)) return rv;
PRFileInfo finfo;
if (PR_GetOpenFileInfo(file, &finfo) == PR_SUCCESS) {
char *dataBuffer = new char[finfo.size+1];
if (dataBuffer) {
PRInt32 bufferSize = PR_Read(file, dataBuffer, finfo.size);
if (bufferSize > 0) {
dataBuffer[bufferSize] = '\r';
rv = ProcessNewChromeBuffer(dataBuffer, bufferSize);
}
delete [] dataBuffer;
}
}
PR_Close(file);
return rv;
}
am_status_t Properties::load(const std::string& fileName)
{
am_status_t status = AM_SUCCESS;
PRFileDesc *propFile;
PRErrorCode pr_errorCode;
propFile = PR_Open(fileName.c_str(), PR_RDONLY, 0);
if (NULL != propFile) {
PRFileInfo fileInfo;
if (PR_GetOpenFileInfo(propFile, &fileInfo) == PR_SUCCESS) {
try {
PRInt32 readCount;
char *buffer = new char[fileInfo.size + 1];
readCount = PR_Read(propFile, buffer, fileInfo.size);
if (readCount == fileInfo.size) {
buffer[readCount] = '\0';
status = parseBuffer(buffer);
} else {
Log::log(Log::ALL_MODULES,
Log::LOG_ERROR,
"am_properties_load(): "
"Could not load properties file %s: "
"Number of bytes read (%d) "
"did not match expected file size (%d).\n",
fileName.c_str(), readCount, fileInfo.size);
status = AM_NSPR_ERROR;
}
delete[] buffer;
} catch (const std::bad_alloc&) {
status = AM_NO_MEMORY;
}
} else {
pr_errorCode = PR_GetError();
Log::log(Log::ALL_MODULES, Log::LOG_ERROR,
"am_properties_load(): "
"Error getting info for properties file %s: %s\n",
fileName.c_str(),
PR_ErrorToString(pr_errorCode, PR_LANGUAGE_I_DEFAULT));
status = AM_NSPR_ERROR;
}
PR_Close(propFile);
} else {
pr_errorCode = PR_GetError();
if (PR_FILE_NOT_FOUND_ERROR == pr_errorCode) {
status = AM_NOT_FOUND;
} else if (PR_NO_ACCESS_RIGHTS_ERROR == pr_errorCode) {
status = AM_ACCESS_DENIED;
} else {
Log::log(Log::ALL_MODULES, Log::LOG_ERROR,
"am_properties_load(): "
"Error opening properties file '%s': %s\n",
fileName.c_str(),
PR_ErrorToString(pr_errorCode, PR_LANGUAGE_I_DEFAULT));
status = AM_NSPR_ERROR;
}
}
return status;
}
static int nss_load_crl(const char* crlfilename, PRBool ascii)
{
PRFileDesc *infile;
PRStatus prstat;
PRFileInfo info;
PRInt32 nb;
int rv;
SECItem crlDER;
CERTSignedCrl *crl=NULL;
PK11SlotInfo *slot=NULL;
infile = PR_Open(crlfilename,PR_RDONLY,0);
if (!infile) {
return 0;
}
crlDER.data = NULL;
prstat = PR_GetOpenFileInfo(infile,&info);
if (prstat!=PR_SUCCESS)
return 0;
if (ascii) {
SECItem filedata;
char *asc,*body;
filedata.data = NULL;
if (!SECITEM_AllocItem(NULL,&filedata,info.size))
return 0;
nb = PR_Read(infile,filedata.data,info.size);
if (nb!=info.size)
return 0;
asc = (char*)filedata.data;
if (!asc)
return 0;
body=strstr(asc,"-----BEGIN");
if (body != NULL) {
char *trailer=NULL;
asc = body;
body = PORT_Strchr(asc,'\n');
if (!body)
body = PORT_Strchr(asc,'\r');
if (body)
trailer = strstr(++body,"-----END");
if (trailer!=NULL)
*trailer='\0';
else
return 0;
}
else {
body = asc;
}
rv = ATOB_ConvertAsciiToItem(&crlDER,body);
PORT_Free(filedata.data);
if (rv)
return 0;
}
else {
if (!SECITEM_AllocItem(NULL,&crlDER,info.size))
return 0;
nb = PR_Read(infile,crlDER.data,info.size);
if (nb!=info.size)
return 0;
}
slot = PK11_GetInternalKeySlot();
crl = PK11_ImportCRL(slot,&crlDER,
NULL,SEC_CRL_TYPE,
NULL,CRL_IMPORT_DEFAULT_OPTIONS,
NULL,(CRL_DECODE_DEFAULT_OPTIONS|
CRL_DECODE_DONT_COPY_DER));
if (slot) PK11_FreeSlot(slot);
if (!crl) return 0;
SEC_DestroyCrl(crl);
return 1;
}
NS_IMETHODIMP
nsNSSCertificateDB::ImportCertsFromFile(nsISupports *aToken,
nsILocalFile *aFile,
PRUint32 aType)
{
NS_ENSURE_ARG(aFile);
switch (aType) {
case nsIX509Cert::CA_CERT:
case nsIX509Cert::EMAIL_CERT:
case nsIX509Cert::SERVER_CERT:
// good
break;
default:
// not supported (yet)
return NS_ERROR_FAILURE;
}
nsresult rv;
PRFileDesc *fd = nsnull;
rv = aFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
if (NS_FAILED(rv))
return rv;
if (!fd)
return NS_ERROR_FAILURE;
PRFileInfo file_info;
if (PR_SUCCESS != PR_GetOpenFileInfo(fd, &file_info))
return NS_ERROR_FAILURE;
unsigned char *buf = new unsigned char[file_info.size];
if (!buf)
return NS_ERROR_OUT_OF_MEMORY;
PRInt32 bytes_obtained = PR_Read(fd, buf, file_info.size);
PR_Close(fd);
if (bytes_obtained != file_info.size)
rv = NS_ERROR_FAILURE;
else {
nsCOMPtr<nsIInterfaceRequestor> cxt = new PipUIContext();
switch (aType) {
case nsIX509Cert::CA_CERT:
rv = ImportCertificates(buf, bytes_obtained, aType, cxt);
break;
case nsIX509Cert::SERVER_CERT:
rv = ImportServerCertificate(buf, bytes_obtained, cxt);
break;
case nsIX509Cert::EMAIL_CERT:
rv = ImportEmailCertificate(buf, bytes_obtained, cxt);
break;
default:
break;
}
}
delete [] buf;
return rv;
}
PR_IMPLEMENT(PRInt32) PR_EmulateSendFile(
PRFileDesc *sd, PRSendFileData *sfd,
PRTransmitFileFlags flags, PRIntervalTime timeout)
{
PRInt32 rv, count = 0;
PRInt32 len, file_bytes, index = 0;
PRFileInfo info;
PRIOVec iov[3];
PRFileMap *mapHandle = NULL;
void *addr = (void*)0; /* initialized to some arbitrary value. Keeps compiler warnings down. */
PRUint32 file_mmap_offset, alignment;
PRInt64 zero64;
PROffset64 file_mmap_offset64;
PRUint32 addr_offset, mmap_len;
/* Get file size */
if (PR_SUCCESS != PR_GetOpenFileInfo(sfd->fd, &info)) {
count = -1;
goto done;
}
if (sfd->file_nbytes &&
(info.size < (sfd->file_offset + sfd->file_nbytes))) {
/*
* there are fewer bytes in file to send than specified
*/
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
count = -1;
goto done;
}
if (sfd->file_nbytes)
file_bytes = sfd->file_nbytes;
else
file_bytes = info.size - sfd->file_offset;
alignment = PR_GetMemMapAlignment();
/* number of initial bytes to skip in mmap'd segment */
addr_offset = sfd->file_offset % alignment;
/* find previous mmap alignment boundary */
file_mmap_offset = sfd->file_offset - addr_offset;
/*
* If the file is large, mmap and send the file in chunks so as
* to not consume too much virtual address space
*/
mmap_len = PR_MIN(file_bytes + addr_offset, SENDFILE_MMAP_CHUNK);
len = mmap_len - addr_offset;
/*
* Map in (part of) file. Take care of zero-length files.
*/
if (len) {
LL_I2L(zero64, 0);
mapHandle = PR_CreateFileMap(sfd->fd, zero64, PR_PROT_READONLY);
if (!mapHandle) {
count = -1;
goto done;
}
LL_I2L(file_mmap_offset64, file_mmap_offset);
addr = PR_MemMap(mapHandle, file_mmap_offset64, mmap_len);
if (!addr) {
count = -1;
goto done;
}
}
/*
* send headers first, followed by the file
*/
if (sfd->hlen) {
iov[index].iov_base = (char *) sfd->header;
iov[index].iov_len = sfd->hlen;
index++;
}
if (len) {
iov[index].iov_base = (char*)addr + addr_offset;
iov[index].iov_len = len;
index++;
}
if ((file_bytes == len) && (sfd->tlen)) {
/*
* all file data is mapped in; send the trailer too
*/
iov[index].iov_base = (char *) sfd->trailer;
iov[index].iov_len = sfd->tlen;
index++;
}
rv = PR_Writev(sd, iov, index, timeout);
if (len)
PR_MemUnmap(addr, mmap_len);
if (rv < 0) {
count = -1;
goto done;
}
PR_ASSERT(rv == sfd->hlen + len + ((len == file_bytes) ? sfd->tlen : 0));
file_bytes -= len;
count += rv;
if (!file_bytes) /* header, file and trailer are sent */
goto done;
/*
* send remaining bytes of the file, if any
*/
len = PR_MIN(file_bytes, SENDFILE_MMAP_CHUNK);
while (len > 0) {
/*
* Map in (part of) file
*/
file_mmap_offset = sfd->file_offset + count - sfd->hlen;
PR_ASSERT((file_mmap_offset % alignment) == 0);
LL_I2L(file_mmap_offset64, file_mmap_offset);
addr = PR_MemMap(mapHandle, file_mmap_offset64, len);
if (!addr) {
count = -1;
goto done;
}
rv = PR_Send(sd, addr, len, 0, timeout);
PR_MemUnmap(addr, len);
if (rv < 0) {
count = -1;
goto done;
}
PR_ASSERT(rv == len);
file_bytes -= rv;
count += rv;
len = PR_MIN(file_bytes, SENDFILE_MMAP_CHUNK);
}
PR_ASSERT(0 == file_bytes);
if (sfd->tlen) {
rv = PR_Send(sd, sfd->trailer, sfd->tlen, 0, timeout);
if (rv >= 0) {
PR_ASSERT(rv == sfd->tlen);
count += rv;
} else
count = -1;
}
done:
if (mapHandle)
PR_CloseFileMap(mapHandle);
if ((count >= 0) && (flags & PR_TRANSMITFILE_CLOSE_SOCKET))
PR_Close(sd);
return count;
}
