NS_IMETHODIMP
nsNoAuthURLParser::ParseFilePath(const char *filepath, PRInt32 filepathLen,
PRUint32 *directoryPos, PRInt32 *directoryLen,
PRUint32 *basenamePos, PRInt32 *basenameLen,
PRUint32 *extensionPos, PRInt32 *extensionLen)
{
NS_PRECONDITION(filepath, "null pointer");
if (filepathLen < 0)
filepathLen = strlen(filepath);
// look for a filepath consisting of only a drive number, which may or
// may not have a leading slash.
if (filepathLen > 1 && filepathLen < 4) {
const char *end = filepath + filepathLen;
const char *p = filepath;
if (*p == '/')
p++;
if ((end-p == 2) && (p[1]==':' || p[1]=='|') && nsCRT::IsAsciiAlpha(*p)) {
// filepath = <drive-number>:
SET_RESULT(directory, 0, filepathLen);
SET_RESULT(basename, 0, -1);
SET_RESULT(extension, 0, -1);
return NS_OK;
}
}
// otherwise fallback on common implementation
return nsBaseURLParser::ParseFilePath(filepath, filepathLen,
directoryPos, directoryLen,
basenamePos, basenameLen,
extensionPos, extensionLen);
}
nsresult
nsBaseURLParser::ParseFileName(const char *filename, PRInt32 filenameLen,
PRUint32 *basenamePos, PRInt32 *basenameLen,
PRUint32 *extensionPos, PRInt32 *extensionLen)
{
NS_PRECONDITION(filename, "null pointer");
if (filenameLen < 0)
filenameLen = strlen(filename);
// no extension if filename ends with a '.'
if (filename[filenameLen-1] != '.') {
// ignore '.' at the beginning
for (const char *p = filename + filenameLen - 1; p > filename; --p) {
if (*p == '.') {
// filename = <basename.extension>
SET_RESULT(basename, 0, p - filename);
SET_RESULT(extension, p + 1 - filename, filenameLen - (p - filename + 1));
return NS_OK;
}
}
}
// filename = <basename>
SET_RESULT(basename, 0, filenameLen);
SET_RESULT(extension, 0, -1);
return NS_OK;
}
void
nsAuthURLParser::ParseAfterScheme(const char *spec, PRInt32 specLen,
PRUint32 *authPos, PRInt32 *authLen,
PRUint32 *pathPos, PRInt32 *pathLen)
{
NS_PRECONDITION(specLen >= 0, "unexpected");
PRUint32 nslash = CountConsecutiveSlashes(spec, specLen);
// search for the end of the authority section
const char *end = spec + specLen;
const char *p;
for (p = spec + nslash; p < end; ++p) {
if (*p == '/' || *p == '?' || *p == '#' || *p == ';')
break;
}
if (p < end) {
// spec = [/]<auth><path>
SET_RESULT(auth, nslash, p - (spec + nslash));
SET_RESULT(path, p - spec, specLen - (p - spec));
}
else {
// spec = [/]<auth>
SET_RESULT(auth, nslash, specLen - nslash);
SET_RESULT(path, 0, -1);
}
}
NS_IMETHODIMP
nsBaseURLParser::ParseUserInfo(const char *userinfo, PRInt32 userinfoLen,
PRUint32 *usernamePos, PRInt32 *usernameLen,
PRUint32 *passwordPos, PRInt32 *passwordLen)
{
SET_RESULT(username, 0, -1);
SET_RESULT(password, 0, -1);
return NS_OK;
}
NS_IMETHODIMP
nsAuthURLParser::ParseAuthority(const char *auth, PRInt32 authLen,
PRUint32 *usernamePos, PRInt32 *usernameLen,
PRUint32 *passwordPos, PRInt32 *passwordLen,
PRUint32 *hostnamePos, PRInt32 *hostnameLen,
PRInt32 *port)
{
nsresult rv;
NS_PRECONDITION(auth, "null pointer");
if (authLen < 0)
authLen = strlen(auth);
if (authLen == 0) {
SET_RESULT(username, 0, -1);
SET_RESULT(password, 0, -1);
SET_RESULT(hostname, 0, 0);
if (port)
*port = -1;
return NS_OK;
}
// search backwards for @
const char *p = auth + authLen - 1;
for (; (*p != '@') && (p > auth); --p);
if ( *p == '@' ) {
// auth = <user-info@server-info>
rv = ParseUserInfo(auth, p - auth,
usernamePos, usernameLen,
passwordPos, passwordLen);
if (NS_FAILED(rv)) return rv;
rv = ParseServerInfo(p + 1, authLen - (p - auth + 1),
hostnamePos, hostnameLen,
port);
if (NS_FAILED(rv)) return rv;
OFFSET_RESULT(hostname, p + 1 - auth);
}
else {
// auth = <server-info>
SET_RESULT(username, 0, -1);
SET_RESULT(password, 0, -1);
rv = ParseServerInfo(auth, authLen,
hostnamePos, hostnameLen,
port);
if (NS_FAILED(rv)) return rv;
}
return NS_OK;
}
NS_IMETHODIMP
nsBaseURLParser::ParseFilePath(const char *filepath, PRInt32 filepathLen,
PRUint32 *directoryPos, PRInt32 *directoryLen,
PRUint32 *basenamePos, PRInt32 *basenameLen,
PRUint32 *extensionPos, PRInt32 *extensionLen)
{
NS_PRECONDITION(filepath, "null pointer");
if (filepathLen < 0)
filepathLen = strlen(filepath);
if (filepathLen == 0) {
SET_RESULT(directory, 0, -1);
SET_RESULT(basename, 0, 0); // assume a zero length file basename
SET_RESULT(extension, 0, -1);
return NS_OK;
}
const char *p;
const char *end = filepath + filepathLen;
// search backwards for filename
for (p = end - 1; *p != '/' && p > filepath; --p)
;
if (*p == '/') {
// catch /.. and /.
if ((p+1 < end && *(p+1) == '.') &&
(p+2 == end || (*(p+2) == '.' && p+3 == end)))
p = end - 1;
// filepath = <directory><filename>.<extension>
SET_RESULT(directory, 0, p - filepath + 1);
ParseFileName(p + 1, end - (p + 1),
basenamePos, basenameLen,
extensionPos, extensionLen);
OFFSET_RESULT(basename, p + 1 - filepath);
OFFSET_RESULT(extension, p + 1 - filepath);
}
else {
// filepath = <filename>.<extension>
SET_RESULT(directory, 0, -1);
ParseFileName(filepath, filepathLen,
basenamePos, basenameLen,
extensionPos, extensionLen);
}
return NS_OK;
}
NS_IMETHODIMP
nsBaseURLParser::ParseServerInfo(const char *serverinfo, PRInt32 serverinfoLen,
PRUint32 *hostnamePos, PRInt32 *hostnameLen,
PRInt32 *port)
{
SET_RESULT(hostname, 0, -1);
if (port)
*port = -1;
return NS_OK;
}
NS_IMETHODIMP
nsBaseURLParser::ParseAuthority(const char *auth, PRInt32 authLen,
PRUint32 *usernamePos, PRInt32 *usernameLen,
PRUint32 *passwordPos, PRInt32 *passwordLen,
PRUint32 *hostnamePos, PRInt32 *hostnameLen,
PRInt32 *port)
{
NS_PRECONDITION(auth, "null pointer");
if (authLen < 0)
authLen = strlen(auth);
SET_RESULT(username, 0, -1);
SET_RESULT(password, 0, -1);
SET_RESULT(hostname, 0, authLen);
if (port)
*port = -1;
return NS_OK;
}
NS_IMETHODIMP
nsAuthURLParser::ParseUserInfo(const char *userinfo, PRInt32 userinfoLen,
PRUint32 *usernamePos, PRInt32 *usernameLen,
PRUint32 *passwordPos, PRInt32 *passwordLen)
{
NS_PRECONDITION(userinfo, "null pointer");
if (userinfoLen < 0)
userinfoLen = strlen(userinfo);
if (userinfoLen == 0) {
SET_RESULT(username, 0, -1);
SET_RESULT(password, 0, -1);
return NS_OK;
}
const char *p = (const char *) memchr(userinfo, ':', userinfoLen);
if (p) {
// userinfo = <username:password>
if (p == userinfo) {
// must have a username!
return NS_ERROR_MALFORMED_URI;
}
SET_RESULT(username, 0, p - userinfo);
SET_RESULT(password, p - userinfo + 1, userinfoLen - (p - userinfo + 1));
}
else {
// userinfo = <username>
SET_RESULT(username, 0, userinfoLen);
SET_RESULT(password, 0, -1);
}
return NS_OK;
}
void
nsStdURLParser::ParseAfterScheme(const char *spec, PRInt32 specLen,
PRUint32 *authPos, PRInt32 *authLen,
PRUint32 *pathPos, PRInt32 *pathLen)
{
NS_PRECONDITION(specLen >= 0, "unexpected");
PRUint32 nslash = CountConsecutiveSlashes(spec, specLen);
// search for the end of the authority section
const char *end = spec + specLen;
const char *p;
for (p = spec + nslash; p < end; ++p) {
if (strchr("/?#;", *p))
break;
}
switch (nslash) {
case 0:
case 2:
if (p < end) {
// spec = (//)<auth><path>
SET_RESULT(auth, nslash, p - (spec + nslash));
SET_RESULT(path, p - spec, specLen - (p - spec));
}
else {
// spec = (//)<auth>
SET_RESULT(auth, nslash, specLen - nslash);
SET_RESULT(path, 0, -1);
}
break;
case 1:
// spec = /<path>
SET_RESULT(auth, 0, -1);
SET_RESULT(path, 0, specLen);
break;
default:
// spec = ///[/]<path>
SET_RESULT(auth, 2, 0);
SET_RESULT(path, 2, specLen - 2);
}
}
void
nsNoAuthURLParser::ParseAfterScheme(const char *spec, PRInt32 specLen,
PRUint32 *authPos, PRInt32 *authLen,
PRUint32 *pathPos, PRInt32 *pathLen)
{
NS_PRECONDITION(specLen >= 0, "unexpected");
// everything is the path
PRUint32 pos = 0;
switch (CountConsecutiveSlashes(spec, specLen)) {
case 0:
case 1:
break;
case 2:
{
const char *p = nsnull;
if (specLen > 2) {
// looks like there is an authority section
#if defined(XP_WIN) || defined(XP_OS2)
// if the authority looks like a drive number then we
// really want to treat it as part of the path
if ((specLen > 3) && (spec[3] == ':' || spec[3] == '|') &&
nsCRT::IsAsciiAlpha(spec[2]) &&
((specLen == 4) || (spec[4] == '/') || (spec[4] == '\\'))) {
pos = 1;
break;
}
#endif
p = (const char *) memchr(spec + 2, '/', specLen - 2);
}
if (p) {
SET_RESULT(auth, 0, -1);
SET_RESULT(path, p - spec, specLen - (p - spec));
}
else {
SET_RESULT(auth, 0, -1);
SET_RESULT(path, 0, -1);
}
return;
}
default:
pos = 2;
break;
}
SET_RESULT(auth, pos, 0);
SET_RESULT(path, pos, specLen - pos);
}
uint32 fifo32Read (fifo32 * buf, uint8 * result) {
uint32 val;
VERIFY_OBJECT (buf, OBJID_FIFO)
CLEAR_RESULT;
if (buf->nItems == 0) {
SET_RESULT (RSLT_BUFFER_EMPTY);
return ERROR;
}
val = * buf->rd_ptr;
buf->rd_ptr++;
ATOMIC(buf->nItems--);
if (buf->rd_ptr == buf->end)
buf->rd_ptr = buf->start;
return val;
}
uint16 fifo16Read (fifo16 * buf, uint8 * result) {
uint32 val;
VERIFY_OBJECT (buf, OBJID_FIFO)
CLEAR_RESULT;
if (buf->nItems == 0) {
SET_RESULT (RSLT_BUFFER_EMPTY);
return ERROR;
}
val = * buf->rd_ptr;
buf->rd_ptr++;
ATOMIC(buf->nItems--);
if (buf->rd_ptr == buf->end)
buf->rd_ptr = buf->start;
// _rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE;
return val;
}
SEXP getfmts(SEXP format)
{
int cnt, v, nfmt;
char fmt[MAXLINE+1], bit[MAXLINE+1];
const char *formatString;
size_t n, cur, chunk, maxlen = 0;
int nthis, nstar;
Rboolean use_UTF8;
SEXP res = PROTECT(allocVector(STRSXP, MAXNARGS));
#define SET_RESULT(n, s) { \
if (n >= MAXNARGS) error(_("only %d arguments are allowed"), MAXNARGS); \
maxlen = (n) < maxlen ? maxlen : (n) + 1; \
SET_STRING_ELT(res, (n), mkChar(s)); \
}
if (!isString(format)) error(_("'fmt' is not a character vector"));
nfmt = LENGTH(format);
if (nfmt != 1)
error(_("'fmt' must be length 1"));
use_UTF8 = getCharCE(STRING_ELT(format, 0)) == CE_UTF8;
formatString = TRANSLATE_CHAR(format, 0);
n = strlen(formatString);
if (n > MAXLINE)
error(_("'fmt' length exceeds maximal format length %d"), MAXLINE);
/* process the format string */
for (cur = 0, cnt = 0; cur < n; cur += chunk) {
const char *curFormat = formatString + cur;
char *starc;
if (formatString[cur] == '%') { /* handle special format command */
if (cur < n - 1 && formatString[cur + 1] == '%') {
/* take care of %% in the format */
chunk = 2;
strcpy(bit, "%");
}
else {
/* recognise selected types from Table B-1 of K&R */
/* NB: we deal with "%%" in branch above. */
/* This is MBCS-OK, as we are in a format spec */
/* Include formats c, u, p and n as well as the R formats; this needs to match */
/* C code as well */
chunk = strcspn(curFormat + 1, "diosfeEgGxXaAcupn") + 2;
if (cur + chunk > n)
error(_("unrecognised format specification '%s'"), curFormat);
strncpy(fmt, curFormat, chunk);
fmt[chunk] = '\0';
nthis = -1;
/* now look for %n$ or %nn$ form */
if (strlen(fmt) > 3 && fmt[1] >= '1' && fmt[1] <= '9') {
v = fmt[1] - '0';
if(fmt[2] == '$') {
nthis = v-1;
memmove(fmt+1, fmt+3, strlen(fmt)-2);
} else if(fmt[2] >= '0' && fmt[2] <= '9' && fmt[3] == '$') {
v = 10*v + fmt[2] - '0';
nthis = v-1;
memmove(fmt+1, fmt+4, strlen(fmt)-3);
}
}
starc = Rf_strchr(fmt, '*');
if (starc) { /* handle * format if present */
nstar = -1;
if (strlen(starc) > 3 && starc[1] >= '1' && starc[1] <= '9') {
v = starc[1] - '0';
if(starc[2] == '$') {
nstar = v-1;
memmove(starc+1, starc+3, strlen(starc)-2);
} else if(starc[2] >= '0' && starc[2] <= '9'
&& starc[3] == '$') {
v = 10*v + starc[2] - '0';
nstar = v-1;
memmove(starc+1, starc+4, strlen(starc)-3);
}
}
if(nstar < 0) {
nstar = cnt++;
}
if (Rf_strchr(starc+1, '*'))
error(_("at most one asterisk '*' is supported in each conversion specification"));
SET_RESULT(nstar, "*");
}
if (fmt[strlen(fmt) - 1] == '%') {
} else {
if(nthis < 0) {
nthis = cnt++;
}
SET_RESULT(nthis, fmt);
}
}
}
else { /* not '%' : handle string part */
char *ch = Rf_strchr(curFormat, '%'); /* MBCS-aware version used */
chunk = (ch) ? (size_t) (ch - curFormat) : strlen(curFormat);
strncpy(bit, curFormat, chunk);
bit[chunk] = '\0';
}
} /* end for ( each chunk ) */
res = xlengthgets(res, maxlen);
UNPROTECT(1);
return res;
}
Bitu XMS_Handler(void) {
// LOG(LOG_MISC,LOG_ERROR)("XMS: CALL %02X",reg_ah);
switch (reg_ah) {
case XMS_GET_VERSION: /* 00 */
reg_ax=XMS_VERSION;
reg_bx=XMS_DRIVER_VERSION;
reg_dx=0; /* No we don't have HMA */
break;
case XMS_ALLOCATE_HIGH_MEMORY: /* 01 */
reg_ax=0;
reg_bl=HIGH_MEMORY_NOT_EXIST;
break;
case XMS_FREE_HIGH_MEMORY: /* 02 */
reg_ax=0;
reg_bl=HIGH_MEMORY_NOT_EXIST;
break;
case XMS_GLOBAL_ENABLE_A20: /* 03 */
case XMS_LOCAL_ENABLE_A20: /* 05 */
SET_RESULT(XMS_EnableA20(true));
break;
case XMS_GLOBAL_DISABLE_A20: /* 04 */
case XMS_LOCAL_DISABLE_A20: /* 06 */
SET_RESULT(XMS_EnableA20(false));
break;
case XMS_QUERY_A20: /* 07 */
reg_ax = XMS_GetEnabledA20();
reg_bl = 0;
break;
case XMS_QUERY_FREE_EXTENDED_MEMORY: /* 08 */
reg_bl = XMS_QueryFreeMemory(reg_ax,reg_dx);
break;
case XMS_ALLOCATE_ANY_MEMORY: /* 89 */
reg_edx &= 0xffff;
// fall through
case XMS_ALLOCATE_EXTENDED_MEMORY: /* 09 */
{
Bit16u handle = 0;
SET_RESULT(XMS_AllocateMemory(reg_dx,handle));
reg_dx = handle;
}; break;
case XMS_FREE_EXTENDED_MEMORY: /* 0a */
SET_RESULT(XMS_FreeMemory(reg_dx));
break;
case XMS_MOVE_EXTENDED_MEMORY_BLOCK: /* 0b */
SET_RESULT(XMS_MoveMemory(SegPhys(ds)+reg_si),false);
break;
case XMS_LOCK_EXTENDED_MEMORY_BLOCK: { /* 0c */
Bit32u address;
Bitu res = XMS_LockMemory(reg_dx, address);
if(res) reg_bl = (Bit8u)res;
reg_ax = (res==0);
if (res==0) { // success
reg_bx=(Bit16u)(address & 0xFFFF);
reg_dx=(Bit16u)(address >> 16);
};
}; break;
case XMS_UNLOCK_EXTENDED_MEMORY_BLOCK: /* 0d */
SET_RESULT(XMS_UnlockMemory(reg_dx));
break;
case XMS_GET_EMB_HANDLE_INFORMATION: /* 0e */
SET_RESULT(XMS_GetHandleInformation(reg_dx,reg_bh,reg_bl,reg_dx),false);
break;
case XMS_RESIZE_ANY_EXTENDED_MEMORY_BLOCK: /* 0x8f */
if(reg_ebx > reg_bx) LOG_MSG("64MB memory limit!");
//fall through
case XMS_RESIZE_EXTENDED_MEMORY_BLOCK: /* 0f */
SET_RESULT(XMS_ResizeMemory(reg_dx, reg_bx));
break;
case XMS_ALLOCATE_UMB: { /* 10 */
if (!umb_available) {
reg_ax=0;
reg_bl=XMS_FUNCTION_NOT_IMPLEMENTED;
break;
}
Bit16u umb_start=dos_infoblock.GetStartOfUMBChain();
if (umb_start==0xffff) {
reg_ax=0;
reg_bl=UMB_NO_BLOCKS_AVAILABLE;
reg_dx=0; // no upper memory available
break;
}
/* Save status and linkage of upper UMB chain and link upper
memory to the regular MCB chain */
Bit8u umb_flag=dos_infoblock.GetUMBChainState();
if ((umb_flag&1)==0) DOS_LinkUMBsToMemChain(1);
Bit8u old_memstrat=DOS_GetMemAllocStrategy()&0xff;
DOS_SetMemAllocStrategy(0x40); // search in UMBs only
Bit16u size=reg_dx;Bit16u seg;
if (DOS_AllocateMemory(&seg,&size)) {
reg_ax=1;
reg_bx=seg;
} else {
reg_ax=0;
if (size==0) reg_bl=UMB_NO_BLOCKS_AVAILABLE;
else reg_bl=UMB_ONLY_SMALLER_BLOCK;
reg_dx=size; // size of largest available UMB
}
/* Restore status and linkage of upper UMB chain */
Bit8u current_umb_flag=dos_infoblock.GetUMBChainState();
if ((current_umb_flag&1)!=(umb_flag&1)) DOS_LinkUMBsToMemChain(umb_flag);
DOS_SetMemAllocStrategy(old_memstrat);
}
break;
case XMS_DEALLOCATE_UMB: /* 11 */
if (!umb_available) {
reg_ax=0;
reg_bl=XMS_FUNCTION_NOT_IMPLEMENTED;
break;
}
if (dos_infoblock.GetStartOfUMBChain()!=0xffff) {
if (DOS_FreeMemory(reg_dx)) {
reg_ax=0x0001;
break;
}
}
reg_ax=0x0000;
reg_bl=UMB_NO_BLOCKS_AVAILABLE;
break;
case XMS_QUERY_ANY_FREE_MEMORY: /* 88 */
reg_bl = XMS_QueryFreeMemory(reg_ax,reg_dx);
reg_eax &= 0xffff;
reg_edx &= 0xffff;
reg_ecx = (MEM_TotalPages()*MEM_PAGESIZE)-1; // highest known physical memory address
break;
case XMS_GET_EMB_HANDLE_INFORMATION_EXT: { /* 8e */
Bit8u free_handles;
Bitu result = XMS_GetHandleInformation(reg_dx,reg_bh,free_handles,reg_dx);
if (result != 0) reg_bl = result;
else {
reg_edx &= 0xffff;
reg_cx = free_handles;
}
reg_ax = (result==0);
} break;
default:
LOG(LOG_MISC,LOG_ERROR)("XMS: unknown function %02X",reg_ah);
reg_ax=0;
reg_bl=XMS_FUNCTION_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsBaseURLParser::ParseURL(const char *spec, PRInt32 specLen,
PRUint32 *schemePos, PRInt32 *schemeLen,
PRUint32 *authorityPos, PRInt32 *authorityLen,
PRUint32 *pathPos, PRInt32 *pathLen)
{
NS_PRECONDITION(spec, "null pointer");
if (specLen < 0)
specLen = strlen(spec);
const char *stop = nsnull;
const char *colon = nsnull;
const char *slash = nsnull;
const char *p;
PRUint32 offset = 0;
PRInt32 len = specLen;
for (p = spec; len && *p && !colon && !slash; ++p, --len) {
// skip leading whitespace
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') {
spec++;
specLen--;
offset++;
continue;
}
switch (*p) {
case ':':
if (!colon)
colon = p;
break;
case '/': // start of filepath
case '?': // start of query
case '#': // start of ref
case ';': // start of param
if (!slash)
slash = p;
break;
case '@': // username@hostname
case '[': // start of IPv6 address literal
if (!stop)
stop = p;
break;
}
}
// disregard the first colon if it follows an '@' or a '['
if (colon && stop && colon > stop)
colon = nsnull;
// if the spec only contained whitespace ...
if (specLen == 0) {
SET_RESULT(scheme, 0, -1);
SET_RESULT(authority, 0, 0);
SET_RESULT(path, 0, 0);
return NS_OK;
}
// ignore trailing whitespace and control characters
for (p = spec + specLen - 1; ((unsigned char) *p <= ' ') && (p != spec); --p)
;
specLen = p - spec + 1;
if (colon && (colon < slash || !slash)) {
//
// spec = <scheme>:/<the-rest>
//
// or
//
// spec = <scheme>:<authority>
// spec = <scheme>:<path-no-slashes>
//
if (!net_IsValidScheme(spec, colon - spec) || (*(colon+1) == ':')) {
NS_WARNING("malformed uri");
return NS_ERROR_MALFORMED_URI;
}
SET_RESULT(scheme, offset, colon - spec);
if (authorityLen || pathLen) {
PRUint32 schemeLen = colon + 1 - spec;
offset += schemeLen;
ParseAfterScheme(colon + 1, specLen - schemeLen,
authorityPos, authorityLen,
pathPos, pathLen);
OFFSET_RESULT(authority, offset);
OFFSET_RESULT(path, offset);
}
}
else {
//
// spec = <authority-no-port-or-password>/<path>
// spec = <path>
//
// or
//
// spec = <authority-no-port-or-password>/<path-with-colon>
// spec = <path-with-colon>
//
// or
//
// spec = <authority-no-port-or-password>
// spec = <path-no-slashes-or-colon>
//
SET_RESULT(scheme, 0, -1);
if (authorityLen || pathLen)
ParseAfterScheme(spec, specLen,
authorityPos, authorityLen,
pathPos, pathLen);
OFFSET_RESULT(authority, offset);
OFFSET_RESULT(path, offset);
}
return NS_OK;
}
NS_IMETHODIMP
nsBaseURLParser::ParsePath(const char *path, PRInt32 pathLen,
PRUint32 *filepathPos, PRInt32 *filepathLen,
PRUint32 *paramPos, PRInt32 *paramLen,
PRUint32 *queryPos, PRInt32 *queryLen,
PRUint32 *refPos, PRInt32 *refLen)
{
NS_PRECONDITION(path, "null pointer");
if (pathLen < 0)
pathLen = strlen(path);
// path = [/]<segment1>/<segment2>/<...>/<segmentN>;<param>?<query>#<ref>
// XXX PL_strnpbrk would be nice, but it's buggy
// search for first occurance of either ? or #
const char *query_beg = 0, *query_end = 0;
const char *ref_beg = 0;
const char *p = 0;
for (p = path; *p; ++p) {
// only match the query string if it precedes the reference fragment
if (!ref_beg && !query_beg && *p == '?')
query_beg = p + 1;
else if (*p == '#') {
ref_beg = p + 1;
if (query_beg)
query_end = p;
break;
}
}
if (query_beg) {
if (query_end)
SET_RESULT(query, query_beg - path, query_end - query_beg);
else
SET_RESULT(query, query_beg - path, pathLen - (query_beg - path));
}
else
SET_RESULT(query, 0, -1);
if (ref_beg)
SET_RESULT(ref, ref_beg - path, pathLen - (ref_beg - path));
else
SET_RESULT(ref, 0, -1);
// search backwards for param
const char *param_beg = 0;
const char *end;
if (query_beg)
end = query_beg - 1;
else if (ref_beg)
end = ref_beg - 1;
else
end = path + pathLen;
for (p = end - 1; p >= path && *p != '/'; --p) {
if (*p == ';') {
// found param
param_beg = p + 1;
}
}
if (param_beg) {
// found <filepath>;<param>
SET_RESULT(param, param_beg - path, end - param_beg);
end = param_beg - 1;
}
else
SET_RESULT(param, 0, -1);
// an empty file path is no file path
if (end != path)
SET_RESULT(filepath, 0, end - path);
else
SET_RESULT(filepath, 0, -1);
return NS_OK;
}
NS_IMETHODIMP
nsAuthURLParser::ParseServerInfo(const char *serverinfo, PRInt32 serverinfoLen,
PRUint32 *hostnamePos, PRInt32 *hostnameLen,
PRInt32 *port)
{
NS_PRECONDITION(serverinfo, "null pointer");
if (serverinfoLen < 0)
serverinfoLen = strlen(serverinfo);
if (serverinfoLen == 0) {
SET_RESULT(hostname, 0, 0);
if (port)
*port = -1;
return NS_OK;
}
// search backwards for a ':' but stop on ']' (IPv6 address literal
// delimiter). check for illegal characters in the hostname.
const char *p = serverinfo + serverinfoLen - 1;
const char *colon = nsnull, *bracket = nsnull;
for (; p > serverinfo; --p) {
switch (*p) {
case ']':
bracket = p;
break;
case ':':
if (bracket == nsnull)
colon = p;
break;
case ' ':
// hostname must not contain a space
NS_WARNING("malformed hostname");
return NS_ERROR_MALFORMED_URI;
}
}
if (colon) {
// serverinfo = <hostname:port>
SET_RESULT(hostname, 0, colon - serverinfo);
if (port) {
// XXX unfortunately ToInteger is not defined for substrings
nsCAutoString buf(colon+1, serverinfoLen - (colon + 1 - serverinfo));
if (buf.Length() == 0) {
*port = -1;
}
else {
PRInt32 err;
*port = buf.ToInteger(&err);
if (NS_FAILED(err))
return NS_ERROR_MALFORMED_URI;
}
}
}
else {
// serverinfo = <hostname>
SET_RESULT(hostname, 0, serverinfoLen);
if (port)
*port = -1;
}
return NS_OK;
}
