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; }