BBOOL rtplatform_gfirst(PSMBDSTAT dirobj, char RTSMB_FAR * name_in)
{
char slashstar [] = {'\\', '*', '\0'};
char dotstar [] = {'.', '*', '\0'};
char name [SMBF_FILENAMESIZE + 1];
rtsmb_size len;
int rv;
void * rtp_dirobj;
/* translate "*" to "*.*" becaues some file systems don't like "*" */
len = (rtsmb_size) tc_strlen (name_in);
tc_strcpy (name, name_in);
if (len > 1 && len < SMBF_FILENAMESIZE - 2 && tc_strcmp (&name[len - 2], slashstar) == 0)
{
tc_strcat (name, dotstar);
}
rv = rtp_file_gfirst(&rtp_dirobj, name);
if (rv < 0)
{
dirobj->rtp_dirobj = (void*)0;
return FALSE;
}
rtp_file_get_name(rtp_dirobj, dirobj->filename, SMBF_FILENAMESIZE);
dirobj->filename[SMBF_FILENAMESIZE] = '\0';
/*translate rtplatform dstat to smb dstat */
rtplatform_translate_dstat (dirobj, rtp_dirobj);
dirobj->unicode = 0;
return TRUE;
}
int _wcache_get_filename(char *fileName, struct wcache_ctx *cc, struct wcache_entry *entry)
{
char *name;
tc_strcpy(fileName, cc->cachePrefix);
name = &fileName[tc_strlen(fileName)];
tc_itoa(entry->fileIndex, name, 16);
tc_strcat(fileName, ".dat");
return (0);
}
enum WebcCharset webc_charset_lookup_8(const char *str)
{
int i;
for (i=0; i<ENC_NAME_TABLE_SIZE; i++)
{
if (!tc_strnicmp(str, EncNameTable[i].name, tc_strlen(EncNameTable[i].name)))
{
return (EncNameTable[i].encoding);
}
}
return (WEBC_CHARSET_UNKNOWN); // tbd - maybe this should default to UTF8 instead?
}
WEBC_CHAR * webc_c_stristr (const WEBC_CHAR *str, const char *subStr)
{
long len = tc_strlen(subStr);
while (*str)
{
if (!webc_c_strnicmp(str,subStr,len))
{
return ((WEBC_CHAR *) str);
}
str++;
}
return (0);
}
/*---------------------------------------------------------------------------*/
HTTPAuthenticationRealm * _HTTP_GetAuthenticationRealmByPath (
HTTPAuthContext* ctx,
const HTTP_CHAR* hostName,
HTTP_UINT16 port,
const HTTP_CHAR* path
)
{
HTTPAuthenticationRealm * realm = 0;
HTTPAuthenticationHost * host = _HTTP_GetAuthenticationHost(ctx, hostName, port);
HTTP_INT32 pathLen, realmPathLen;
if (host)
{
pathLen = tc_strlen(path);
realm = (HTTPAuthenticationRealm*) host->realmList.next;
while (realm != (HTTPAuthenticationRealm*) &host->realmList)
{
realmPathLen = tc_strlen(realm->path);
if (realmPathLen > 0 && realmPathLen <= pathLen)
{
if (!tc_strncmp(realm->path, path, realmPathLen))
{
break;
}
}
realm = (HTTPAuthenticationRealm*) realm->node.next;
}
if (realm == (HTTPAuthenticationRealm*) &host->realmList)
{
realm = 0;
}
}
return (realm);
}
char * webc_ip_to_str(char * ipstr, unsigned char * ipaddr)
{
int n;
ipstr[0] = '\0';
for (n=0; n<4; n++)
{
tc_itoa(ipaddr[n], &(ipstr[tc_strlen(ipstr)]), 10);
if (n<3)
{
tc_strcat(ipstr, ".");
}
}
return (ipstr);
}
char *webc_malloc_string_copy_8(const char *str, const char *file, unsigned int line)
{
char *newstr;
if (!str)
{
return 0;
}
newstr = (char *) WEBC_DEBUG_MALLOC(sizeof(char) * (tc_strlen(str) + 1), (char*) file, line,"webc_malloc_string_copy_8",0);
if (newstr)
{
tc_strcpy(newstr,str);
}
return (newstr);
}
char *webc_CreateVFile (const char *pName, int iMimeType, long lSize, WEBC_PFBYTE pData, WEBC_UINT16 wFlags, VFileDeleteFn Destructor)
{
#if (WEBC_SUPPORT_INTERNAL)
int n;
char unique_name[20];
if (!pName)
{
tc_strcpy(unique_name, "\xffvfile");
tc_itoa(_nextUniqueNum, &unique_name[tc_strlen(unique_name)], 10);
pName = unique_name;
_nextUniqueNum++;
}
for (n=0; n<NUM_VFILE_ENTRIES; n++)
{
if (!gWebcVFileTable[n].pName)
{
gWebcVFileTable[n].pName = webc_malloc_string_copy_8(pName, __FILE__, __LINE__);
gWebcVFileTable[n].iMimeType = (WebcFileContentType) iMimeType;
gWebcVFileTable[n].lSize = lSize;
if (wFlags & WEBC_VFILE_COPY)
{
gWebcVFileTable[n].pData = (WEBC_PFBYTE) WEBC_MALLOC(lSize);
if (!gWebcVFileTable[n].pData)
{
gWebcVFileTable[n].lSize = 0;
}
else
{
tc_movebytes(gWebcVFileTable[n].pData, pData, lSize);
}
}
else
{
gWebcVFileTable[n].pData = pData;
}
gWebcVFileTable[n].wFlags = wFlags | WEBC_VFILE_CREATED;
gWebcVFileTable[n].Destroy = Destructor;
return (gWebcVFileTable[n].pName);
}
}
#endif
return 0;
}
/*---------------------------------------------------------------------------*/
HTTP_INT32 _HTTP_RealmPrintAuthorization (
HTTPAuthenticationRealm *realm,
const HTTP_CHAR* method,
const HTTP_CHAR* path,
HTTP_INT32 (*writeFn) (
void* requestStream,
const HTTP_CHAR* data,
HTTP_INT32 len
),
void* requestStream
)
{
switch (realm->scheme)
{
case HTTP_AUTHENTICATION_BASIC:
if (realm->userName[0])
{
HTTP_INT32 len = 0;
char auth[HTTP_CFG_MAX_USERNAME_LEN + HTTP_CFG_MAX_PASSWORD_LEN];
char encoded[((HTTP_CFG_MAX_USERNAME_LEN + HTTP_CFG_MAX_PASSWORD_LEN) * 4 + 2) /3];
len = sizeof(HTTP_CLIENT_BASIC_STR) / sizeof(HTTP_CHAR) - sizeof(HTTP_CHAR);
writeFn(requestStream, HTTP_CLIENT_BASIC_STR, len);
writeFn(requestStream, " ", 1);
tc_strcpy(auth, realm->userName);
tc_strcat(auth, ":");
tc_strcat(auth, realm->password);
len = _HTTP_Base64Encode(encoded, (HTTP_UINT8*) auth, (HTTP_INT32) tc_strlen(auth));
writeFn(requestStream, encoded, len);
return (len);
}
break;
case HTTP_AUTHENTICATION_DIGEST:
if (realm->userName[0])
{
HTTP_INT32 len = 0;
HTTP_MD5_CTX md5Ctx;
HTTP_CHAR hashA1[32];
HTTP_CHAR hashA2[32];
HTTP_CHAR finalHash[33];
/* according to RFC 2617,
credentials = "Digest" digest-response
where
digest-response = "username=\"" + <user-name> +
"\", realm=\"" + <realm-name> +
"\", nonce=\"" + <server-nonce> +
"\", uri=\"" + <path> +
"\", response=\"" +
(qop == auth || qop == auth-int)?
KD(H(A1), <nonce> + ":" + <nonce-count> + ":" + <cnonce> + ":" + <qop> + ":" + H(A2)) :
KD(H(A1), <nonce> + ":" + H(A2))
A1 = <user-name> + ":" + <realm-name> + ":" + <password>
A2 = <method (GET,POST,etc)> + ":" + <path>
H(X) = MD5(X), as a 32-character HEX string
KD(I,J) = H(I + ":" + J);
*/
len = 17 /*Digest username="******", realm="*/ +
tc_strlen(realm->realmName) + 10 /*", nonce="*/ +
tc_strlen(realm->param.digest.serverNonce) + 8 /*", uri="*/ +
tc_strlen(path) + 13 /*", response="*/ + 32 /* MD5 hash */ + 1;
writeFn(requestStream, "Digest username=\"", 17);
writeFn(requestStream, realm->userName, tc_strlen(realm->userName));
writeFn(requestStream, "\", realm=\"", 10);
writeFn(requestStream, realm->realmName, tc_strlen(realm->realmName));
writeFn(requestStream, "\", nonce=\"", 10);
writeFn(requestStream, realm->param.digest.serverNonce, tc_strlen(realm->param.digest.serverNonce));
writeFn(requestStream, "\", uri=\"", 8);
writeFn(requestStream, path, tc_strlen(path));
writeFn(requestStream, "\", response=\"", 13);
/*-----------------------------------------------------*/
/* find H(A1) */
/* if (algorithm == MD5) */
HTTP_MD5_Init(&md5Ctx);
HTTP_MD5_Update(&md5Ctx, realm->userName, tc_strlen(realm->userName)); /* TBD!!! - what if HTTP_CHAR is not ASCII 8bit ? */
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, realm->realmName, tc_strlen(realm->realmName));
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, realm->password, tc_strlen(realm->password));
HTTP_MD5_Final(&md5Ctx);
if (realm->param.digest.hashAlgorithm == HTTP_ALGORITHM_MD5_SESS)
{
HTTP_UINT8 HA1[16];
tc_memcpy(HA1, md5Ctx.digest, 16);
HTTP_MD5_Init(&md5Ctx);
HTTP_MD5_Update(&md5Ctx, HA1, 16);
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, realm->param.digest.serverNonce, tc_strlen(realm->param.digest.serverNonce));
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, realm->param.digest.clientNonce, tc_strlen(realm->param.digest.clientNonce));
HTTP_MD5_Final(&md5Ctx);
}
_HTTP_HashToHex(hashA1, md5Ctx.digest, 16);
/*-----------------------------------------------------*/
/* find H(A2) */
/* if (QOP == auth || QOP == none) */
HTTP_MD5_Init(&md5Ctx);
HTTP_MD5_Update(&md5Ctx, method, tc_strlen(method));
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, path, tc_strlen(path));
if (realm->param.digest.qop == HTTP_QOP_AUTH_INT)
{
HTTP_MD5_Update(&md5Ctx, ":", 1);
/* What is HEntity!?!? */
/*HTTP_MD5_Update(&md5Ctx, HEntity, HASHHEXLEN);*/
}
HTTP_MD5_Final(&md5Ctx);
_HTTP_HashToHex(hashA2, md5Ctx.digest, 16);
HTTP_MD5_Init(&md5Ctx);
HTTP_MD5_Update(&md5Ctx, hashA1, 32);
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, realm->param.digest.serverNonce, tc_strlen(realm->param.digest.serverNonce));
HTTP_MD5_Update(&md5Ctx, ":", 1);
if (realm->param.digest.qop == HTTP_QOP_AUTH ||
realm->param.digest.qop == HTTP_QOP_AUTH_INT)
{
HTTP_CHAR nonceCountStr[8];
_HTTP_UINT32ToHex(nonceCountStr, realm->param.digest.nonceCount);
HTTP_MD5_Update(&md5Ctx, nonceCountStr, 8);
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, realm->param.digest.clientNonce, tc_strlen(realm->param.digest.clientNonce));
HTTP_MD5_Update(&md5Ctx, ":", 1);
HTTP_MD5_Update(&md5Ctx, httpAuthQoPNames[realm->param.digest.qop], tc_strlen(httpAuthQoPNames[realm->param.digest.qop]));
HTTP_MD5_Update(&md5Ctx, ":", 1);
}
HTTP_MD5_Update(&md5Ctx, hashA2, 32);
HTTP_MD5_Final(&md5Ctx);
_HTTP_HashToHex(finalHash, md5Ctx.digest, 16);
finalHash[32] = '\"';
writeFn(requestStream, finalHash, 33);
return (len);
}
break;
default:
break;
}
return (0);
}
long webc_escape_string(WEBC_CHAR * escstr, const char * str)
{
long pos, epos, i;
char * rep;
for (pos = 0, epos= 0; str[pos]; pos++)
{
switch (str[pos])
{
case '\"':
rep = """;
break;
case '&':
rep = "&";
break;
case '<':
rep = "<";
break;
case '>':
rep = ">";
break;
case (char) HTML_NBSP_CHAR:
rep = " ";
break;
case '\n':
rep = "<br>";
break;
default:
rep = 0;
break;
}
if (rep)
{
if (escstr)
{
for (i=0; rep[i]; i++)
{
escstr[epos++] = (WEBC_CHAR) rep[i];
}
continue;
}
else
{
//Incase the target is NULL, add the length of the rep string
//but - 1 for the char its replacing
epos += tc_strlen(rep) - 1;
}
}
else
{
if (escstr)
{
escstr[epos] = str[pos];
}
}
epos++;
}//end for
if (escstr)
{
//don't forget to NULL terminate
escstr[epos] = '\0';
}
return epos;
}
struct wcache_entry *_wcache_new_entry(struct wcache_ctx *cc, const char * key)
{
struct wcache_entry *entry;
char filename[WEBC_CACHE_MAX_PATH_LEN];
void *fp;
CACHE_STATISTICS_UPDATE(cc, (char *)key,CACHE_STAT_EVENT_CREATE)
if (sizeof(wcache_entry) > (cc->bytesMax - cc->bytesUsed))
{
// won't fit; try to free up some space
if (!_wcache_free_bytes(cc, sizeof(wcache_entry)))
{
return (0);
}
}
if (cc->numFiles >= cc->maxFiles)
{
if (!_wcache_free_oldest_file(cc))
{
return (0);
}
}
entry = (struct wcache_entry *) WEBC_MALLOC(sizeof(struct wcache_entry));
if (entry)
{
entry->dataType = 0;
entry->key = webc_malloc_string_copy_8(key, __FILE__, __LINE__);
if (entry->key)
{
entry->keyLen = EBSMIN(WEBC_CACHE_MAX_KEY_LEN-1, tc_strlen(key));
entry->fileIndex = giCacheFileIndexHint;
while (1)
{
_wcache_get_filename(filename, cc, entry);
if (cc->spec.sys_open(cc->sysPtr, filename, &fp, WEBC_CO_READ) < 0)
{
break;
}
cc->spec.sys_close(cc->sysPtr, fp);
entry->fileIndex++;
// tbd - bound this loop
}
giCacheFileIndexHint = entry->fileIndex + 1;
entry->size = 0;
entry->flags = 0;
#if (WEBC_SUPPORT_CACHE_COMPRESSION)
entry->flags |= WEBC_CACHE_ENTRY_COMPRESSED;
#endif
INSERT_FRONT_CACHE(cc,entry);
cc->bytesUsed += sizeof(wcache_entry);
cc->numFiles++;
}
else
{
WEBC_FREE(entry);
entry = 0;
}
}
return (entry);
}
int wcache_flush(struct wcache_ctx *cc)
{
struct wcache_entry *entry;
WEBC_UINT16 saveFlags;
void *fp;
char filename[WEBC_CACHE_MAX_PATH_LEN];
#if (WEBC_CACHE_SAVE_DIRECTORY)
void *fpDir;
char lineBuffer[512];
#endif
tc_strcpy(filename, cc->cachePrefix);
tc_strcat(filename, "index.dat");
if (cc->spec.sys_open(cc->sysPtr, filename, &fp, WEBC_CO_CREATE) < 0)
{
return (-1);
}
#if (WEBC_CACHE_SAVE_DIRECTORY)
tc_strcpy(filename, cc->cachePrefix);
tc_strcat(filename, "index.txt");
if (cc->spec.sys_open(cc->sysPtr, filename, &fpDir, WEBC_CO_CREATE) < 0)
{
cc->spec.sys_close(cc->sysPtr, fp);
return (-1);
}
#endif
cc->spec.sys_write(cc->sysPtr, fp, (WEBC_PFBYTE) cc, sizeof(struct wcache_ctx));
#if (WEBC_CACHE_SAVE_DIRECTORY)
rtp_sprintf(lineBuffer,
" index mime-type size flags date expires key\r\n"
" ===== ========= ==== ===== ==== ======= ===\r\n"
"\r\n");
cc->spec.sys_write(cc->sysPtr, fpDir, (WEBC_PFBYTE) lineBuffer, tc_strlen(lineBuffer));
#endif
// reverse the order of all entries so we'll load it back in mru order
entry = cc->lru;
while (entry)
{
// if we dump the index in the middle of a cache op, then we don't want to have
// the entry marked as "open" when we re-load the index
saveFlags = entry->flags;
entry->flags &= ~(WEBC_CACHE_ENTRY_LOCKED | WEBC_CACHE_ENTRY_INUSE | WEBC_CACHE_ENTRY_LOCK_MASK);
cc->spec.sys_write(cc->sysPtr, fp, (WEBC_PFBYTE) entry, sizeof(struct wcache_entry) - sizeof(char *));
cc->spec.sys_write(cc->sysPtr, fp, (WEBC_PFBYTE) entry->key, entry->keyLen*sizeof(char));
#if (WEBC_CACHE_SAVE_DIRECTORY)
rtp_sprintf(lineBuffer, "%8x %9d %12ld %04hx ",
entry->fileIndex,
entry->dataType,
entry->size,
entry->flags);
ebs_print_time(lineBuffer + tc_strlen(lineBuffer), entry->date, 0);
tc_strcat(lineBuffer, " ");
ebs_print_time(lineBuffer + tc_strlen(lineBuffer), entry->expires, 0);
tc_strcat(lineBuffer, " ");
tc_strcat(lineBuffer, entry->key);
tc_strcat(lineBuffer, "\r\n");
cc->spec.sys_write(cc->sysPtr, fpDir, (WEBC_PFBYTE) lineBuffer, tc_strlen(lineBuffer));
#endif // WEBC_CACHE_SAVE_DIRECTORY
entry->flags = saveFlags;
entry = entry->prev;
}
cc->spec.sys_close(cc->sysPtr, fp);
#if (WEBC_CACHE_SAVE_DIRECTORY)
cc->spec.sys_close(cc->sysPtr, fpDir);
#endif
return (0);
}
void StringCopyBuilder::SetString(const char *pStr)
{
mpStr8 = pStr;
miStrLen = pStr? tc_strlen(pStr) : 0;
}
