static void requireStartEndLines(char *fileName, char *startLine, char *endLine)
/* Make sure first real line in file is startLine, and last is endLine. Tolerate
* empty lines and white space. */
{
char *reportFileName = fileNameOnly(fileName);
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line;
/* Get first real line and make sure it is not empty and matches start line. */
if (!lineFileNextReal(lf, &line))
errAbort("%s is empty", reportFileName);
line = trimSpaces(line);
if (!sameString(line, startLine))
errAbort("%s doesn't start with %s as expected", reportFileName, startLine);
boolean lastSame = FALSE;
for (;;)
{
if (!lineFileNextReal(lf, &line))
break;
line = trimSpaces(line);
lastSame = sameString(line, endLine);
}
if (!lastSame)
errAbort("%s doesn't end with %s as expected", reportFileName, endLine);
lineFileClose(&lf);
}
void loadReads(Reads* reads)
{
freeReads(reads); // FREE FIRST!
reads->readData = (struct read*)malloc(BATCH_SIZE * sizeof(struct read)); // LOAD SECOND!
for(int i = 0; i < BATCH_SIZE && (reads->current + i < reads->total); i++)
{
struct read* current = &(reads->readData[i]);
reads->ID = reads->ID + 1;
// TODO: THESE LENGTHS SHOULD BE VARIABLE!!!
char seqName1[2048];
char sequence[2048];
char seqName2[2048];
char quality[2048];
// Get the 4 lines of a FASTQ file:
if( fgets(seqName1, 2048, reads->file) == NULL ||
fgets(sequence, 2048, reads->file) == NULL ||
fgets(seqName2, 2048, reads->file) == NULL ||
fgets(quality, 2048, reads->file) == NULL )
{
printf("CRITICAL: FAILED TO READ INPUT!\n");
exit(1);
}
trimSpaces(sequence);
trimSpaces(quality);
trimNs(sequence, quality);
replaceN(sequence);
// Sequence name 1:
current->seqName1 = malloc(strlen(seqName1) + 1);
strcpy(current->seqName1, seqName1);
// Encode sequences:
encode_sequence(current, sequence);
// Also encode reverse_complement of sequences
//encode_sequence_reverse_comp(current, sequence);
// Sequence name 2:
current->seqName2 = malloc(strlen(seqName2) + 1);
strcpy(current->seqName2, seqName2);
//Quality:
current->quality = malloc(strlen(quality) + 1);
strcpy(current->quality, quality);
current->basecontig = NULL;
current->correct_pos = 0;
current->number = reads->ID;
}
}
// find WWW-Authenticate header, send to Authenticator to extract required subfields
void RtspThread::checkAuthResponse(std::string &response)
{
std::string authLine;
StringVector lines = split( response, "\r\n" );
const char* authenticate_match = "WWW-Authenticate:";
size_t authenticate_match_len = strlen(authenticate_match);
for ( size_t i = 0; i < lines.size(); i++ )
{
// stop at end of headers
if (lines[i].length()==0)
break;
if (strncasecmp(lines[i].c_str(),authenticate_match,authenticate_match_len) == 0)
{
authLine = lines[i];
Debug( 2, "Found auth line at %d", i);
break;
}
}
if (!authLine.empty())
{
Debug( 2, "Analyze auth line %s", authLine.c_str());
mAuthenticator->authHandleHeader( trimSpaces(authLine.substr(authenticate_match_len,authLine.length()-authenticate_match_len)) );
}
}
void cgiToStringFilter(char *dd, char *pat, enum stringFilterType *retSft,
char ***retVals, boolean *retInv)
/* Given a "does/doesn't" and a (list of) regexps from CGI, fill in
* retCft, retVals and retInv to make a filter. */
{
char **vals, *ptrs[32];
int numWords;
int i;
assert(retSft != NULL);
assert(retVals != NULL);
assert(retInv != NULL);
assert(sameString(dd, "does") || sameString(dd, "doesn't"));
/* catch null-constraint cases: */
if (pat == NULL)
pat = "";
pat = trimSpaces(pat);
if ((pat[0] == 0) || sameString(pat, "*"))
{
*retSft = sftIgnore;
return;
}
*retSft = sftMultiRegexp;
numWords = chopByWhite(pat, ptrs, ArraySize(ptrs));
vals = needMem((numWords+1) * sizeof(char *));
for (i=0; i < numWords; i++)
vals[i] = cloneString(ptrs[i]);
vals[i] = NULL;
*retVals = vals;
*retInv = sameString("doesn't", dd);
}
void doAdvFilterKeyPasted(struct sqlConnection *conn, struct column *colList,
struct column *col)
/* Handle submission in key-paste in form. */
{
char *pasteVarName = colVarName(col, keyWordPastedPrefix);
char *pasteVal = trimSpaces(cartString(cart, pasteVarName));
char *keyVarName = advFilterName(col, "keyFile");
if (pasteVal == NULL || pasteVal[0] == 0)
{
/* If string is empty then clear cart variable. */
cartRemove(cart, keyVarName);
}
else
{
/* Else write variable to temp file and save temp
* file name. */
struct tempName tn;
FILE *f;
makeTempName(&tn, "near", ".key");
f = mustOpen(tn.forCgi, "w");
mustWrite(f, pasteVal, strlen(pasteVal));
carefulClose(&f);
cartSetString(cart, keyVarName, tn.forCgi);
}
cartRemovePrefix(cart, keyWordPastedPrefix);
doAdvFilter(conn, colList);
}
int main(int argc, char *argv[])
{
char *listName = "finished.new";
char *fofName = "unfinished_acc.fof";
char *outName = "frags.txt";
FILE *out = mustOpen(outName, "w");
struct fof *fof = fofOpen(fofName, NULL);
struct kvt *kvt = newKvt(64);
char line[512];
int lineCount = 0;
FILE *lf;
char *keyText;
char *s, *t;
int size;
lf = mustOpen(listName, "r");
while (fgets(line, sizeof(line), lf))
{
++lineCount;
kvtClear(kvt);
s = trimSpaces(line);
t = strchr(s, '.');
if (t != NULL)
*t = 0;
keyText = fofFetchString(fof, s, &size);
kvtParseAdd(kvt, keyText);
fprintf(out, "%s phase %s frags %s\n", s, kvtLookup(kvt, "pha"), kvtLookup(kvt, "frg"));
freez(&keyText);
}
freeKvt(&kvt);
return 0;
}
void stopUpload(struct sqlConnection *conn)
/* Try and stop current upload. */
{
char *url = trimSpaces(cgiString("url"));
cgiMakeHiddenVar("url", url);
struct edwSubmit *sub = edwMostRecentSubmission(conn, url);
if (sub == NULL)
{
/* Submission hasn't happened yet - remove it from job queue. */
unsigned edwSubmitJobId = 0;
int posInQueue = edwSubmitPositionInQueue(conn, url, &edwSubmitJobId);
if (posInQueue >= 0)
{
char query[256];
sqlSafef(query, sizeof(query), "delete from edwSubmitJob where id=%u", edwSubmitJobId);
sqlUpdate(conn, query);
printf("Removed submission from %s from job queue\n", url);
}
}
else
{
char query[256];
sqlSafef(query, sizeof(query),
"update edwSubmit set errorMessage='Stopped by user.' where id=%u", sub->id);
sqlUpdate(conn, query);
}
monitorSubmission(conn);
}
static void normalizePatList(struct slName **pPatList)
/* patList might be a plain old list of terms, in which case we keep the
* terms only if they are not no-ops. patList might also be one element
* that is a space-separated list of terms, in which case we make a new
* list item for each non-no-op term. (Trim spaces while we're at it.) */
{
struct slName *pat, *nextPat, *patListOut = NULL;
if (pPatList == NULL) return;
for (pat = *pPatList; pat != NULL; pat = nextPat)
{
nextPat = pat->next;
strcpy(pat->name, trimSpaces(pat->name));
if (hasWhiteSpace(pat->name))
{
char *line = pat->name, *word;
while ((word = nextQuotedWord(&line)) != NULL)
if (wildReal(word))
{
struct slName *newPat = slNameNew(word);
slAddHead(&patListOut, newPat);
}
slNameFree(&pat);
}
else if (wildReal(pat->name))
slAddHead(&patListOut, pat);
}
*pPatList = patListOut;
}
void cgiToCharFilter(char *dd, char *pat, enum charFilterType *retCft,
char **retVals, boolean *retInv)
/* Given a "does/doesn't" and a (list of) literal chars from CGI, fill in
* retCft, retVals and retInv to make a filter. */
{
char *vals, *ptrs[32];
int numWords;
int i;
assert(retCft != NULL);
assert(retVals != NULL);
assert(retInv != NULL);
assert(sameString(dd, "does") || sameString(dd, "doesn't"));
/* catch null-constraint cases. ? will be treated as a literal match,
* which would make sense for bed strand and maybe other single-char things: */
if (pat == NULL)
pat = "";
pat = trimSpaces(pat);
if ((pat[0] == 0) || sameString(pat, "*"))
{
*retCft = cftIgnore;
return;
}
*retCft = cftMultiLiteral;
numWords = chopByWhite(pat, ptrs, ArraySize(ptrs));
vals = needMem((numWords+1) * sizeof(char));
for (i=0; i < numWords; i++)
vals[i] = ptrs[i][0];
vals[i] = 0;
*retVals = vals;
*retInv = sameString("doesn't", dd);
}
static Value* parseToken(const char** expr, parser_cb* cb) {
Value* ret;
char* token = nextToken(expr);
if(token == NULL) {
return ValErr(badChar(**expr));
}
trimSpaces(expr);
if(**expr == '(') {
(*expr)++;
ArgList* arglist = ArgList_parse(expr, ',', ')', cb);
if(arglist == NULL) {
/* Parse error occurred and has already been raised */
free(token);
return ValErr(ignoreError());
}
ret = ValCall(FuncCall_create(token, arglist));
}
else {
ret = ValVar(token);
}
free(token);
return ret;
}
boolean userSettingsProcessForm(struct userSettings *us)
/* Handle button press in userSettings form.
* If this returns TRUE then form is finished processing
* and you can call something to make the next page. */
{
struct cart *cart = us->cart;
char *command = cartString(cart, us->formVar);
boolean retVal = TRUE;
char *name = cartNonemptyString(cart, us->nameVar);
command = trimSpaces(command);
if (sameWord(command, "save") && name != NULL)
{
char *varName = settingsVarName(us->savePrefix, name);
saveSettings(us, varName);
freez(&varName);
}
else if (startsWith(command, "load") && name != NULL)
{
userSettingsUseSelected(us);
}
else if (startsWith("delete", command))
{
char *which = cartOptionalString(cart, us->listDisplayVar);
if (which != NULL)
{
char *varName = settingsVarName(us->savePrefix, which);
cartRemove(cart, varName);
userSettingsSaveForm(us);
retVal = FALSE;
}
}
cartRemove(cart, us->formVar);
return retVal;
}
void doSearch(struct sqlConnection *conn, struct column *colList)
/* Search. If result is unambiguous call displayData, otherwise
* put up a page of choices. */
{
char *search = cartString(cart, searchVarName);
char *escSearch = makeEscapedString(trimSpaces(search), '\'');
struct genePos *accList;
accList = findKnownAccessions(conn, escSearch);
if (accList != NULL)
{
if (slCount(accList) == 1 || !sameString(groupOn, "position"))
displayData(conn, colList, accList);
else
{
struct genePos *acc;
hPrintf("%s maps to %d positions, please pick one below:<BR>\n",
search, slCount(accList));
for (acc = accList; acc != NULL; acc = acc->next)
{
hPrintf(" ");
selfAnchorSearch(acc);
hPrintf("%s:%d-%d</A><BR>\n", acc->chrom, acc->start+1, acc->end);
}
}
}
else
{
searchAllColumns(conn, colList, escSearch);
}
freez(&escSearch);
}
std::string TextOutDisplay::prepareText( std::string text )
{
std::string tmp_text = text;
tmp_text = trimSpaces(tmp_text);
tmp_text = clearSmileys(tmp_text);
tmp_text = trimSpaces( tmp_text );
if( tmp_text == ".")
{
tmp_text = "";
}
return tmp_text;
}
char* nextToken(const char** expr) {
size_t len = 1;
trimSpaces(expr);
char* special = nextSpecial(expr);
if(special) {
return special;
}
const char* p = *expr;
/* First char must match [a-zA-Z_] */
if(!(isalpha(p[0]) || p[0] == '_')) {
return NULL;
}
/* Count consecutive number of chars matching [a-zA-Z0-9_] */
while(isalnum(p[len]) || p[len] == '_') {
len++;
}
char* ret = strndup(*expr, len);
*expr += len;
return ret;
}
unsigned buildReleaseBits(char *rel)
/* unpack the comma separated list of possible release tags */
{
if (rel == NULL)
return RELEASE_ALPHA | RELEASE_BETA | RELEASE_PUBLIC;
char *oldString = cloneString(rel);
unsigned bits = 0;
while(rel)
{
char *end = strchr(rel, ',');
if (end)
*end++ = 0;
rel = trimSpaces(rel);
if (sameString(rel, "alpha"))
bits |= RELEASE_ALPHA;
else if (sameString(rel, "beta"))
bits |= RELEASE_BETA;
else if (sameString(rel, "public"))
bits |= RELEASE_PUBLIC;
else
errAbort("track with release %s must have a release combination of alpha, beta, and public", oldString);
rel = end;
}
return bits;
}
bool cParser::include(std::stringstream & params)
{
std::string filename;
std::getline(params, filename);
trimSpaces(filename);
trimQuotes(filename);
return parse(filename);
}
char *trim(char *s)
/* Trim spaces and leading question marks. */
{
s = trimSpaces(s);
while (*s == '?')
++s;
return s;
}
static void addDatabasesToHash(struct hash *hash, char *s, struct lineFile *lf)
/* Add contents of comma-separated list to hash. */
{
struct slName *el, *list = parseDatabaseList(lf, trimSpaces(s));
for (el = list; el != NULL; el = el->next)
hashAdd(hash, el->name, NULL);
slFreeList(&list);
}
void makeTableDescriptions(char *database, char *asFile)
/* makeTableDescriptions - Add table descriptions to database.. */
{
struct sqlConnection *conn = sqlConnect(database);
struct lineFile *lf = lineFileOpen(asFile, TRUE);
FILE *f = hgCreateTabFile(".", "tableDescriptions");
/* Open a tab file with name corresponding to tableName in tmpDir. */
char *line;
/* struct asObject *asList = */ asParseFile(asFile); /* Just to check syntax */
if (sqlTableExists(conn, "chromInfo"))
errAbort("%s looks like a genome database, has chromInfo, aborting",
database);
sqlRemakeTable(conn, "tableDescriptions",
"NOSQLINJ CREATE TABLE tableDescriptions (\n"
" tableName varchar(255) not null,\n"
" autoSqlDef longblob not null,\n"
" gbdAnchor varchar(255) not null,\n"
" PRIMARY KEY(tableName(32))\n"
")" );
while (lineFileNextReal(lf, &line))
{
if (startsWith("table", line))
{
struct dyString *as = dyStringNew(0);
char *name = trimSpaces(line + 6); /* Skip over table. */
char *escaped = NULL;
fprintf(f, "%s\t", name);
/* Putting lines into as. */
for (;;)
{
char *s;
dyStringAppend(as, line);
dyStringAppendC(as, '\n');
s = skipLeadingSpaces(line);
if (s[0] == ')')
break;
if (!lineFileNext(lf, &line, NULL))
errAbort("Unexpected end of file, missing closing paren in %s",
lf->fileName);
}
escaped = needMem(2*as->stringSize+1);
fprintf(f, "%s\t", sqlEscapeTabFileString2(escaped, as->string));
fprintf(f, "\n");
freez(&escaped);
dyStringFree(&as);
}
else
errAbort("Expecting table line %d of %s", lf->lineIx, lf->fileName);
}
hgLoadTabFile(conn, ".", "tableDescriptions", &f);
}
int LibvlcCamera::PrimeCapture() {
Info("Priming capture from %s", mPath.c_str());
StringVector opVect = split(Options(), ",");
// Set transport method as specified by method field, rtpUni is default
if ( Method() == "rtpMulti" )
opVect.push_back("--rtsp-mcast");
else if ( Method() == "rtpRtsp" )
opVect.push_back("--rtsp-tcp");
else if ( Method() == "rtpRtspHttp" )
opVect.push_back("--rtsp-http");
opVect.push_back("--no-audio");
if ( opVect.size() > 0 ) {
mOptArgV = new char*[opVect.size()];
Debug(2, "Number of Options: %d",opVect.size());
for (size_t i=0; i< opVect.size(); i++) {
opVect[i] = trimSpaces(opVect[i]);
mOptArgV[i] = (char *)opVect[i].c_str();
Debug(2, "set option %d to '%s'", i, opVect[i].c_str());
}
}
mLibvlcInstance = libvlc_new(opVect.size(), (const char* const*)mOptArgV);
if ( mLibvlcInstance == NULL ) {
Error("Unable to create libvlc instance due to: %s", libvlc_errmsg());
return -1;
}
mLibvlcMedia = libvlc_media_new_location(mLibvlcInstance, mPath.c_str());
if ( mLibvlcMedia == NULL ) {
Error("Unable to open input %s due to: %s", mPath.c_str(), libvlc_errmsg());
return -1;
}
mLibvlcMediaPlayer = libvlc_media_player_new_from_media(mLibvlcMedia);
if ( mLibvlcMediaPlayer == NULL ) {
Error("Unable to create player for %s due to: %s", mPath.c_str(), libvlc_errmsg());
return -1;
}
libvlc_video_set_format(mLibvlcMediaPlayer, mTargetChroma.c_str(), width, height, width * mBpp);
libvlc_video_set_callbacks(mLibvlcMediaPlayer, &LibvlcLockBuffer, &LibvlcUnlockBuffer, NULL, &mLibvlcData);
mLibvlcData.bufferSize = width * height * mBpp;
// Libvlc wants 32 byte alignment for images (should in theory do this for all image lines)
mLibvlcData.buffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize);
mLibvlcData.prevBuffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize);
mLibvlcData.newImage.setValueImmediate(false);
libvlc_media_player_play(mLibvlcMediaPlayer);
return 0;
}
boolean raNextTagVal(struct lineFile *lf, char **retTag, char **retVal, struct dyString *dyRecord)
// Read next line. Return FALSE at end of file or blank line. Otherwise fill in
// *retTag and *retVal and return TRUE. If dy parameter is non-null, then the text parsed
// gets appended to dy. Continuation lines in RA file will be joined to produce tag and val,
// but dy will be filled with the unedited multiple lines containing the continuation chars.
// NOTE: retTag & retVal, if returned, point to static mem which will be overwritten on next call!
{
*retTag = NULL;
*retVal = NULL;
char *line, *raw = NULL;
int lineLen,rawLen;
// Don't bother with raw if it isn't used.
char **pRaw = NULL;
int *pRawLen = NULL;
if (dyRecord != NULL)
{
pRaw = &raw;
pRawLen = &rawLen;
}
while (lineFileNextFull(lf, &line, &lineLen, pRaw, pRawLen)) // Joins continuation lines
{
char *clippedText = skipLeadingSpaces(line);
if (*clippedText == 0)
{
if (dyRecord)
lineFileReuse(lf); // Just so don't loose leading space in dy.
return FALSE;
}
// Append whatever line was read from file.
if (dyRecord)
{
if (raw != NULL)
dyStringAppendN(dyRecord, raw, rawLen);
else
dyStringAppendN(dyRecord, line, lineLen);
dyStringAppendC(dyRecord,'\n');
}
// Skip comments
if (*clippedText == '#')
{
if (startsWith("#EOF", clippedText))
return FALSE;
else
continue;
}
*retTag = nextWord(&line);
*retVal = trimSpaces(line);
return TRUE;
}
return FALSE;
}
static struct joinerType *parseType(struct lineFile *lf,
char *line, struct hash *symHash, struct dyString *dyBuf)
/* Parse one type record. */
{
struct joinerType *type;
AllocVar(type);
type->name = cloneString(trimSpaces(line));
while ((line = nextSubbedLine(lf, symHash, dyBuf)) != NULL)
{
struct joinerTable *table;
line = trimSpaces(line);
if (line[0] == 0)
break;
table = parseTableSpec(lf, line);
slAddHead(&type->tableList, table);
}
slReverse(&type->tableList);
return type;
}
void loadAccs(char *accFile, struct hash *accTbl)
/* load accessions from a file */
{
struct lineFile *lf = lineFileOpen(accFile, TRUE);
char *line;
while (lineFileNextReal(lf, &line))
addAcc(accTbl, trimSpaces(line));
lineFileClose(&lf);
}
void edwWriteErrToTable(struct sqlConnection *conn, char *table, int id, char *err)
/* Write out error message to errorMessage field of table. */
{
char *trimmedError = trimSpaces(err);
struct dyString *query = dyStringNew(0);
sqlDyStringPrintf(query, "update %s set errorMessage='%s' where id=%d",
table, trimmedError, id);
sqlUpdate(conn, query->string);
dyStringFree(&query);
}
static void printCladeOrgDbTree(struct jsonWrite *jw)
/* Print out the tree of clades, organisms and dbs as JSON. Each node has value and label
* for menu options; clade nodes and org nodes also have children and default. */
{
jsonWriteListStart(jw, "cladeOrgDb");
struct slPair *clade, *cladeOptions = hGetCladeOptions();
struct dbDb *centralDbDbList = hDbDbList();
for (clade = cladeOptions; clade != NULL; clade = clade->next)
{
jsonWriteObjectStart(jw, NULL);
jsonWriteValueLabel(jw, clade->name, clade->val);
jsonWriteListStart(jw, "children");
struct slPair *org, *orgOptions = hGetGenomeOptionsForClade(clade->name);
for (org = orgOptions; org != NULL; org = org->next)
{
jsonWriteObjectStart(jw, NULL);
jsonWriteValueLabel(jw, org->name, org->val);
jsonWriteListStart(jw, "children");
struct dbDb *dbDb, *dbDbList;
if (isHubTrack(org->name))
dbDbList = trackHubGetDbDbs(clade->name);
else
dbDbList = centralDbDbList;
for (dbDb = dbDbList; dbDb != NULL; dbDb = dbDb->next)
{
if (sameString(org->name, dbDb->genome))
{
jsonWriteObjectStart(jw, NULL);
jsonWriteValueLabel(jw, dbDb->name, dbDb->description);
jsonWriteString(jw, "defaultPos", dbDb->defaultPos);
jsonWriteObjectEnd(jw);
}
}
jsonWriteListEnd(jw); // children (dbs)
jsonWriteString(jw, "default", trimSpaces(hDefaultDbForGenome(org->name)));
jsonWriteObjectEnd(jw); // org
}
jsonWriteListEnd(jw); // children (orgs)
jsonWriteString(jw, "default", trimSpaces(hDefaultGenomeForClade(clade->name)));
jsonWriteObjectEnd(jw); // clade
}
jsonWriteListEnd(jw);
}
struct raField *raFieldFromLine(char *line, struct lm *lm)
/* Parse out line and convert it to a raField. Will return NULL on empty lines.
* Will insert some zeroes into the input line as well. */
{
char *word = nextWord(&line);
if (word == NULL)
return NULL;
trimSpaces(line);
return raFieldNew(word, line, lm);
}
//////////////////////////////////////////////////////////////////////////////
///
/// Get the first operand
///
//////////////////////////////////////////////////////////////////////////////
long controller::getFirstOperand(unsigned char* ptr) {
unsigned char length = getOperationPosition(ptr);
unsigned char* trimPtr = trimSpaces(ptr, &length);
long number = convertCharacterToNumber(trimPtr, length);
if (GetVerbose())
SpacePrint("First operand:%d\n", number);
return number;
}
void handleFileError(struct sqlConnection *conn, int submitId, int fileId, char *err)
/* Write out error to stderr and also save it in errorMessage field of file
* and submit table. */
{
/* Write out error message to errorMessage field of table. */
warn("%s", trimSpaces(err));
edwWriteErrToTable(conn, "edwFile", fileId, err);
edwWriteErrToTable(conn, "edwSubmit", submitId, err);
noWarnAbort(err);
}
int getSign(const char** expr) {
int sign = 1;
trimSpaces(expr);
if(**expr == '-') {
sign = -1;
(*expr)++;
}
return sign;
}
void Authenticator::authHandleHeader(std::string headerData)
{
const char* basic_match = "Basic ";
const char* digest_match = "Digest ";
size_t digest_match_len = strlen(digest_match);
// Check if basic auth
if (strncasecmp(headerData.c_str(),basic_match,strlen(basic_match)) == 0)
{
fAuthMethod = AUTH_BASIC;
Debug( 2, "Set authMethod to Basic");
}
// Check if digest auth
else if (strncasecmp( headerData.c_str(),digest_match,digest_match_len ) == 0)
{
fAuthMethod = AUTH_DIGEST;
Debug( 2, "Set authMethod to Digest");
StringVector subparts = split(headerData.substr(digest_match_len, headerData.length() - digest_match_len), ",");
// subparts are key="value"
for ( size_t i = 0; i < subparts.size(); i++ )
{
StringVector kvPair = split( trimSpaces( subparts[i] ), "=" );
std::string key = trimSpaces( kvPair[0] );
if (key == "realm") {
fRealm = trimSet( kvPair[1], "\"");
continue;
}
if (key == "nonce") {
fNonce = trimSet( kvPair[1], "\"");
continue;
}
if (key == "qop") {
fQop = trimSet( kvPair[1], "\"");
continue;
}
}
Debug( 2, "Auth data completed. User: %s, realm: %s, nonce: %s, qop: %s", username().c_str(), fRealm.c_str(), fNonce.c_str(), fQop.c_str() );
}
}
