/* Given all the HTTP headers as a single string parse them into individual
* name, value pairs. Called twice: once to work out how many headers there
* are, then again to copy them.
*/
static int ParseHeaders(private_ws_t *ws, const char *hdrs, int hdrsz, jk_ws_service_t *s)
{
int hdrCount = 0;
const char *limit = hdrs + hdrsz;
const char *name, *nameEnd;
const char *value, *valueEnd;
while (hdrs < limit)
{
/* Skip line *before* doing anything, cos we want to lose the first line which
* contains the request.
*/
while (hdrs < limit && (*hdrs != '\n' && *hdrs != '\r'))
hdrs++;
while (hdrs < limit && (*hdrs == '\n' || *hdrs == '\r'))
hdrs++;
if (hdrs >= limit)
break;
name = nameEnd = value = valueEnd = NULL;
name = hdrs;
while (hdrs < limit && *hdrs >= ' ' && *hdrs != ':')
hdrs++;
nameEnd = hdrs;
if (hdrs < limit && *hdrs == ':')
{
hdrs++;
while (hdrs < limit && (*hdrs == ' ' || *hdrs == '\t'))
hdrs++;
value = hdrs;
while (hdrs < limit && *hdrs >= ' ')
hdrs++;
valueEnd = hdrs;
}
if (s->headers_names != NULL && s->headers_values != NULL)
{
s->headers_names[hdrCount] = MemDup(ws, name, nameEnd);
s->headers_values[hdrCount] = MemDup(ws, value, valueEnd);
DEBUG(("%s = %s\n", s->headers_names[hdrCount], s->headers_values[hdrCount]));
}
hdrCount++;
}
return hdrCount;
}
int SendAuthentificationBlobLS(Host CurLS, char *User, char *Pass)
{
double PlatForm;
uchar AuthBlob[0xFFFF] = {0};
uchar MD5Result[MD5_DIGEST_LENGTH] = {0};
uchar SHAResult[32] = {0};
uchar SessionKey[SK_SZ] = {0};
uchar Modulus[MODULUS_SZ * 2] = {0};
uchar ivec[AES_BLOCK_SIZE] = {0};
uchar ecount_buf[AES_BLOCK_SIZE] = {0};
uint MiscDatas[0x05] = {0};
uchar *Browser;
uchar *Mark;
uchar *MarkObjL;
uint Idx, Size, Crc;
HttpsPacketHeader *HSHeader;
AES_KEY AesKey;
MD5_CTX Context;
RSA *Keys;
RSA *SkypeRSA;
ObjectDesc Obj2000, ObjSessionKey, ObjZBool1, ObjRequestCode, ObjZBool2, ObjUserName, ObjSharedSecret, ObjModulus, ObjPlatForm, ObjLang, ObjMiscDatas, ObjVer, ObjPubAddr;
printf("Generating RSA Keys Pair (Size = %d Bits)..\n", KEYSZ);
Keys = RSA_generate_key(KEYSZ * 2, RSA_F4, NULL, NULL);
if (Keys == NULL)
{
printf("Error generating Keys..\n\n");
return (0);
}
//printf("Modulus N..\n");
Idx = BN_bn2bin(Keys->n, Modulus);
//showmem(Modulus, MODULUS_SZ);
//printf("Modulus D\n");
Idx = BN_bn2bin(Keys->d, Modulus + Idx);
//showmem(Modulus + MODULUS_SZ, MODULUS_SZ);
//printf("\n");
Browser = AuthBlob;
HSHeader = (HttpsPacketHeader *)Browser;
memcpy_s(HSHeader->MAGIC, sizeof(HSHeader->MAGIC), HTTPS_HSR_MAGIC, strlen(HTTPS_HSR_MAGIC));
HSHeader->ResponseLen = htons(0xCD);
Browser += sizeof(HttpsPacketHeader);
*Browser++ = RAW_PARAMS;
*Browser++ = 0x03;
Obj2000.Family = OBJ_FAMILY_NBR;
Obj2000.Id = OBJ_ID_2000;
Obj2000.Value.Nbr = 0x2000;
WriteObject(&Browser, Obj2000);
GetSessionKey(SessionKey);
SpecialSHA(SessionKey, SK_SZ, SHAResult, 32);
AES_set_encrypt_key(SHAResult, 256, &AesKey);
SkypeRSA = RSA_new();
BN_hex2bn(&(SkypeRSA->n), SkypeModulus1536[1]);
BN_hex2bn(&(SkypeRSA->e), "10001");
RSA_public_encrypt(SK_SZ, SessionKey, SessionKey, SkypeRSA, RSA_NO_PADDING);
RSA_free(SkypeRSA);
ObjSessionKey.Family = OBJ_FAMILY_BLOB;
ObjSessionKey.Id = OBJ_ID_SK;
ObjSessionKey.Value.Memory.Memory = (uchar *)&SessionKey;
ObjSessionKey.Value.Memory.MsZ = SK_SZ;
WriteObject(&Browser, ObjSessionKey);
ObjZBool1.Family = OBJ_FAMILY_NBR;
ObjZBool1.Id = OBJ_ID_ZBOOL1;
ObjZBool1.Value.Nbr = 0x01;
WriteObject(&Browser, ObjZBool1);
Mark = Browser;
HSHeader = (HttpsPacketHeader *)Browser;
memcpy_s(HSHeader->MAGIC, sizeof(HSHeader->MAGIC), HTTPS_HSRR_MAGIC, strlen(HTTPS_HSRR_MAGIC));
HSHeader->ResponseLen = htons(0x00);
Browser += sizeof(HttpsPacketHeader);
MarkObjL = Browser;
*Browser++ = RAW_PARAMS;
*Browser++ = 0x04;
ObjRequestCode.Family = OBJ_FAMILY_NBR;
ObjRequestCode.Id = OBJ_ID_REQCODE;
ObjRequestCode.Value.Nbr = 0x1399;
WriteObject(&Browser, ObjRequestCode);
ObjZBool2.Family = OBJ_FAMILY_NBR;
ObjZBool2.Id = OBJ_ID_ZBOOL2;
ObjZBool2.Value.Nbr = 0x01;
WriteObject(&Browser, ObjZBool2);
ObjUserName.Family = OBJ_FAMILY_STRING;
ObjUserName.Id = OBJ_ID_USERNAME;
ObjUserName.Value.Memory.Memory = (uchar *)User;
ObjUserName.Value.Memory.MsZ = (uchar)strlen(User);
WriteObject(&Browser, ObjUserName);
MD5_Init(&Context);
MD5_Update(&Context, User, (ulong)strlen(User));
MD5_Update(&Context, CONCAT_SALT, (ulong)strlen(CONCAT_SALT));
MD5_Update(&Context, Pass, (ulong)strlen(Pass));
MD5_Final(MD5Result, &Context);
ObjSharedSecret.Family = OBJ_FAMILY_BLOB;
ObjSharedSecret.Id = OBJ_ID_USERPASS;
ObjSharedSecret.Value.Memory.Memory = (uchar *)MD5Result;
ObjSharedSecret.Value.Memory.MsZ = MD5_DIGEST_LENGTH;
WriteObject(&Browser, ObjSharedSecret);
*Browser++ = RAW_PARAMS;
*Browser++ = 0x06;
ObjModulus.Family = OBJ_FAMILY_BLOB;
ObjModulus.Id = OBJ_ID_MODULUS;
ObjModulus.Value.Memory.Memory = (uchar *)Modulus;
ObjModulus.Value.Memory.MsZ = MODULUS_SZ;
WriteObject(&Browser, ObjModulus);
PlatForm = PlatFormSpecific();
ObjPlatForm.Family = OBJ_FAMILY_TABLE;
ObjPlatForm.Id = OBJ_ID_PLATFORM;
memcpy_s(ObjPlatForm.Value.Table, sizeof(ObjPlatForm.Value.Table), (uchar *)&PlatForm, sizeof(ObjPlatForm.Value.Table));
WriteObject(&Browser, ObjPlatForm);
ObjLang.Family = OBJ_FAMILY_STRING;
ObjLang.Id = OBJ_ID_LANG;
ObjLang.Value.Memory.Memory = (uchar *)LANG_STR;
ObjLang.Value.Memory.MsZ = (uchar)strlen(LANG_STR);
WriteObject(&Browser, ObjLang);
FillMiscDatas(MiscDatas);
ObjMiscDatas.Family = OBJ_FAMILY_INTLIST;
ObjMiscDatas.Id = OBJ_ID_MISCD;
ObjMiscDatas.Value.Memory.Memory = (uchar *)MiscDatas;
ObjMiscDatas.Value.Memory.MsZ = 0x05;
WriteObject(&Browser, ObjMiscDatas);
ObjVer.Family = OBJ_FAMILY_STRING;
ObjVer.Id = OBJ_ID_VERSION;
ObjVer.Value.Memory.Memory = (uchar *)VER_STR;
ObjVer.Value.Memory.MsZ = (uchar)strlen(VER_STR);
WriteObject(&Browser, ObjVer);
ObjPubAddr.Family = OBJ_FAMILY_NBR;
ObjPubAddr.Id = OBJ_ID_PUBADDR;
ObjPubAddr.Value.Nbr = htonl(my_public_ip);
WriteObject(&Browser, ObjPubAddr);
Size = (uint)(Browser - MarkObjL);
HSHeader->ResponseLen = htons((ushort)Size + 0x02);
Idx = 0;
ZeroMemory(ivec, AES_BLOCK_SIZE);
ZeroMemory(ecount_buf, AES_BLOCK_SIZE);
AES_ctr128_encrypt(MarkObjL, MarkObjL, Size, &AesKey, ivec, ecount_buf, &Idx);
Crc = crc32(MarkObjL, Size, -1);
*Browser++ = *((uchar *)(&Crc) + 0);
*Browser++ = *((uchar *)(&Crc) + 1);
Size = (uint)(Browser - AuthBlob);
SuperWait = 1;
if (SendPacketTCP(LSSock, CurLS, AuthBlob, Size, HTTPS_PORT, &Connected))
printf("Auth Response Got..\n\n");
else
{
printf(":'(..\n");
return (-1);
}
/*unsigned char data[222] = {
0x17, 0x03, 0x01, 0x00, 0xD9, 0x73, 0xC4, 0x06, 0x08, 0xFF, 0x1F, 0xFE, 0xED, 0x64, 0xB8, 0x49,
0x4D, 0xD8, 0xBE, 0xCD, 0xC9, 0xEF, 0x63, 0x74, 0x6D, 0x7F, 0x1D, 0x9B, 0xE6, 0x91, 0xFC, 0x14,
0xC6, 0x01, 0xDD, 0x79, 0xD6, 0xEA, 0x3B, 0xB3, 0xB6, 0x20, 0x03, 0x5E, 0x05, 0xEB, 0xFC, 0xAA,
0x46, 0x35, 0x7B, 0xAF, 0x5A, 0x59, 0x01, 0xFA, 0xBB, 0xB6, 0x1F, 0x81, 0x6D, 0x34, 0x85, 0x39,
0x93, 0xBB, 0x9B, 0x5B, 0xCC, 0x21, 0xD4, 0xCC, 0x85, 0x39, 0x27, 0x62, 0x69, 0xBC, 0x05, 0x48,
0xF2, 0x19, 0x88, 0xD3, 0x86, 0xD3, 0x10, 0x0D, 0xE1, 0x36, 0x08, 0x14, 0xC9, 0xC3, 0x52, 0x8B,
0x86, 0x42, 0x8D, 0x1F, 0x25, 0x02, 0x2E, 0x82, 0x48, 0xDC, 0x0C, 0x5C, 0x66, 0x5E, 0x34, 0x1A,
0x00, 0x3B, 0x4F, 0x6D, 0x54, 0x2E, 0x02, 0x91, 0x3E, 0xE1, 0xD7, 0x47, 0xC9, 0x04, 0xA0, 0xB2,
0xBD, 0x60, 0x49, 0xE1, 0xB8, 0x79, 0xB3, 0x1A, 0xE5, 0x14, 0x12, 0xC8, 0x0C, 0x37, 0xB3, 0x23,
0x2E, 0xBD, 0xD7, 0x9F, 0x47, 0xA3, 0xE1, 0xAD, 0x21, 0xEF, 0xF0, 0x79, 0x7E, 0x72, 0x28, 0x29,
0xCA, 0xAF, 0x29, 0xDD, 0xE4, 0xDC, 0x2C, 0x9C, 0x52, 0x07, 0xC5, 0x33, 0x9D, 0x65, 0xE3, 0x06,
0x14, 0x12, 0xEA, 0xF7, 0x7F, 0x1B, 0x79, 0xA2, 0x65, 0xA2, 0x5C, 0x68, 0x74, 0x13, 0x97, 0x41,
0xFE, 0x83, 0x2B, 0x13, 0x56, 0x56, 0x57, 0x1F, 0xCC, 0x65, 0xA0, 0x46, 0xEA, 0x0C, 0x18, 0x8B,
0x59, 0x9C, 0xE1, 0x9E, 0x59, 0x68, 0x43, 0x94, 0x2D, 0x1E, 0xC3, 0x4F, 0x7F, 0x04
};
ZeroMemory(RecvBuffer, sizeof(RecvBuffer));
memcpy_s(RecvBuffer, sizeof(RecvBuffer), data, sizeof(data));*/
HSHeader = (HttpsPacketHeader *)RecvBuffer;
if (strncmp((const char *)HSHeader->MAGIC, HTTPS_HSRR_MAGIC, strlen(HTTPS_HSRR_MAGIC)))
{
printf("Bad Response..\n");
return (-1);
}
Idx = 0;
ZeroMemory(ivec, AES_BLOCK_SIZE);
ZeroMemory(ecount_buf, AES_BLOCK_SIZE);
ivec[3] = 0x01;
ivec[7] = 0x01;
AES_ctr128_encrypt(RecvBuffer + sizeof(HttpsPacketHeader), RecvBuffer + sizeof(HttpsPacketHeader), htons(HSHeader->ResponseLen) - 0x02, &AesKey, ivec, ecount_buf, &Idx);
printf("[UNCIPHERED]Auth Response..\n\n");
//showmem(RecvBuffer, RecvBufferSz);
//printf("\n\n");
uchar *Buffer;
uint BSize;
SResponse Response;
Buffer = RecvBuffer;
BSize = RecvBufferSz;
Response.Objs = NULL;
Response.NbObj = 0;
while (BSize)
{
MainArchResponseManager(&Buffer, &BSize, &Response);
Buffer += 2;
}
for (Idx = 0; Idx < Response.NbObj; Idx++)
{
switch (Response.Objs[Idx].Id)
{
case OBJ_ID_LOGINANSWER:
switch (Response.Objs[Idx].Value.Nbr)
{
case LOGIN_OK:
cprintf(FOREGROUND_BLUE, "Login Successful..\n");
GLoginD.RSAKeys = Keys;
break;
default :
cprintf(FOREGROUND_RED, "Login Failed.. Bad Credentials..\n");
ExitProcess(0);
break;
}
break;
case OBJ_ID_CIPHERDLOGD:
GLoginD.SignedCredentials.Memory = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
GLoginD.SignedCredentials.MsZ = Response.Objs[Idx].Value.Memory.MsZ;
uchar *PostProcessed;
char *Key;
uint KeyIdx, PPsZ;
KeyIdx = htonl(*(uint *)Response.Objs[Idx].Value.Memory.Memory);
Response.Objs[Idx].Value.Memory.Memory += 4;
Response.Objs[Idx].Value.Memory.MsZ -= 4;
SkypeRSA = RSA_new();
Key = KeySelect(KeyIdx);
BN_hex2bn(&(SkypeRSA->n), Key);
BN_hex2bn(&(SkypeRSA->e), "10001");
PPsZ = RSA_public_decrypt(Response.Objs[Idx].Value.Memory.MsZ, Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.Memory, SkypeRSA, RSA_NO_PADDING);
RSA_free(SkypeRSA);
PostProcessed = FinalizeLoginDatas(Response.Objs[Idx].Value.Memory.Memory, &PPsZ, NULL, 0);
Response.Objs[Idx].Value.Memory.Memory += PPsZ;
if (PostProcessed == NULL)
{
printf("Bad Datas Finalization..\n");
return (0);
}
//showmem(PostProcessed, PPsZ);
//printf("\n");
SResponse LoginDatas;
LoginDatas.Objs = NULL;
LoginDatas.NbObj = 0;
ManageObjects(&PostProcessed, PPsZ, &LoginDatas);
for (uint LdIdx = 0; LdIdx < LoginDatas.NbObj; LdIdx++)
{
switch (LoginDatas.Objs[LdIdx].Id)
{
case OBJ_ID_LDUSER:
GLoginD.User = LoginDatas.Objs[LdIdx].Value.Memory.Memory;
break;
case OBJ_ID_LDEXPIRY:
GLoginD.Expiry = LoginDatas.Objs[LdIdx].Value.Nbr;
break;
case OBJ_ID_LDMODULUS:
GLoginD.Modulus = LoginDatas.Objs[LdIdx].Value.Memory;
//showmem(LoginDatas.Objs[LdIdx].Value.Memory.Memory, LoginDatas.Objs[LdIdx].Value.Memory.MsZ);
//printf("\n\n");
break;
default :
printf("Non critical Object %d:%d..\n", LoginDatas.Objs[LdIdx].Family, LoginDatas.Objs[LdIdx].Id);
break;
}
}
cprintf(FOREGROUND_BLUE, "User <%s> Logged in.. Credentials Expiry : %d\n", GLoginD.User, GLoginD.Expiry);
cprintf(FOREGROUND_BLUE, "Login Data Saved..\n");
break;
default :
printf("Non critical Object %d:%d..\n", Response.Objs[Idx].Family, Response.Objs[Idx].Id);
break;
}
}
printf("\n\n");
return (1);
}
static Int2 Main_old (void)
{
AsnIoPtr aip, xml_aip = NULL;
BioseqPtr query_bsp, PNTR query_bsp_array;
BioSourcePtr source;
BLAST_MatrixPtr matrix;
BLAST_OptionsBlkPtr options;
BLAST_KarlinBlkPtr ka_params=NULL, ka_params_gap=NULL;
BlastPruneSapStructPtr prune;
Boolean db_is_na, query_is_na, show_gi, believe_query=FALSE;
Boolean html=FALSE;
CharPtr params_buffer=NULL;
Int4 number_of_descriptions, number_of_alignments;
SeqAlignPtr seqalign, PNTR seqalign_array;
SeqAnnotPtr seqannot;
SeqEntryPtr PNTR sepp;
TxDfDbInfoPtr dbinfo=NULL, dbinfo_head;
Uint1 align_type, align_view, out_type;
Uint4 align_options, print_options;
ValNodePtr mask_loc, mask_loc_start, next_mask_loc;
ValNodePtr vnp, other_returns, error_returns;
CharPtr blast_program, blast_database, blast_inputfile, blast_outputfile;
FILE *infp, *outfp, *mqfp=NULL;
Int4 index, num_bsps, total_length, total_processed = 0;
Int2 ctr = 1;
Char prefix[2];
SeqLocPtr last_mask, mask_slp;
Boolean done, hits_found;
Boolean lcase_masking;
MBXmlPtr mbxp = NULL;
Boolean traditional_formatting;
blast_program = "blastn";
blast_database = myargs [ARG_DB].strvalue;
blast_inputfile = myargs [ARG_QUERY].strvalue;
blast_outputfile = myargs [ARG_OUT].strvalue;
if (myargs[ARG_HTML].intvalue)
html = TRUE;
if ((infp = FileOpen(blast_inputfile, "r")) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "mgblast: Unable to open input file %s\n", blast_inputfile);
return (1);
}
align_view = (Int1) myargs[ARG_FORMAT].intvalue;
/* Geo mod:
-- replaced myargs[ARG_OUTTYPE].intvalue with out_type from now on
*/
out_type=(Int1) myargs[ARG_OUTTYPE].intvalue;
if (out_type==MGBLAST_FLTHITS || out_type==MGBLAST_HITGAPS) {
align_view = 12 + (out_type-MGBLAST_FLTHITS );
out_type=MBLAST_ALIGNMENTS;
//Attention: 12 MUST be the -m mgblast tab option for MGBLAST_FLTHITS format
// and MGBLAST_HITGAPS = MGBLAST_FLTHITS+1
if (align_view>12) { // this is MGBLAST_HITGAPS output
gap_Info=TRUE;
if (dbgaps_buf==NULL)
dbgaps_buf=(CharPtr) Malloc(dbgaps_bufsize + 1);
if (qgaps_buf==NULL)
qgaps_buf=(CharPtr) Malloc(qgaps_bufsize + 1);
}
}
outfp = NULL;
traditional_formatting =
(out_type == MBLAST_ALIGNMENTS ||
out_type == MBLAST_DELAYED_TRACEBACK);
if ((!traditional_formatting ||
(align_view != 7 && align_view != 10 && align_view != 11)) &&
blast_outputfile != NULL) {
if ((outfp = FileOpen(blast_outputfile, "w")) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", blast_outputfile);
return (1);
}
}
//align_type = BlastGetTypes(blast_program, &query_is_na, &db_is_na);
align_type = BlastGetTypes(blast_program, &query_is_na, &db_is_na);
/*
if (!traditional_formatting)
believe_query = TRUE;
else
believe_query = (Boolean) myargs[ARG_BELIEVEQUERY].intvalue;
*/
//Geo mod:
believe_query=FALSE;
//If ASN.1 output is requested and believe_query is not set to TRUE,
// exit with an error.
if (!believe_query && (myargs[ARG_ASNOUT].strvalue ||
align_view == 10 || align_view == 11)) {
ErrPostEx(SEV_FATAL, 1, 0,
"-J option must be TRUE to produce ASN.1 output; before "
"changing -J to TRUE please also ensure that all query "
"sequence identifiers are unique");
return -1;
}
options = BLASTOptionNewEx(blast_program, TRUE, TRUE);
if (options == NULL)
return 3;
options->do_sum_stats = FALSE;
options->is_neighboring = FALSE;
options->expect_value = (Nlm_FloatHi) myargs [ARG_EVALUE].floatvalue;
number_of_descriptions = myargs[ARG_DESCRIPTIONS].intvalue;
number_of_alignments = myargs[ARG_ALIGNMENTS].intvalue;
options->hitlist_size = MAX(number_of_descriptions, number_of_alignments);
if (myargs[ARG_XDROP].intvalue != 0)
options->gap_x_dropoff = myargs[ARG_XDROP].intvalue;
if (myargs[ARG_XDROP_UNGAPPED].intvalue != 0)
options->dropoff_2nd_pass = myargs[ARG_XDROP_UNGAPPED].intvalue;
if (myargs[ARG_XDROP_FINAL].intvalue != 0)
options->gap_x_dropoff_final = myargs[ARG_XDROP_FINAL].intvalue;
if (StringICmp(myargs[ARG_FILTER].strvalue, "T") == 0)
options->filter_string = StringSave("D");
else
options->filter_string = StringSave(myargs[ARG_FILTER].strvalue);
show_gi = (Boolean) myargs[ARG_SHOWGIS].intvalue;
options->penalty = myargs[ARG_MISMATCH].intvalue;
options->reward = myargs[ARG_MATCH].intvalue;
if (myargs[ARG_GAPOPEN].intvalue >= 0)
options->gap_open = myargs[ARG_GAPOPEN].intvalue;
if (myargs[ARG_GAPEXT].intvalue >= 0)
options->gap_extend = myargs[ARG_GAPEXT].intvalue;
if (options->gap_open == 0 && options->reward % 2 == 0 &&
options->gap_extend == options->reward / 2 - options->penalty)
/* This is the default value */
options->gap_extend = 0;
options->genetic_code = 1;
options->db_genetic_code = 1; /* Default; it's not needed here anyway */
options->number_of_cpus = myargs[ARG_THREADS].intvalue;
if (myargs[ARG_WORDSIZE].intvalue != 0)
options->wordsize = myargs[ARG_WORDSIZE].intvalue;
if (myargs[ARG_MINSCORE].intvalue == 0)
options->cutoff_s2 = options->wordsize*options->reward;
else
options->cutoff_s2 = myargs[ARG_MINSCORE].intvalue;
options->db_length = (Int8) myargs[ARG_DBSIZE].floatvalue;
options->searchsp_eff = (Nlm_FloatHi) myargs[ARG_SEARCHSP].floatvalue;
options->perform_culling = FALSE;
/* Kludge */
options->block_width = myargs[ARG_MAXPOS].intvalue;
options->strand_option = myargs[ARG_STRAND].intvalue;
options->window_size = myargs[ARG_WINDOW].intvalue;
#ifdef DO_NOT_SUPPRESS_BLAST_OP
options->mb_template_length = myargs[ARG_TEMPL_LEN].intvalue;
if (myargs[ARG_TEMPL_LEN].intvalue != 0)
options->mb_one_base_step = (Boolean) myargs[ARG_EVERYBASE].intvalue;
options->mb_disc_type = myargs[ARG_TEMPL_TYPE].intvalue;
#endif
lcase_masking = (Boolean) myargs[ARG_LCASE].intvalue;
/* Allow dynamic programming gapped extension only with affine
gap scores */
if (options->gap_open != 0 || options->gap_extend != 0)
options->mb_use_dyn_prog = (Boolean) myargs[ARG_DYNAMIC].intvalue;
print_options = 0;
align_options = 0;
align_options += TXALIGN_COMPRESS;
align_options += TXALIGN_END_NUM;
if (show_gi) {
align_options += TXALIGN_SHOW_GI;
print_options += TXALIGN_SHOW_GI;
}
if (align_view) {
align_options += TXALIGN_MASTER;
if (align_view == 1 || align_view == 3)
align_options += TXALIGN_MISMATCH;
if (align_view == 3 || align_view == 4 || align_view == 6)
align_options += TXALIGN_FLAT_INS;
if (align_view == 5 || align_view == 6)
align_options += TXALIGN_BLUNT_END;
} else {
align_options += TXALIGN_MATRIX_VAL;
align_options += TXALIGN_SHOW_QS;
}
if (html) {
align_options += TXALIGN_HTML;
print_options += TXALIGN_HTML;
}
if (myargs[ARG_GILIST].strvalue)
options->gifile = StringSave(myargs[ARG_GILIST].strvalue);
if (out_type == MBLAST_ENDPOINTS)
options->no_traceback = 1;
else if (out_type == MBLAST_DELAYED_TRACEBACK)
options->no_traceback = 2;
else
options->no_traceback = 0;
options->megablast_full_deflines = (Boolean) myargs[ARG_FULLID].intvalue;
options->perc_identity = (FloatLo) myargs[ARG_PERC_IDENT].floatvalue;
options->hsp_num_max = myargs[ARG_MAXHSP].intvalue;
if (!believe_query)
options->megablast_full_deflines = TRUE;
/*if (options->megablast_full_deflines)
believe_query = FALSE;*/
query_bsp_array = (BioseqPtr PNTR) MemNew((MAX_NUM_QUERIES+1)*sizeof(BioseqPtr));
sepp = (SeqEntryPtr PNTR) MemNew(MAX_NUM_QUERIES*sizeof(SeqEntryPtr));
StrCpy(prefix, "");
global_fp = outfp;
options->output = outfp;
if (traditional_formatting) {
if (align_view < 7) {
if (html) {
fprintf(outfp, "<HTML>\n<TITLE>MEGABLAST Search Results</TITLE>\n");
fprintf(outfp, "<BODY BGCOLOR=\"#FFFFFF\" LINK=\"#0000FF\" "
"VLINK=\"#660099\" ALINK=\"#660099\">\n");
fprintf(outfp, "<PRE>\n");
}
init_buff_ex(90);
BlastPrintVersionInfo("mgblast", html, outfp);
fprintf(outfp, "\n");
MegaBlastPrintReference(html, 90, outfp);
fprintf(outfp, "\n");
if(!PrintDbInformation(blast_database, !db_is_na, 70, outfp, html))
return 1;
free_buff();
#ifdef OS_UNIX
fprintf(global_fp, "%s", "Searching");
#endif
}
}
aip = NULL;
if (myargs[ARG_ASNOUT].strvalue != NULL) {
if ((aip = AsnIoOpen (myargs[ARG_ASNOUT].strvalue,"w")) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", myargs[ARG_ASNOUT].strvalue);
return 1;
}
}
else if (align_view == 10 || align_view == 11)
{
const char* mode = (align_view == 10) ? "w" : "wb";
if ((aip = AsnIoOpen (blast_outputfile, (char*) mode)) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", blast_outputfile);
return 1;
}
}
if (align_view == 7) {
xml_aip = AsnIoOpen(blast_outputfile, "wx");
}
if (myargs[ARG_QUERYLOC].strvalue) {
Int4 start, end;
Megablast_GetLoc(myargs[ARG_QUERYLOC].strvalue, &start, &end);
options->required_start = start - 1;
options->required_end = end -1;
}
done = FALSE;
while (!done) {
num_bsps = 0;
total_length = 0;
done = TRUE;
SeqMgrHoldIndexing(TRUE);
mask_slp = last_mask = NULL;
while ((sepp[num_bsps]=FastaToSeqEntryForDb(infp, query_is_na, NULL,
believe_query, prefix, &ctr,
&mask_slp)) != NULL) {
if (!lcase_masking) /* Lower case ignored */
mask_slp = SeqLocFree(mask_slp);
if (mask_slp) {
if (!last_mask)
options->query_lcase_mask = last_mask = mask_slp;
else {
last_mask->next = mask_slp;
last_mask = last_mask->next;
}
mask_slp = NULL;
}
query_bsp = NULL;
SeqEntryExplore(sepp[num_bsps], &query_bsp, FindNuc);
//debug:
/*
char query_buffer[255];
SeqIdWrite(query_bsp->id, query_buffer, PRINTID_FASTA_LONG, BUFFER_LENGTH);
fprintf(stderr, "===> query_buf=%s\n", query_buffer);
*/
if (query_bsp == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "Unable to obtain bioseq\n");
return 2;
}
source = BioSourceNew();
source->org = OrgRefNew();
source->org->orgname = OrgNameNew();
source->org->orgname->gcode = options->genetic_code;
ValNodeAddPointer(&(query_bsp->descr), Seq_descr_source, source);
query_bsp_array[num_bsps++] = query_bsp;
total_length += query_bsp->length;
if (total_length > myargs[ARG_MAXQUERY].intvalue ||
num_bsps >= MAX_NUM_QUERIES) {
done = FALSE;
break;
}
}
if (num_bsps == 0)
break;
SeqMgrHoldIndexing(FALSE);
other_returns = NULL;
error_returns = NULL;
if (out_type==MBLAST_ENDPOINTS)
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options,
&other_returns, &error_returns,
dummy_callback, NULL, NULL, 0,
MegaBlastPrintEndpoints);
else if (out_type==MBLAST_SEGMENTS)
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options,
&other_returns, &error_returns,
dummy_callback, NULL, NULL, 0,
MegaBlastPrintSegments);
else if (out_type==MBLAST_ALIGN_INFO) {
/* -- Geo mod: do not print header
PrintTabularOutputHeader(blast_database,
(num_bsps==1) ? query_bsp_array[0] : NULL,
NULL, "megablast", 0, believe_query,
global_fp);*/
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options,
&other_returns, &error_returns,
dummy_callback, NULL, NULL, 0,
MegaBlastPrintAlignInfo);
} else if (out_type==MBLAST_ALIGNMENTS) {
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options, &other_returns,
&error_returns, align_view < 7 ? tick_callback : NULL,
NULL, NULL, 0, NULL);
}
#ifdef OS_UNIX
fflush(global_fp);
#endif
if (error_returns) {
BlastErrorPrint(error_returns);
for (vnp = error_returns; vnp; vnp = vnp->next) {
BlastDestroyErrorMessage((BlastErrorMsgPtr)vnp->data.ptrvalue);
}
ValNodeFree(error_returns);
}
if (traditional_formatting) {
dbinfo = NULL;
ka_params = NULL;
ka_params_gap = NULL;
params_buffer = NULL;
mask_loc = NULL;
matrix = NULL;
for (vnp=other_returns; vnp; vnp = vnp->next) {
switch (vnp->choice) {
case TXDBINFO:
dbinfo = vnp->data.ptrvalue;
break;
case TXKABLK_NOGAP:
ka_params = vnp->data.ptrvalue;
break;
case TXKABLK_GAP:
ka_params_gap = vnp->data.ptrvalue;
break;
case TXPARAMETERS:
params_buffer = vnp->data.ptrvalue;
break;
case TXMATRIX:
matrix = vnp->data.ptrvalue;
break;
case SEQLOC_MASKING_NOTSET:
case SEQLOC_MASKING_PLUS1:
case SEQLOC_MASKING_PLUS2:
case SEQLOC_MASKING_PLUS3:
case SEQLOC_MASKING_MINUS1:
case SEQLOC_MASKING_MINUS2:
case SEQLOC_MASKING_MINUS3:
ValNodeAddPointer(&mask_loc, vnp->choice, vnp->data.ptrvalue);
break;
default:
break;
}
}
#ifdef OS_UNIX
if(align_view < 7) {
fprintf(global_fp, "%s\n", " done");
}
#endif
if (myargs[ARG_MASKEDQUERY].strvalue) {
if ((mqfp = FileOpen(myargs[ARG_MASKEDQUERY].strvalue, "w")) == NULL)
ErrPostEx(SEV_WARNING, 1, 0, "Unable to open file %s for masked query\n",
myargs[ARG_MASKEDQUERY].strvalue);
}
hits_found = FALSE;
mask_loc_start = next_mask_loc = mask_loc;
mask_loc = NULL;
if (align_view == 7) {
mbxp = PSIXmlInit(xml_aip, "megablast", blast_database,
options, query_bsp_array[0], 0);
}
if (seqalign_array) { //results returned back for processing
ReadDBBioseqFetchEnable ("megablast", blast_database, db_is_na, TRUE);
for (index=0; index<num_bsps; index++) {
seqalign = seqalign_array[index];
if (next_mask_loc &&
SeqIdComp(SeqLocId((SeqLocPtr)next_mask_loc->data.ptrvalue),
query_bsp_array[index]->id) == SIC_YES) {
mask_loc = (SeqLocPtr)
MemDup(next_mask_loc, sizeof(SeqLoc));
next_mask_loc = next_mask_loc->next;
mask_loc->next = NULL;
}
if (mqfp) {
/* convert mask locations from all sources into
a single seqloc */
mask_slp = NULL;
if (mask_loc)
mask_slp = blastMergeFilterLocs(mask_slp,
(SeqLocPtr)mask_loc->data.ptrvalue,
FALSE, 0, 0);
PrintMaskedSequence(query_bsp_array[index], mask_slp,
mqfp, 50, lcase_masking);
SeqLocSetFree(mask_slp);
}
if (seqalign==NULL) {
mask_loc = MemFree(mask_loc);
continue;
}
hits_found = TRUE;
if (align_view < 7) {
init_buff_ex(70);
AcknowledgeBlastQuery(query_bsp_array[index], 70, outfp,
believe_query, html);
free_buff();
}
if (align_view == 8 || align_view == 9) {
if (align_view == 9)
PrintTabularOutputHeader(blast_database,
query_bsp_array[index], NULL, blast_program, 0,
believe_query, global_fp);
/* debug:
char qbuf[512];
strcpy(qbuf, BioseqGetTitle(query_bsp_array[index]));
fprintf(stderr, "---> Here: query title=%s\n", qbuf);
*/
BlastPrintTabulatedResults(seqalign,
query_bsp_array[index], NULL, number_of_alignments,
blast_program, !options->gapped_calculation,
believe_query, 0, 0,
global_fp, (align_view == 9));
ObjMgrFreeCache(0);
SeqAlignSetFree(seqalign);
mask_loc = MemFree(mask_loc);
continue;
}
//Geo mod:
else if (align_view>=12) {
MGBlastPrintTab(seqalign,
query_bsp_array[index], number_of_alignments,
!options->gapped_calculation,
global_fp);
ObjMgrFreeCache(0);
SeqAlignSetFree(seqalign);
mask_loc = MemFree(mask_loc);
continue;
}
else if(align_view == 7) {
IterationPtr iterp;
iterp = BXMLBuildOneQueryIteration(seqalign,
NULL, FALSE,
!options->gapped_calculation, index,
NULL, query_bsp_array[index], mask_loc);
IterationAsnWrite(iterp, mbxp->aip, mbxp->atp);
AsnIoFlush(mbxp->aip);
IterationFree(iterp);
SeqAlignSetFree(seqalign);
mask_loc = MemFree(mask_loc);
continue;
}
seqannot = SeqAnnotNew();
seqannot->type = 2;
AddAlignInfoToSeqAnnot(seqannot, align_type);
seqannot->data = seqalign;
if (aip) {
SeqAnnotAsnWrite((SeqAnnotPtr) seqannot, aip, NULL);
AsnIoReset(aip);
}
if (outfp) { /* Uncacheing causes problems with ordinal nos. vs. gi's. */
prune = BlastPruneHitsFromSeqAlign(seqalign, number_of_descriptions, NULL);
ObjMgrSetHold();
init_buff_ex(85);
PrintDefLinesFromSeqAlign(prune->sap, 80,
outfp, print_options, FIRST_PASS, NULL);
free_buff();
prune = BlastPruneHitsFromSeqAlign(seqalign, number_of_alignments, prune);
seqannot->data = prune->sap;
if (align_view != 0)
ShowTextAlignFromAnnot(seqannot, 60, outfp, NULL,
NULL, align_options, NULL,
mask_loc, NULL);
else
ShowTextAlignFromAnnot(seqannot, 60, outfp, NULL, NULL, align_options, NULL, mask_loc, FormatScoreFunc);
seqannot->data = seqalign;
prune = BlastPruneSapStructDestruct(prune);
ObjMgrClearHold();
ObjMgrFreeCache(0);
}
seqannot = SeqAnnotFree(seqannot);
mask_loc = MemFree(mask_loc);
} /* End loop on seqaligns for different queries */
ReadDBBioseqFetchDisable();
}
if (mbxp != NULL) {
MBXmlClose(mbxp, other_returns, !options->gapped_calculation);
}
if (mqfp)
FileClose(mqfp);
if (!hits_found && align_view < 7)
fprintf(outfp, "\n\n ***** No hits found ******\n\n");
matrix = BLAST_MatrixDestruct(matrix);
if(html)
fprintf(outfp, "<PRE>\n");
init_buff_ex(85);
dbinfo_head = dbinfo;
if(align_view < 7) {
while (dbinfo) {
PrintDbReport(dbinfo, 70, outfp);
dbinfo = dbinfo->next;
}
}
dbinfo_head = TxDfDbInfoDestruct(dbinfo_head);
if (ka_params) {
if(align_view < 7)
PrintKAParameters(ka_params->Lambda, ka_params->K, ka_params->H, 70, outfp, FALSE);
MemFree(ka_params);
}
if (ka_params_gap) {
if(align_view < 7)
PrintKAParameters(ka_params_gap->Lambda, ka_params_gap->K, ka_params_gap->H, 70, outfp, TRUE);
MemFree(ka_params_gap);
}
if(align_view < 7)
PrintTildeSepLines(params_buffer, 70, outfp);
MemFree(params_buffer);
free_buff();
mask_loc = mask_loc_start;
while (mask_loc) {
SeqLocSetFree(mask_loc->data.ptrvalue);
mask_loc = mask_loc->next;
}
ValNodeFree(mask_loc_start);
} else { //not traditional formatting
/* Just destruct all other_returns parts */
for (vnp=other_returns; vnp; vnp = vnp->next) {
switch (vnp->choice) {
case TXDBINFO:
TxDfDbInfoDestruct(vnp->data.ptrvalue);
break;
case TXKABLK_NOGAP:
case TXKABLK_GAP:
case TXPARAMETERS:
MemFree(vnp->data.ptrvalue);
break;
case TXMATRIX:
BLAST_MatrixDestruct(vnp->data.ptrvalue);
break;
case SEQLOC_MASKING_NOTSET:
case SEQLOC_MASKING_PLUS1:
case SEQLOC_MASKING_PLUS2:
case SEQLOC_MASKING_PLUS3:
case SEQLOC_MASKING_MINUS1:
case SEQLOC_MASKING_MINUS2:
case SEQLOC_MASKING_MINUS3:
mask_loc = vnp->data.ptrvalue;
SeqLocSetFree(mask_loc);
default:
break;
}
}
}
other_returns = ValNodeFree(other_returns);
MemFree(seqalign_array);
options->query_lcase_mask =
SeqLocSetFree(options->query_lcase_mask);
/* Freeing SeqEntries can be very expensive, do this only if
this is not the last iteration of search */
if (!done) {
for (index=0; index<num_bsps; index++) {
sepp[index] = SeqEntryFree(sepp[index]);
query_bsp_array[index] = NULL;
}
}
total_processed += num_bsps;
} /* End of loop on complete searches */
aip = AsnIoClose(aip);
/*if (align_view == 7)
xml_aip = AsnIoClose(xml_aip);*/
if (align_view < 7 && html)
fprintf(outfp, "</PRE>\n</BODY>\n</HTML>\n");
if (align_view < 7 && myargs[ARG_LOGINFO].intvalue)
fprintf(outfp, "Mega BLAST run finished, processed %d queries\n",
total_processed);
MemFree(query_bsp_array);
MemFree(sepp);
MemFree(qgaps_buf);
MemFree(dbgaps_buf);
options = BLASTOptionDelete(options);
FileClose(infp);
FileClose(outfp);
return 0;
}