static STREAM
cssp_encode_tssmartcardcreds(char *username, char *password, char *domain)
{
STREAM out, h1, h2;
struct stream tmp = { 0 };
struct stream message = { 0 };
// pin [0]
s_realloc(&tmp, strlen(password) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, password, strlen(password) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
// cspData[1]
h2 = cssp_encode_tscspdatadetail(AT_KEYEXCHANGE, g_sc_card_name, g_sc_reader_name,
g_sc_container_name, g_sc_csp_name);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 1, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
// userHint [2]
if (username && strlen(username))
{
s_realloc(&tmp, strlen(username) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, username, strlen(username) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 2, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
// domainHint [3]
if (domain && strlen(domain))
{
s_realloc(&tmp, strlen(domain) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, domain, strlen(domain) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 3, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
s_mark_end(&message);
// build message
out = ber_wrap_hdr_data(BER_TAG_SEQUENCE | BER_TAG_CONSTRUCTED, &message);
// cleanup
free(tmp.data);
free(message.data);
return out;
}
char *
hello(char *me, int encrypted)
{
int ehlo;
String *r;
char *ret, *s, *t;
if (!encrypted) {
if(trysecure > 1){
if((ret = wraptls()) != nil)
return ret;
encrypted = 1;
}
/*
* Verizon fails to print the smtp greeting banner when it
* answers a call. Send a no-op in the hope of making it
* talk.
*/
if (autistic) {
dBprint("NOOP\r\n");
getreply(); /* consume the smtp greeting */
/* next reply will be response to noop */
}
switch(getreply()){
case 2:
break;
case 5:
return Giveup;
default:
return Retry;
}
}
ehlo = 1;
Again:
if(ehlo)
dBprint("EHLO %s\r\n", me);
else
dBprint("HELO %s\r\n", me);
switch (getreply()) {
case 2:
break;
case 5:
if(ehlo){
ehlo = 0;
goto Again;
}
return Giveup;
default:
return Retry;
}
r = s_clone(reply);
if(r == nil)
return Retry; /* Out of memory or couldn't get string */
/* Invariant: every line has a newline, a result of getcrlf() */
for(s = s_to_c(r); (t = strchr(s, '\n')) != nil; s = t + 1){
*t = '\0';
for (t = s; *t != '\0'; t++)
*t = toupper(*t);
if(!encrypted && trysecure &&
(strcmp(s, "250-STARTTLS") == 0 ||
strcmp(s, "250 STARTTLS") == 0)){
s_free(r);
return dotls(me);
}
if(tryauth && (encrypted || insecure) &&
(strncmp(s, "250 AUTH", strlen("250 AUTH")) == 0 ||
strncmp(s, "250-AUTH", strlen("250 AUTH")) == 0)){
ret = doauth(s + strlen("250 AUTH "));
s_free(r);
return ret;
}
}
s_free(r);
return 0;
}
void lwqq_free_extension(LwqqClient* lc,LwqqExtension* ext)
{
ext->remove(lc, ext);
s_free(ext);
}
//detect boundary box
FLOAT *dpm_ttic_gpu_get_boxes(FLOAT **features,FLOAT *scales,int *feature_size, GPUModel *MO,
int *detected_count, FLOAT *acc_score, FLOAT thresh)
{
//constant parameters
const int max_scale = MO->MI->max_scale;
const int interval = MO->MI->interval;
const int sbin = MO->MI->sbin;
const int padx = MO->MI->padx;
const int pady = MO->MI->pady;
const int NoR = MO->RF->NoR;
const int NoP = MO->PF->NoP;
const int NoC = MO->MI->numcomponent;
const int *numpart = MO->MI->numpart;
const int LofFeat=(max_scale+interval)*NoC;
const int L_MAX = max_scale+interval;
/* for measurement */
struct timeval tv;
struct timeval tv_make_c_start, tv_make_c_end;
struct timeval tv_nucom_start, tv_nucom_end;
struct timeval tv_box_start, tv_box_end;
float time_box=0;
struct timeval tv_root_score_start, tv_root_score_end;
float time_root_score = 0;
struct timeval tv_part_score_start, tv_part_score_end;
float time_part_score = 0;
struct timeval tv_dt_start, tv_dt_end;
float time_dt = 0;
struct timeval tv_calc_a_score_start, tv_calc_a_score_end;
float time_calc_a_score = 0;
gettimeofday(&tv_make_c_start, nullptr);
int **RF_size = MO->RF->root_size;
int *rootsym = MO->RF->rootsym;
int *part_sym = MO->PF->part_sym;
int **part_size = MO->PF->part_size;
FLOAT **rootfilter = MO->RF->rootfilter;
FLOAT **partfilter=MO->PF->partfilter;
int **psize = MO->MI->psize;
int **rm_size_array = (int **)malloc(sizeof(int *)*L_MAX);
int **pm_size_array = (int **)malloc(sizeof(int *)*L_MAX);
pm_size_array = (int **)malloc(sizeof(int *)*L_MAX);
FLOAT **Tboxes=(FLOAT**)calloc(LofFeat,sizeof(FLOAT*)); //box coordinate information(Temp)
int *b_nums =(int*)calloc(LofFeat,sizeof(int)); //length of Tboxes
int count = 0;
int detected_boxes=0;
CUresult res;
/* matched score (root and part) */
FLOAT ***rootmatch,***partmatch = nullptr;
int *new_PADsize; // need new_PADsize[L_MAX*3]
size_t SUM_SIZE_feat = 0;
FLOAT **featp2 = (FLOAT **)malloc(L_MAX*sizeof(FLOAT *));
if(featp2 == nullptr) { // error semantics
printf("allocate featp2 failed\n");
exit(1);
}
/* allocate required memory for new_PADsize */
new_PADsize = (int *)malloc(L_MAX*3*sizeof(int));
if(new_PADsize == nullptr) { // error semantics
printf("allocate new_PADsize failed\n");
exit(1);
}
/* do padarray once and reuse it at calculating root and part time */
/* calculate sum of size of padded feature */
for(int tmpL=0; tmpL<L_MAX; tmpL++) {
int PADsize[3] = { feature_size[tmpL*2], feature_size[tmpL*2+1], 31 };
int NEW_Y = PADsize[0] + pady*2;
int NEW_X = PADsize[1] + padx*2;
SUM_SIZE_feat += (NEW_X*NEW_Y*PADsize[2])*sizeof(FLOAT);
}
/* allocate region for padded feat in a lump */
FLOAT *dst_feat;
res = cuMemHostAlloc((void **)&dst_feat, SUM_SIZE_feat, CU_MEMHOSTALLOC_DEVICEMAP);
if(res != CUDA_SUCCESS) {
printf("cuMemHostAlloc(dst_feat) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
memset(dst_feat, 0, SUM_SIZE_feat); // zero clear
/* distribute allocated region */
uintptr_t pointer_feat = (uintptr_t)dst_feat;
for(int tmpL=0; tmpL<L_MAX; tmpL++) {
featp2[tmpL] = (FLOAT *)pointer_feat;
int PADsize[3] = { feature_size[tmpL*2], feature_size[tmpL*2+1], 31 };
int NEW_Y = PADsize[0] + pady*2;
int NEW_X = PADsize[1] + padx*2;
pointer_feat += (uintptr_t)(NEW_X*NEW_Y*PADsize[2]*sizeof(FLOAT));
}
/* copy feat to feat2 */
for(int tmpL=0; tmpL<L_MAX; tmpL++) {
int PADsize[3] = { feature_size[tmpL*2], feature_size[tmpL*2+1], 31 };
int NEW_Y = PADsize[0] + pady*2;
int NEW_X = PADsize[1] + padx*2;
int L = NEW_Y*padx;
int SPL = PADsize[0] + pady;
int M_S = sizeof(FLOAT)*PADsize[0];
FLOAT *P = featp2[tmpL];
FLOAT *S = features[tmpL];
for(int i=0; i<PADsize[2]; i++)
{
P += L;
for(int j=0; j<PADsize[1]; j++)
{
P += pady;
memcpy(P, S, M_S);
S += PADsize[0];
P += SPL;
}
P += L;
}
new_PADsize[tmpL*3] = NEW_Y;
new_PADsize[tmpL*3 + 1] = NEW_X;
new_PADsize[tmpL*3 + 2] = PADsize[2];
}
/* do padarray once and reuse it at calculating root and part time */
/* allocation in a lump */
int *dst_rm_size = (int *)malloc(sizeof(int)*NoC*2*L_MAX);
if(dst_rm_size == nullptr) {
printf("allocate dst_rm_size failed\n");
exit(1);
}
/* distribution to rm_size_array[L_MAX] */
uintptr_t ptr = (uintptr_t)dst_rm_size;
for(int i=0; i<L_MAX; i++) {
rm_size_array[i] = (int *)ptr;
ptr += (uintptr_t)(NoC*2*sizeof(int));
}
/* allocation in a lump */
int *dst_pm_size = (int *)malloc(sizeof(int)*NoP*2*L_MAX);
if(dst_pm_size == nullptr) {
printf("allocate dst_pm_size failed\n");
exit(1);
}
/* distribution to pm_size_array[L_MAX] */
ptr = (uintptr_t)dst_pm_size;
for(int i=0; i<L_MAX; i++) {
pm_size_array[i] = (int *)ptr;
ptr += (uintptr_t)(NoP*2*sizeof(int));
}
///////level
for (int level=interval; level<L_MAX; level++) // feature's loop(A's loop) 1level 1picture
{
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
Tboxes[count]=nullptr;
count++;
continue;
}
} //for (level) // feature's loop(A's loop) 1level 1picture
///////root calculation/////////
/* calculate model score (only root) */
gettimeofday(&tv_root_score_start, nullptr);
rootmatch = fconvsMT_GPU(
featp2,
SUM_SIZE_feat,
rootfilter,
rootsym,
1,
NoR,
new_PADsize,
RF_size, rm_size_array,
L_MAX,
interval,
feature_size,
padx,
pady,
MO->MI->max_X,
MO->MI->max_Y,
ROOT
);
gettimeofday(&tv_root_score_end, nullptr);
tvsub(&tv_root_score_end, &tv_root_score_start, &tv);
time_root_score += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
///////part calculation/////////
if(NoP>0)
{
/* calculate model score (only part) */
gettimeofday(&tv_part_score_start, nullptr);
partmatch = fconvsMT_GPU(
featp2,
SUM_SIZE_feat,
partfilter,
part_sym,
1,
NoP,
new_PADsize,
part_size,
pm_size_array,
L_MAX,
interval,
feature_size,
padx,
pady,
MO->MI->max_X,
MO->MI->max_Y,
PART
);
gettimeofday(&tv_part_score_end, nullptr);
tvsub(&tv_part_score_end, &tv_part_score_start, &tv);
time_part_score += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
}
res = cuCtxSetCurrent(ctx[0]);
if(res != CUDA_SUCCESS) {
printf("cuCtxSetCurrent(ctx[0]) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
gettimeofday(&tv_make_c_end, nullptr);
gettimeofday(&tv_nucom_start, nullptr);
count = 0;
detected_boxes = 0;
int **RL_array = (int **)malloc((L_MAX-interval)*sizeof(int*));
int *dst_RL = (int *) malloc(NoC*(L_MAX-interval)*sizeof(int));
int **RI_array = (int **)malloc((L_MAX-interval)*sizeof(int*));
int *dst_RI = (int *)malloc(NoC*(L_MAX-interval)*sizeof(int));
int **OI_array = (int **)malloc((L_MAX-interval)*sizeof(int*));
int *dst_OI = (int *)malloc((NoC)*(L_MAX-interval)*sizeof(int));
int **RL_S_array = (int **)malloc((L_MAX-interval)*sizeof(int*));
int *dst_RL_S = (int *)malloc(NoC*(L_MAX-interval)*sizeof(int));
FLOAT **OFF_array = (FLOAT **)malloc((L_MAX-interval)*sizeof(FLOAT*));
FLOAT *dst_OFF = (FLOAT *)malloc(NoC*(L_MAX-interval)*sizeof(FLOAT));
FLOAT ***SCORE_array = (FLOAT ***)malloc((L_MAX-interval)*sizeof(FLOAT **));
FLOAT **sub_dst_SCORE = (FLOAT **)malloc(NoC*(L_MAX-interval)*sizeof(FLOAT*));
uintptr_t pointer_RL = (uintptr_t)dst_RL;
uintptr_t pointer_RI = (uintptr_t)dst_RI;
uintptr_t pointer_OI = (uintptr_t)dst_OI;
uintptr_t pointer_RL_S = (uintptr_t)dst_RL_S;
uintptr_t pointer_OFF = (uintptr_t)dst_OFF;
uintptr_t pointer_SCORE = (uintptr_t)sub_dst_SCORE;
for (int level=interval; level<L_MAX; level++) {
int L=level-interval;
RL_array[L] = (int *)pointer_RL;
pointer_RL += (uintptr_t)NoC*sizeof(int);
RI_array[L] = (int *)pointer_RI;
pointer_RI += (uintptr_t)NoC*sizeof(int);
OI_array[L] = (int *)pointer_OI;
pointer_OI += (uintptr_t)NoC*sizeof(int);
RL_S_array[L] = (int *)pointer_RL_S;
pointer_RL_S += (uintptr_t)NoC*sizeof(int);
OFF_array[L] = (FLOAT *)pointer_OFF;
pointer_OFF += (uintptr_t)NoC*sizeof(FLOAT);
SCORE_array[L] = (FLOAT **)pointer_SCORE;
pointer_SCORE += (uintptr_t)NoC*sizeof(FLOAT*);
}
int sum_RL_S = 0;
int sum_SNJ = 0;
/* prepare for parallel execution */
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
/* root score + offset */
RL_array[L][j] = rm_size_array[level][j*2]*rm_size_array[level][j*2+1]; //length of root-matching
RI_array[L][j] = MO->MI->ridx[j]; //root-index
OI_array[L][j] = MO->MI->oidx[j]; //offset-index
RL_S_array[L][j] =sizeof(FLOAT)*RL_array[L][j];
OFF_array[L][j] = MO->MI->offw[RI_array[L][j]]; //offset information
/* search max values */
max_RL_S = (max_RL_S < RL_S_array[L][j]) ? RL_S_array[L][j] : max_RL_S;
max_numpart = (max_numpart < numpart[j]) ? numpart[j] : max_numpart;
}
}
sum_RL_S = max_RL_S*NoC*(L_MAX-interval);
/* root matching size */
sum_SNJ = sizeof(int*)*max_numpart*NoC*(L_MAX-interval);
/* consolidated allocation for SCORE_array and distribute region */
FLOAT *dst_SCORE = (FLOAT *)malloc(sum_RL_S);
pointer_SCORE = (uintptr_t)dst_SCORE;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
SCORE_array[L][j] = (FLOAT *)pointer_SCORE;
pointer_SCORE += (uintptr_t)max_RL_S;
}
}
/* add offset */
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
memcpy(SCORE_array[L][j], rootmatch[level][j], RL_S_array[L][j]);
FLOAT *SC_S = SCORE_array[L][j];
FLOAT *SC_E = SCORE_array[L][j]+RL_array[L][j];
while(SC_S<SC_E) *(SC_S++)+=OFF_array[L][j];
}
}
/* anchor matrix */ // consolidated allocation
int ***ax_array = (int ***)malloc((L_MAX-interval)*sizeof(int **));
int **sub_dst_ax = (int **)malloc(NoC*(L_MAX-interval)*sizeof(int *));
int *dst_ax = (int *)malloc(sum_SNJ);
int ***ay_array = (int ***)malloc((L_MAX-interval)*sizeof(int **));
int **sub_dst_ay = (int **)malloc(NoC*(L_MAX-interval)*sizeof(int *));
int *dst_ay = (int *)malloc(sum_SNJ);
/* boudary index */ // consolidated allocation
int ****Ix_array =(int ****)malloc((L_MAX-interval)*sizeof(int ***));
int ***sub_dst_Ix = (int ***)malloc(NoC*(L_MAX-interval)*sizeof(int **));
int **dst_Ix = (int **)malloc(sum_SNJ);
int ****Iy_array = (int ****)malloc((L_MAX-interval)*sizeof(int ***));
int ***sub_dst_Iy = (int ***)malloc(NoC*(L_MAX-interval)*sizeof(int **));
int **dst_Iy = (int **)malloc(sum_SNJ);
/* distribute region */
uintptr_t pointer_ax = (uintptr_t)sub_dst_ax;
uintptr_t pointer_ay = (uintptr_t)sub_dst_ay;
uintptr_t pointer_Ix = (uintptr_t)sub_dst_Ix;
uintptr_t pointer_Iy = (uintptr_t)sub_dst_Iy;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
ax_array[L] = (int **)pointer_ax;
pointer_ax += (uintptr_t)(NoC*sizeof(int*));
ay_array[L] = (int **)pointer_ay;
pointer_ay += (uintptr_t)(NoC*sizeof(int*));
Ix_array[L] = (int ***)pointer_Ix;
pointer_Ix += (uintptr_t)(NoC*sizeof(int**));
Iy_array[L] = (int ***)pointer_Iy;
pointer_Iy += (uintptr_t)(NoC*sizeof(int**));
}
pointer_ax = (uintptr_t)dst_ax;
pointer_ay = (uintptr_t)dst_ay;
pointer_Ix = (uintptr_t)dst_Ix;
pointer_Iy = (uintptr_t)dst_Iy;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
uintptr_t pointer_offset = sizeof(int*)*max_numpart;
ax_array[L][j] = (int *)pointer_ax;
pointer_ax += pointer_offset;
ay_array[L][j] = (int *)pointer_ay;
pointer_ay += pointer_offset;
Ix_array[L][j] = (int **)pointer_Ix;
pointer_Ix += pointer_offset;
Iy_array[L][j] = (int **)pointer_Iy;
pointer_Iy += pointer_offset;
}
}
/* add parts */
if(NoP>0)
{
/* arrays to store temporary loop variables */
int tmp_array_size = 0;
for(int level=interval; level<L_MAX; level++) {
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
tmp_array_size += max_numpart*sizeof(int);
}
}
int ***DIDX_array = (int ***)malloc((L_MAX-interval)*sizeof(int**));
int **sub_dst_DIDX = (int **)malloc(NoC*(L_MAX-interval)*sizeof(int*));
int *dst_DIDX = (int *)malloc(tmp_array_size);
int ***DID_4_array = (int ***)malloc((L_MAX-interval)*sizeof(int **));
int **sub_dst_DID_4 = (int **)malloc(NoC*(L_MAX-interval)*sizeof(int*));
int *dst_DID_4;
res = cuMemHostAlloc((void **)&dst_DID_4, tmp_array_size, CU_MEMHOSTALLOC_DEVICEMAP);
if(res != CUDA_SUCCESS) {
printf("cuMemHostAlloc(dst_DID_4) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
int ***PIDX_array = (int ***)malloc((L_MAX-interval)*sizeof(int **));
int **sub_dst_PIDX = (int **)malloc(NoC*(L_MAX-interval)*sizeof(int*));
int *dst_PIDX;
res = cuMemHostAlloc((void **)&dst_PIDX, tmp_array_size, CU_MEMHOSTALLOC_DEVICEMAP);
if(res != CUDA_SUCCESS) {
printf("cuMemHostAlloc(dst_PIDX) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
/* distribute consolidated region */
uintptr_t pointer_DIDX = (uintptr_t)sub_dst_DIDX;
uintptr_t pointer_DID_4 = (uintptr_t)sub_dst_DID_4;
uintptr_t pointer_PIDX = (uintptr_t)sub_dst_PIDX;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
DIDX_array[L] = (int **)pointer_DIDX;
pointer_DIDX += (uintptr_t)(NoC*sizeof(int*));
DID_4_array[L] = (int **)pointer_DID_4;
pointer_DID_4 += (uintptr_t)(NoC*sizeof(int*));
PIDX_array[L] = (int **)pointer_PIDX;
pointer_PIDX += (uintptr_t)(NoC*sizeof(int*));
}
pointer_DIDX = (uintptr_t)dst_DIDX;
pointer_DID_4 = (uintptr_t)dst_DID_4;
pointer_PIDX = (uintptr_t)dst_PIDX;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X)) {
continue;
}
for(int j=0; j<NoC; j++) {
uintptr_t pointer_offset = (uintptr_t)(max_numpart*sizeof(int));
DIDX_array[L][j] = (int *)pointer_DIDX;
pointer_DIDX += pointer_offset;
DID_4_array[L][j] = (int *)pointer_DID_4;
pointer_DID_4 += pointer_offset;
PIDX_array[L][j] = (int *)pointer_PIDX;
pointer_PIDX += pointer_offset;
}
}
/* prepare for parallel execution */
int sum_size_index_matrix = 0;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X)) {
continue;
}
for(int j=0; j<NoC; j++) {
for (int k=0;k<numpart[j];k++) {
/* assign values to each element */
DIDX_array[L][j][k] = MO->MI->didx[j][k];
DID_4_array[L][j][k] = DIDX_array[L][j][k]*4;
PIDX_array[L][j][k] = MO->MI->pidx[j][k];
/* anchor */
ax_array[L][j][k] = MO->MI->anchor[DIDX_array[L][j][k]*2]+1;
ay_array[L][j][k] = MO->MI->anchor[DIDX_array[L][j][k]*2+1]+1;
int PSSIZE[2] ={pm_size_array[L][PIDX_array[L][j][k]*2], pm_size_array[L][PIDX_array[L][j][k]*2+1]}; // size of C
/* index matrix */
sum_size_index_matrix += sizeof(int)*PSSIZE[0]*PSSIZE[1];
}
}
}
int *dst_Ix_kk = (int *)malloc(sum_size_index_matrix);
int *dst_Iy_kk = (int *)malloc(sum_size_index_matrix);
uintptr_t pointer_Ix_kk = (uintptr_t)dst_Ix_kk;
uintptr_t pointer_Iy_kk = (uintptr_t)dst_Iy_kk;
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
for (int k=0;k<numpart[j];k++) {
int PSSIZE[2] ={pm_size_array[L][PIDX_array[L][j][k]*2], pm_size_array[L][PIDX_array[L][j][k]*2+1]}; // size of C
Ix_array[L][j][k] = (int *)pointer_Ix_kk;
Iy_array[L][j][k] = (int *)pointer_Iy_kk;
pointer_Ix_kk += (uintptr_t)(sizeof(int)*PSSIZE[0]*PSSIZE[1]);
pointer_Iy_kk += (uintptr_t)(sizeof(int)*PSSIZE[0]*PSSIZE[1]);
}
}
}
gettimeofday(&tv_dt_start, nullptr);
FLOAT ****M_array = dt_GPU(
Ix_array, // int ****Ix_array
Iy_array, // int ****Iy_array
PIDX_array, // int ***PIDX_array
pm_size_array, // int **size_array
NoP, // int NoP
numpart, // int *numpart
NoC, // int NoC
interval, // int interval
L_MAX, // int L_MAX
feature_size, // int *feature_size,
padx, // int padx,
pady, // int pady,
MO->MI->max_X, // int max_X
MO->MI->max_Y, // int max_Y
MO->MI->def, // FLOAT *def
tmp_array_size, // int tmp_array_size
dst_PIDX, // int *dst_PIDX
dst_DID_4 // int *DID_4
);
gettimeofday(&tv_dt_end, nullptr);
tvsub(&tv_dt_end, &tv_dt_start, &tv);
time_dt += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
/* add part score */
for(int level=interval; level<L_MAX; level++){
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
continue;
}
for(int j=0; j<NoC; j++) {
for(int k=0; k<numpart[j]; k++) {
int PSSIZE[2] ={pm_size_array[L][PIDX_array[L][j][k]*2],
pm_size_array[L][PIDX_array[L][j][k]*2+1]}; // Size of C
int R_S[2]={rm_size_array[level][j*2], rm_size_array[level][j*2+1]};
dpm_ttic_add_part_calculation(SCORE_array[L][j], M_array[L][j][k], R_S,
PSSIZE, ax_array[L][j][k], ay_array[L][j][k]);
}
}
}
s_free(M_array[0][0][0]);
s_free(M_array[0][0]);
s_free(M_array[0]);
s_free(M_array);
/* free temporary arrays */
free(dst_DIDX);
free(sub_dst_DIDX);
free(DIDX_array);
res = cuMemFreeHost(dst_DID_4);
if(res != CUDA_SUCCESS) {
printf("cuMemFreeHost(dst_DID_4) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
free(sub_dst_DID_4);
free(DID_4_array);
res = cuMemFreeHost(dst_PIDX);
if(res != CUDA_SUCCESS) {
printf("cuMemFreeHost(dst_PIDX) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
free(sub_dst_PIDX);
free(PIDX_array);
res = cuCtxSetCurrent(ctx[0]);
if(res != CUDA_SUCCESS) {
printf("cuCtxSetCurrent(ctx[0]) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
} // start from if(NoP>0)
/* combine root and part score and detect boundary box for each-component */
FLOAT *scale_array = (FLOAT *)malloc((L_MAX-interval)*sizeof(FLOAT));
for(int level=interval; level<L_MAX; level++) {
int L = level - interval;
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X))
{
Tboxes[count]=nullptr;
count++;
continue;
}
scale_array[L] = (FLOAT)sbin/scales[level];
}
for (int level=interval; level<L_MAX; level++) // feature's loop(A's loop) 1level 1picture
{
/* parameters (related for level) */
int L=level-interval;
/* matched score size matrix */
FLOAT scale=(FLOAT)sbin/scales[level];
/* loop conditon */
if(feature_size[level*2]+2*pady<MO->MI->max_Y ||(feature_size[level*2+1]+2*padx<MO->MI->max_X)) {
Tboxes[count]=nullptr;
count++;
continue;
}
/* calculate accumulated score */
gettimeofday(&tv_calc_a_score_start, nullptr);
calc_a_score_GPU(
acc_score, // FLOAT *ac_score
SCORE_array[L], // FLOAT **score
rm_size_array[level], // int *ssize_start
MO->MI, // Model_info *MI
scale, // FLOAT scale
RL_S_array[L], // int *size_score_array
NoC // int NoC
);
gettimeofday(&tv_calc_a_score_end, nullptr);
tvsub(&tv_calc_a_score_end, &tv_calc_a_score_start, &tv);
time_calc_a_score += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
for(int j = 0; j <NoC; j++) {
int R_S[2]={rm_size_array[level][j*2], rm_size_array[level][j*2+1]};
/* get all good matches */
int GMN;
int *GMPC = get_gmpc(SCORE_array[L][j],thresh,R_S,&GMN);
int RSIZE[2]={MO->MI->rsize[j*2], MO->MI->rsize[j*2+1]};
int GL = (numpart[j]+1)*4+3; //31
/* detected box coordinate(current level) */
FLOAT *t_boxes = (FLOAT*)calloc(GMN*GL,sizeof(FLOAT));
gettimeofday(&tv_box_start, nullptr);
// NO NEED TO USE GPU
for(int k = 0;k < GMN;k++) {
FLOAT *P_temp = t_boxes+GL*k;
int y = GMPC[2*k];
int x = GMPC[2*k+1];
/* calculate root box coordinate */
FLOAT *RB =rootbox(x,y,scale,padx,pady,RSIZE);
memcpy(P_temp, RB,sizeof(FLOAT)*4);
s_free(RB);
P_temp+=4;
for(int pp=0;pp<numpart[j];pp++) {
int PBSIZE[2]={psize[j][pp*2], psize[j][pp*2+1]};
int Isize[2]={pm_size_array[L][MO->MI->pidx[j][pp]*2], pm_size_array[L][MO->MI->pidx[j][pp]*2+1]};
/* calculate part box coordinate */
FLOAT *PB = partbox(x,y,ax_array[L][j][pp],ay_array[L][j][pp],scale,padx,pady,PBSIZE,Ix_array[L][j][pp],Iy_array[L][j][pp],Isize);
memcpy(P_temp, PB,sizeof(FLOAT)*4);
P_temp+=4;
s_free(PB);
}
/* component number and score */
*(P_temp++)=(FLOAT)j; //component number
*(P_temp++)=SCORE_array[L][j][x*R_S[0]+y]; //score of good match
*P_temp = scale;
}
// NO NEED TO USE GPU
gettimeofday(&tv_box_end, nullptr);
tvsub(&tv_box_end, &tv_box_start, &tv);
time_box += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
/* save box information */
if (GMN > 0)
Tboxes[count] = t_boxes;
else
Tboxes[count] = nullptr;
b_nums[count]=GMN;
count++;
detected_boxes+=GMN; //number of detected box
/* release */
s_free(GMPC);
}
////numcom
}
////level
/* free temporary arrays */
free(dst_RL);
free(RL_array);
free(dst_RI);
free(RI_array);
free(dst_OI);
free(OI_array);
free(dst_RL_S);
free(RL_S_array);
free(dst_OFF);
free(OFF_array);
free(dst_SCORE);
free(sub_dst_SCORE);
free(SCORE_array);
free(dst_ax);
free(sub_dst_ax);
free(ax_array);
free(dst_ay);
free(sub_dst_ay);
free(ay_array);
free(Ix_array[0][0][0]);
free(dst_Ix);
free(sub_dst_Ix);
free(Ix_array);
free(Iy_array[0][0][0]);
free(dst_Iy);
free(sub_dst_Iy);
free(Iy_array);
free(scale_array);
gettimeofday(&tv_nucom_end, nullptr);
#ifdef PRINT_INFO
printf("root SCORE : %f\n", time_root_score);
printf("part SCORE : %f\n", time_part_score);
printf("dt : %f\n", time_dt);
printf("calc_a_score : %f\n", time_calc_a_score);
#endif
res = cuCtxSetCurrent(ctx[0]);
if(res != CUDA_SUCCESS) {
printf("cuCtxSetCurrent(ctx[0]) failed: res = %s\n",cuda_response_to_string(res));
exit(1);
}
/* free memory regions */
res = cuMemFreeHost((void *)featp2[0]);
if(res != CUDA_SUCCESS) {
printf("cuMemFreeHost(featp2[0]) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
s_free(featp2);
res = cuMemFreeHost((void *)rootmatch[interval][0]);
if(res != CUDA_SUCCESS) {
printf("cuMemFreeHost(rootmatch[0][0]) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
s_free(rootmatch[0]);
s_free(rootmatch);
if (partmatch != nullptr) {
res = cuMemFreeHost((void *)partmatch[0][0]);
if(res != CUDA_SUCCESS) {
printf("cuMemFreeHost(partmatch[0][0]) failed: res = %s\n", cuda_response_to_string(res));
exit(1);
}
s_free(partmatch[0]);
s_free(partmatch);
s_free(new_PADsize);
}
/* release */
s_free(rm_size_array[0]);
s_free(rm_size_array);
s_free(pm_size_array[0]);
s_free(pm_size_array);
/* Output boundary-box coorinate information */
int GL=(numpart[0]+1)*4+3;
FLOAT *boxes=(FLOAT*)calloc(detected_boxes*GL,sizeof(FLOAT)); //box coordinate information(Temp)
FLOAT *T1 = boxes;
for(int i = 0; i < LofFeat; i++) {
int num_t = b_nums[i]*GL;
if(num_t > 0) {
FLOAT *T2 = Tboxes[i];
//memcpy_s(T1,sizeof(FLOAT)*num_t,T2,sizeof(FLOAT)*num_t);
memcpy(T1, T2,sizeof(FLOAT)*num_t);
T1 += num_t;
}
}
FLOAT abs_threshold = abs(thresh);
/* accumulated score calculation */
FLOAT max_score = 0.0;
/* add offset to accumulated score */
for(int i = 0; i < MO->MI->IM_HEIGHT*MO->MI->IM_WIDTH; i++) {
if (acc_score[i] < thresh) {
acc_score[i] = 0.0;
} else {
acc_score[i] += abs_threshold;
if (acc_score[i] > max_score)
max_score = acc_score[i];
}
}
/* normalization */
if (max_score > 0.0) {
FLOAT ac_ratio = 1.0 / max_score;
for (int i = 0; i < MO->MI->IM_HEIGHT*MO->MI->IM_WIDTH; i++) {
acc_score[i] *= ac_ratio;
}
}
/* release */
free_boxes(Tboxes,LofFeat);
s_free(b_nums);
/* output result */
*detected_count = detected_boxes;
return boxes;
}
int main(int argc, char **argv)
{
population *pop=NULL; /* Population of solutions. */
char *filename_in=NULL; /* Input filename. */
char *filename_out=NULL; /* Output filename. */
int i; /* Loop variable over command-line arguments. */
int generations=10; /* Number of generations to perform. */
char *beststring=NULL; /* Human readable form of best solution. */
size_t beststrlen=0; /* Length of beststring. */
random_seed(42);
/*
* Parse command-line. Expect '-i FILENAME' for a population to read,
* otherwise a new population will be created.
* '-o FILENAME' is absolutely required to specify a file to write to.
* If we don't get these, then we will write the options.
*/
if (argc<2)
{
write_usage();
exit(0);
}
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "-i")==0)
{ /* Read pop. */
i++;
if (i==argc)
{
printf("Input filename not specified.\n");
write_usage();
exit(0);
}
filename_in = argv[i];
printf("Input filename set to \"%s\"\n", filename_in);
}
else if (strcmp(argv[i], "-o")==0)
{ /* Out pop. */
i++;
if (i==argc)
{
printf("Output filename not specified.\n");
write_usage();
exit(0);
}
filename_out = argv[i];
printf("Output filename set to \"%s\"\n", filename_out);
}
else if (strcmp(argv[i], "-n")==0)
{ /* Number of generations requested. */
i++;
if (i==argc)
{
printf("Number of generations not specified.\n");
write_usage();
exit(0);
}
generations = atoi(argv[i]);
printf("Number of generations set to %d.\n", generations);
}
else
{ /* Error parsing args. */
printf("Unable to parse command-line argument \"%s\"\n", argv[i]);
write_usage();
exit(0);
}
}
/*
* Check that we had the required inputs.
*/
if (filename_out == NULL)
{
printf("No output filename was specified.\n");
write_usage();
exit(0);
}
/*
* Read or create population.
*/
if (filename_in == NULL)
{
pop = ga_genesis_char(
40, /* const int population_size */
1, /* const int num_chromo */
strlen(target_text), /* const int len_chromo */
NULL, /* GAgeneration_hook generation_hook */
NULL, /* GAiteration_hook iteration_hook */
NULL, /* GAdata_destructor data_destructor */
NULL, /* GAdata_ref_incrementor data_ref_incrementor */
struggle_score, /* GAevaluate evaluate */
ga_seed_printable_random, /* GAseed seed */
NULL, /* GAadapt adapt */
ga_select_one_roulette, /* GAselect_one select_one */
ga_select_two_roulette, /* GAselect_two select_two */
ga_mutate_printable_singlepoint_drift, /* GAmutate mutate */
ga_crossover_char_allele_mixing, /* GAcrossover crossover */
NULL, /* GAreplace replace */
NULL /* vpointer User data */
);
ga_population_set_parameters(
pop, /* population *pop */
GA_SCHEME_DARWIN, /* const ga_scheme_type scheme */
GA_ELITISM_PARENTS_SURVIVE, /* const ga_elitism_type elitism */
1.0, /* double crossover */
0.1, /* double mutation */
0.0 /* double migration */
);
}
else
{
pop = ga_population_read(filename_in);
pop->evaluate = struggle_score; /* Custom functions can't be saved and
* therefore "pop->evaluate" must be
* defined manually. Likewise, if a
* custom crossover routine was used, for
* example, then that would also need
* to be manually defined here.
*/
}
ga_evolution(
pop, /* population *pop */
generations /* const int max_generations */
);
printf("The final solution with seed = %d was:\n", i);
beststring = ga_chromosome_char_to_string(pop, ga_get_entity_from_rank(pop,0), beststring, &beststrlen);
printf("%s\n", beststring);
printf("With score = %f\n", ga_entity_get_fitness(ga_get_entity_from_rank(pop,0)) );
ga_population_write(pop, filename_out);
printf("Population has been saved as \"%s\"\n", filename_out);
ga_extinction(pop);
s_free(beststring);
exit(EXIT_SUCCESS);
}
/**
* Set online status, this is the last step of login
*
* @param err
* @param lc
*/
static void set_online_status(LwqqClient *lc, char *status, LwqqErrorCode *err)
{
char msg[1024] ={0};
char *buf;
LwqqHttpRequest *req = NULL;
char *response = NULL;
char *cookies;
int ret;
json_t *json = NULL;
char *value;
if (!status || !err) {
goto done ;
}
lc->clientid = generate_clientid();
if (!lc->clientid) {
lwqq_log(LOG_ERROR, "Generate clientid error\n");
*err = LWQQ_EC_ERROR;
goto done ;
}
snprintf(msg, sizeof(msg), "{\"status\":\"%s\",\"ptwebqq\":\"%s\","
"\"passwd_sig\":""\"\",\"clientid\":\"%s\""
", \"psessionid\":null}"
,status, lc->cookies->ptwebqq
,lc->clientid);
buf = url_encode(msg);
snprintf(msg, sizeof(msg), "r=%s", buf);
s_free(buf);
/* Create a POST request */
req = lwqq_http_create_default_request(LWQQ_URL_SET_STATUS, err);
if (!req) {
goto done;
}
/* Set header needed by server */
req->set_header(req, "Cookie2", "$Version=1");
req->set_header(req, "Referer", "http://d.web2.qq.com/proxy.html?v=20101025002");
req->set_header(req, "Content-type", "application/x-www-form-urlencoded");
/* Set http cookie */
cookies = lwqq_get_cookies(lc);
if (cookies) {
req->set_header(req, "Cookie", cookies);
s_free(cookies);
}
ret = req->do_request(req, 1, msg);
if (ret) {
*err = LWQQ_EC_NETWORK_ERROR;
goto done;
}
if (req->http_code != 200) {
*err = LWQQ_EC_HTTP_ERROR;
goto done;
}
/**
* Here, we got a json object like this:
* {"retcode":0,"result":{"uin":1421032531,"cip":2013211875,"index":1060,"port":43415,"status":"online","vfwebqq":"e7ce7913336ad0d28de9cdb9b46a57e4a6127161e35b87d09486001870226ec1fca4c2ba31c025c7","psessionid":"8368046764001e636f6e6e7365727665725f77656271714031302e3133332e34312e32303200006b2900001544016e0400533cb3546d0000000a4046674d4652585136496d00000028e7ce7913336ad0d28de9cdb9b46a57e4a6127161e35b87d09486001870226ec1fca4c2ba31c025c7","user_state":0,"f":0}}
*
*/
response = req->response;
ret = json_parse_document(&json, response);
if (ret != JSON_OK) {
*err = LWQQ_EC_ERROR;
goto done;
}
if (!(value = json_parse_simple_value(json, "retcode"))) {
*err = LWQQ_EC_ERROR;
goto done;
}
/**
* Do we need parse "seskey? from kernelhcy's code, we need it,
* but from the response we got like above, we dont need
*
*/
if ((value = json_parse_simple_value(json, "seskey"))) {
lc->seskey = s_strdup(value);
}
if ((value = json_parse_simple_value(json, "cip"))) {
lc->cip = s_strdup(value);
}
if ((value = json_parse_simple_value(json, "index"))) {
lc->index = s_strdup(value);
}
if ((value = json_parse_simple_value(json, "port"))) {
lc->port = s_strdup(value);
}
if ((value = json_parse_simple_value(json, "status"))) {
/* This really need? */
lc->status = s_strdup(value);
}
if ((value = json_parse_simple_value(json, "vfwebqq"))) {
lc->vfwebqq = s_strdup(value);
}
if ((value = json_parse_simple_value(json, "psessionid"))) {
lc->psessionid = s_strdup(value);
}
*err = LWQQ_EC_OK;
done:
if (json)
json_free_value(&json);
lwqq_http_request_free(req);
}
/*
* change to a remote directory.
*/
int
changedir(Node *node)
{
Node *to;
String *cdpath;
to = node;
if(to == remdir)
return 0;
/* build an absolute path */
switch(os){
case Tops:
case VM:
switch(node->depth){
case 0:
remdir = node;
return 0;
case 1:
cdpath = s_clone(node->remname);
break;
default:
return seterr(nosuchfile);
}
break;
case VMS:
switch(node->depth){
case 0:
remdir = node;
return 0;
default:
cdpath = s_new();
vmspath(node, cdpath);
}
break;
case MVS:
if(node->depth == 0)
cdpath = s_clone(remrootpath);
else{
cdpath = s_new();
mvspath(node, cdpath);
}
break;
default:
if(node->depth == 0)
cdpath = s_clone(remrootpath);
else{
cdpath = s_new();
unixpath(node, cdpath);
}
break;
}
uncachedir(remdir, 0);
/*
* connect, if we need a password (Incomplete)
* act like it worked (best we can do).
*/
sendrequest("CWD", s_to_c(cdpath));
s_free(cdpath);
switch(getreply(&ctlin, msg, sizeof(msg), 0)){
case Success:
case Incomplete:
remdir = node;
return 0;
default:
return seterr(nosuchfile);
}
}
int main(int argc, char **argv)
{
population *popd=NULL; /* Population for Darwinian evolution. */
population *popb=NULL; /* Population for Baldwinian evolution. */
population *popl=NULL; /* Population for Lamarckian evolution. */
char *beststring=NULL; /* Human readable form of best solution. */
size_t beststrlen=0; /* Length of beststring. */
random_seed(23091975);
popd = ga_genesis_char(
150, /* const int population_size */
1, /* const int num_chromo */
(int) strlen(target_text), /* const int len_chromo */
NULL, /* GAgeneration_hook generation_hook */
NULL, /* GAiteration_hook iteration_hook */
NULL, /* GAdata_destructor data_destructor */
NULL, /* GAdata_ref_incrementor data_ref_incrementor */
struggle_score, /* GAevaluate evaluate */
ga_seed_printable_random, /* GAseed seed */
struggle_adaptation, /* GAadapt adapt */
ga_select_one_sus, /* GAselect_one select_one */
ga_select_two_sus, /* GAselect_two select_two */
ga_mutate_printable_singlepoint_drift, /* GAmutate mutate */
ga_crossover_char_allele_mixing, /* GAcrossover crossover */
NULL, /* GAreplace replace */
NULL /* vpointer User data */
);
ga_population_set_parameters(
popd, /* population *pop */
GA_SCHEME_DARWIN, /* const ga_scheme_type scheme */
GA_ELITISM_PARENTS_DIE, /* const ga_elitism_type elitism */
0.9, /* const double crossover */
0.1, /* const double mutation */
0.0 /* const double migration */
);
/*
* Make exact copies of the populations, except modify
* their evolutionary schemes.
*/
popb = ga_population_clone(popd);
ga_population_set_scheme(popb, GA_SCHEME_BALDWIN_CHILDREN);
popl = ga_population_clone(popd);
ga_population_set_scheme(popl, GA_SCHEME_LAMARCK_CHILDREN);
/*
* Evolve each population in turn.
*/
ga_evolution(
popd, /* population *pop */
600 /* const int max_generations */
);
printf( "The final solution with Darwinian evolution with score %f was:\n",
ga_get_entity_from_rank(popd,0)->fitness );
beststring = ga_chromosome_char_to_string(popd, ga_get_entity_from_rank(popd,0), beststring, &beststrlen);
printf("%s\n", beststring);
ga_evolution(
popb, /* population *pop */
300 /* const int max_generations */
);
printf( "The final solution with Baldwinian evolution with score %f was:\n",
ga_get_entity_from_rank(popb,0)->fitness );
beststring = ga_chromosome_char_to_string(popb, ga_get_entity_from_rank(popb,0), beststring, &beststrlen);
printf("%s\n", beststring);
ga_evolution(
popl, /* population *pop */
300 /* const int max_generations */
);
printf( "The final solution with Lamarckian evolution with score %f was:\n",
ga_get_entity_from_rank(popl,0)->fitness );
beststring = ga_chromosome_char_to_string(popl, ga_get_entity_from_rank(popl,0), beststring, &beststrlen);
printf("%s\n", beststring);
/* Deallocate population structures. */
ga_extinction(popd);
ga_extinction(popb);
ga_extinction(popl);
/* Deallocate string buffer. */
s_free(beststring);
exit(EXIT_SUCCESS);
}
/*
Function: iUtlSignalsIgnoreHandler()
Purpose: To set the signal handler to 'ignore', and optionally
recover the current signal handler
Parameters: iSignal signal
ppsaSigAction return pointer for the current
signal action (optional)
Globals: none
Returns: UTL error code
*/
int iUtlSignalsIgnoreHandler
(
int iSignal,
struct sigaction **ppsaSigAction
)
{
int iError = UTL_NoError;
struct sigaction *psaSigAction = NULL;
struct sigaction saSigAction;
sigset_t ssSigSet;
/* Clear the structures */
s_memset(&ssSigSet, 0, sizeof(sigset_t));
s_memset(&saSigAction, 0, sizeof(struct sigaction));
/* Set the structure fields */
saSigAction.sa_handler = SIG_IGN;
saSigAction.sa_mask = ssSigSet;
saSigAction.sa_flags = SA_RESTART;
/* Allocate space for the signal action structure if the return pointer is passed */
if ( ppsaSigAction != NULL ) {
if ( (psaSigAction = (struct sigaction *)s_malloc(sizeof(struct sigaction))) == NULL ) {
iError = UTL_MemError;
goto bailFromiSignalsIgnoreHandler;
}
}
/* Install the signal action */
if ( s_sigaction(iSignal, &saSigAction, psaSigAction) != 0 ) {
iError = UTL_SignalActionInstallFailed;
goto bailFromiSignalsIgnoreHandler;
}
/* Bail label */
bailFromiSignalsIgnoreHandler:
/* Handle the error */
if ( iError == UTL_NoError ) {
/* Set the return pointer if it was passed */
if ( ppsaSigAction != NULL ) {
*ppsaSigAction = psaSigAction;
}
}
else {
/* Free allocations */
s_free(psaSigAction);
}
return (iError);
}
//
// read in the mailbox and parse into messages.
//
static char*
_readmbox(Mailbox *mb, int doplumb, Mlock *lk)
{
int fd, n;
String *tmp;
Dir *d;
static char err[128];
Message *m, **l;
Inbuf *inb;
char *x;
l = &mb->root->part;
/*
* open the mailbox. If it doesn't exist, try the temporary one.
*/
n = 0;
retry:
fd = open(mb->path, OREAD);
if(fd < 0){
rerrstr(err, sizeof(err));
if(strstr(err, "exclusive lock") != 0 && n++ < 20){
sleep(500); /* wait for lock to go away */
goto retry;
}
if(strstr(err, "exist") != 0){
tmp = s_copy(mb->path);
s_append(tmp, ".tmp");
if(sysrename(s_to_c(tmp), mb->path) == 0){
s_free(tmp);
goto retry;
}
s_free(tmp);
}
return err;
}
/*
* a new qid.path means reread the mailbox, while
* a new qid.vers means read any new messages
*/
d = dirfstat(fd);
if(d == nil){
close(fd);
errstr(err, sizeof(err));
return err;
}
if(mb->d != nil){
if(d->qid.path == mb->d->qid.path && d->qid.vers == mb->d->qid.vers){
close(fd);
free(d);
return nil;
}
if(d->qid.path == mb->d->qid.path){
while(*l != nil)
l = &(*l)->next;
seek(fd, mb->d->length, 0);
}
free(mb->d);
}
mb->d = d;
mb->vers++;
henter(PATH(0, Qtop), mb->name,
(Qid){PATH(mb->id, Qmbox), mb->vers, QTDIR}, nil, mb);
inb = emalloc(sizeof(Inbuf));
inb->rptr = inb->wptr = inb->data;
inb->fd = fd;
// read new messages
snprint(err, sizeof err, "reading '%s'", mb->path);
logmsg(err, nil);
for(;;){
if(lk != nil)
syslockrefresh(lk);
m = newmessage(mb->root);
m->mallocd = 1;
m->inmbox = 1;
if(readmessage(m, inb) < 0){
delmessage(mb, m);
mb->root->subname--;
break;
}
// merge mailbox versions
while(*l != nil){
if(memcmp((*l)->digest, m->digest, SHA1dlen) == 0){
// matches mail we already read, discard
logmsg("duplicate", *l);
delmessage(mb, m);
mb->root->subname--;
m = nil;
l = &(*l)->next;
break;
} else {
// old mail no longer in box, mark deleted
logmsg("disappeared", *l);
if(doplumb)
mailplumb(mb, *l, 1);
(*l)->inmbox = 0;
(*l)->deleted = 1;
l = &(*l)->next;
}
}
if(m == nil)
continue;
x = strchr(m->start, '\n');
if(x == nil)
m->header = m->end;
else
m->header = x + 1;
m->mheader = m->mhend = m->header;
parseunix(m);
parse(m, 0, mb, 0);
logmsg("new", m);
/* chain in */
*l = m;
l = &m->next;
if(doplumb)
mailplumb(mb, m, 0);
}
logmsg("mbox read", nil);
// whatever is left has been removed from the mbox, mark deleted
while(*l != nil){
if(doplumb)
mailplumb(mb, *l, 1);
(*l)->inmbox = 0;
(*l)->deleted = 1;
l = &(*l)->next;
}
close(fd);
free(inb);
return nil;
}
static void
_writembox(Mailbox *mb, Mlock *lk)
{
Dir *d;
Message *m;
String *tmp;
int mode, errs;
Biobuf *b;
tmp = s_copy(mb->path);
s_append(tmp, ".tmp");
/*
* preserve old files permissions, if possible
*/
d = dirstat(mb->path);
if(d != nil){
mode = d->mode&0777;
free(d);
} else
mode = MBOXMODE;
sysremove(s_to_c(tmp));
b = sysopen(s_to_c(tmp), "alc", mode);
if(b == 0){
fprint(2, "can't write temporary mailbox %s: %r\n", s_to_c(tmp));
return;
}
logmsg("writing new mbox", nil);
errs = 0;
for(m = mb->root->part; m != nil; m = m->next){
if(lk != nil)
syslockrefresh(lk);
if(m->deleted)
continue;
logmsg("writing", m);
if(Bwrite(b, m->start, m->end - m->start) < 0)
errs = 1;
if(Bwrite(b, "\n", 1) < 0)
errs = 1;
}
logmsg("wrote new mbox", nil);
if(sysclose(b) < 0)
errs = 1;
if(errs){
fprint(2, "error writing temporary mail file\n");
s_free(tmp);
return;
}
sysremove(mb->path);
if(sysrename(s_to_c(tmp), mb->path) < 0)
fprint(2, "%s: can't rename %s to %s: %r\n", argv0,
s_to_c(tmp), mb->path);
s_free(tmp);
if(mb->d != nil)
free(mb->d);
mb->d = dirstat(mb->path);
}
RD_BOOL
cssp_connect(char *server, char *user, char *domain, char *password, STREAM s)
{
OM_uint32 actual_time;
gss_cred_id_t cred;
gss_buffer_desc input_tok, output_tok;
gss_name_t target_name;
OM_uint32 major_status, minor_status;
int context_established = 0;
gss_ctx_id_t gss_ctx;
gss_OID desired_mech = &_gss_spnego_krb5_mechanism_oid_desc;
STREAM ts_creds;
struct stream token = { 0 };
struct stream pubkey = { 0 };
struct stream pubkey_cmp = { 0 };
// Verify that system gss support spnego
if (!cssp_gss_mech_available(desired_mech))
{
warning("CredSSP: System doesn't have support for desired authentication mechanism.\n");
return False;
}
// Get service name
if (!cssp_gss_get_service_name(server, &target_name))
{
warning("CredSSP: Failed to get target service name.\n");
return False;
}
// Establish tls connection to server
if (!tcp_tls_connect())
{
warning("CredSSP: Failed to establish TLS connection.\n");
return False;
}
tcp_tls_get_server_pubkey(&pubkey);
#ifdef WITH_DEBUG_CREDSSP
streamsave(&pubkey, "PubKey.raw");
#endif
// Enter the spnego loop
OM_uint32 actual_services;
gss_OID actual_mech;
struct stream blob = { 0 };
gss_ctx = GSS_C_NO_CONTEXT;
cred = GSS_C_NO_CREDENTIAL;
input_tok.length = 0;
output_tok.length = 0;
minor_status = 0;
int i = 0;
do
{
major_status = gss_init_sec_context(&minor_status,
cred,
&gss_ctx,
target_name,
desired_mech,
GSS_C_MUTUAL_FLAG | GSS_C_DELEG_FLAG,
GSS_C_INDEFINITE,
GSS_C_NO_CHANNEL_BINDINGS,
&input_tok,
&actual_mech,
&output_tok, &actual_services, &actual_time);
if (GSS_ERROR(major_status))
{
if (i == 0)
error("CredSSP: Initialize failed, do you have correct kerberos tgt initialized ?\n");
else
error("CredSSP: Negotiation failed.\n");
#ifdef WITH_DEBUG_CREDSSP
cssp_gss_report_error(GSS_C_GSS_CODE, "CredSSP: SPNEGO negotiation failed.",
major_status, minor_status);
#endif
goto bail_out;
}
// validate required services
if (!(actual_services & GSS_C_CONF_FLAG))
{
error("CredSSP: Confidiality service required but is not available.\n");
goto bail_out;
}
// Send token to server
if (output_tok.length != 0)
{
if (output_tok.length > token.size)
s_realloc(&token, output_tok.length);
s_reset(&token);
out_uint8p(&token, output_tok.value, output_tok.length);
s_mark_end(&token);
if (!cssp_send_tsrequest(&token, NULL, NULL))
goto bail_out;
(void) gss_release_buffer(&minor_status, &output_tok);
}
// Read token from server
if (major_status & GSS_S_CONTINUE_NEEDED)
{
(void) gss_release_buffer(&minor_status, &input_tok);
if (!cssp_read_tsrequest(&token, NULL))
goto bail_out;
input_tok.value = token.data;
input_tok.length = s_length(&token);
}
else
{
// Send encrypted pubkey for verification to server
context_established = 1;
if (!cssp_gss_wrap(gss_ctx, &pubkey, &blob))
goto bail_out;
if (!cssp_send_tsrequest(NULL, NULL, &blob))
goto bail_out;
context_established = 1;
}
i++;
}
while (!context_established);
// read tsrequest response and decrypt for public key validation
if (!cssp_read_tsrequest(NULL, &blob))
goto bail_out;
if (!cssp_gss_unwrap(gss_ctx, &blob, &pubkey_cmp))
goto bail_out;
pubkey_cmp.data[0] -= 1;
// validate public key
if (memcmp(pubkey.data, pubkey_cmp.data, s_length(&pubkey)) != 0)
{
error("CredSSP: Cannot guarantee integrity of server connection, MITM ? "
"(public key data mismatch)\n");
goto bail_out;
}
// Send TSCredentials
ts_creds = cssp_encode_tscredentials(user, password, domain);
if (!cssp_gss_wrap(gss_ctx, ts_creds, &blob))
goto bail_out;
s_free(ts_creds);
if (!cssp_send_tsrequest(NULL, &blob, NULL))
goto bail_out;
return True;
bail_out:
xfree(token.data);
return False;
}
RD_BOOL
cssp_send_tsrequest(STREAM token, STREAM auth, STREAM pubkey)
{
STREAM s;
STREAM h1, h2, h3, h4, h5;
struct stream tmp = { 0 };
struct stream message = { 0 };
memset(&message, 0, sizeof(message));
memset(&tmp, 0, sizeof(tmp));
// version [0]
s_realloc(&tmp, sizeof(uint8));
s_reset(&tmp);
out_uint8(&tmp, 2);
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_INTEGER, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
// negoToken [1]
if (token && s_length(token))
{
h5 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, token);
h4 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0, h5);
h3 = ber_wrap_hdr_data(BER_TAG_SEQUENCE | BER_TAG_CONSTRUCTED, h4);
h2 = ber_wrap_hdr_data(BER_TAG_SEQUENCE | BER_TAG_CONSTRUCTED, h3);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 1, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h5);
s_free(h4);
s_free(h3);
s_free(h2);
s_free(h1);
}
// authInfo [2]
if (auth && s_length(auth))
{
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, auth);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 2, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_free(h2);
s_free(h1);
}
// pubKeyAuth [3]
if (pubkey && s_length(pubkey))
{
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, pubkey);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 3, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
s_mark_end(&message);
// Construct ASN.1 Message
// Todo: can h1 be send directly instead of tcp_init() approach
h1 = ber_wrap_hdr_data(BER_TAG_SEQUENCE | BER_TAG_CONSTRUCTED, &message);
s = tcp_init(s_length(h1));
out_uint8p(s, h1->data, s_length(h1));
s_mark_end(s);
s_free(h1);
#if WITH_DEBUG_CREDSSP
streamsave(s, "tsrequest_out.raw");
printf("Out TSRequest %ld bytes\n", s_length(s));
hexdump(s->data, s_length(s));
#endif
tcp_send(s);
// cleanup
xfree(message.data);
xfree(tmp.data);
return True;
}
STREAM
cssp_encode_tscredentials(char *username, char *password, char *domain)
{
STREAM out;
STREAM h1, h2, h3;
struct stream tmp = { 0 };
struct stream message = { 0 };
// credType [0]
s_realloc(&tmp, sizeof(uint8));
s_reset(&tmp);
if (g_use_password_as_pin == False)
{
out_uint8(&tmp, 1); // TSPasswordCreds
}
else
{
out_uint8(&tmp, 2); // TSSmartCardCreds
}
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_INTEGER, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
// credentials [1]
if (g_use_password_as_pin == False)
{
h3 = cssp_encode_tspasswordcreds(username, password, domain);
}
else
{
h3 = cssp_encode_tssmartcardcreds(username, password, domain);
}
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, h3);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 1, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h3);
s_free(h2);
s_free(h1);
// Construct ASN.1 message
out = ber_wrap_hdr_data(BER_TAG_SEQUENCE | BER_TAG_CONSTRUCTED, &message);
#if WITH_DEBUG_CREDSSP
streamsave(out, "tscredentials.raw");
printf("Out TSCredentials %ld bytes\n", s_length(out));
hexdump(out->data, s_length(out));
#endif
// cleanup
xfree(message.data);
xfree(tmp.data);
return out;
}
/**
* Do really login
*
* @param lc
* @param md5 The md5 calculated from calculate_password_md5()
* @param err
*/
static void do_login(LwqqClient *lc, const char *md5, LwqqErrorCode *err)
{
char url[1024];
LwqqHttpRequest *req;
char *response = NULL;
char *cookies;
int ret;
snprintf(url, sizeof(url), "%s/login?u=%s&p=%s&verifycode=%s&"
"webqq_type=10&remember_uin=1&aid=1003903&login2qq=1&"
"u1=http%%3A%%2F%%2Fweb.qq.com%%2Floginproxy.html"
"%%3Flogin2qq%%3D1%%26webqq_type%%3D10&h=1&ptredirect=0&"
"ptlang=2052&from_ui=1&pttype=1&dumy=&fp=loginerroralert&"
"action=2-11-7438&mibao_css=m_webqq&t=1&g=1", LWQQ_URL_LOGIN_HOST, lc->username, md5, lc->vc->str);
req = lwqq_http_create_default_request(url, err);
if (!req) {
goto done;
}
/* Setup http header */
cookies = lwqq_get_cookies(lc);
if (cookies) {
req->set_header(req, "Cookie", cookies);
s_free(cookies);
}
/* Send request */
ret = req->do_request(req, 0, NULL);
if (ret) {
*err = LWQQ_EC_NETWORK_ERROR;
goto done;
}
if (req->http_code != 200) {
*err = LWQQ_EC_HTTP_ERROR;
goto done;
}
response = req->response;
char *p = strstr(response, "\'");
if (!p) {
*err = LWQQ_EC_ERROR;
goto done;
}
char buf[4] = {0};
int status;
strncpy(buf, p + 1, 1);
status = atoi(buf);
switch (status) {
case 0:
if (sava_cookie(lc, req, err)) {
goto done;
}
break;
case 1:
lwqq_log(LOG_WARNING, "Server busy! Please try again\n");
*err = LWQQ_EC_ERROR;
goto done;
case 2:
lwqq_log(LOG_ERROR, "Out of date QQ number\n");
*err = LWQQ_EC_ERROR;
goto done;
case 3:
lwqq_log(LOG_ERROR, "Wrong password\n");
*err = LWQQ_EC_ERROR;
goto done;
case 4:
lwqq_log(LOG_ERROR, "Wrong verify code\n");
*err = LWQQ_EC_ERROR;
goto done;
case 5:
lwqq_log(LOG_ERROR, "Verify failed\n");
*err = LWQQ_EC_ERROR;
goto done;
case 6:
lwqq_log(LOG_WARNING, "You may need to try login again\n");
*err = LWQQ_EC_ERROR;
goto done;
case 7:
lwqq_log(LOG_ERROR, "Wrong input\n");
*err = LWQQ_EC_ERROR;
goto done;
case 8:
lwqq_log(LOG_ERROR, "Too many logins on this IP. Please try again\n");
*err = LWQQ_EC_ERROR;
goto done;
default:
*err = LWQQ_EC_ERROR;
lwqq_log(LOG_ERROR, "Unknow error");
goto done;
}
set_online_status(lc, "online", err);
done:
lwqq_http_request_free(req);
}
/*
* pipe message to mailer with the following transformations:
* - change \r\n into \n.
* - add sender's domain to any addrs with no domain
* - add a From: if none of From:, Sender:, or Replyto: exists
* - add a Received: line
*/
int
pipemsg(int *byteswritten)
{
int n, nbytes, sawdot, status, nonhdr, bpr;
char *cp;
Field *f;
Link *l;
Node *p;
String *hdr, *line;
pipesig(&status); /* set status to 1 on write to closed pipe */
sawdot = 0;
status = 0;
/*
* add a 'From ' line as envelope
*/
nbytes = 0;
nbytes += Bprint(pp->std[0]->fp, "From %s %s remote from \n",
s_to_c(senders.first->p), thedate());
/*
* add our own Received: stamp
*/
nbytes += Bprint(pp->std[0]->fp, "Received: from %s ", him);
if(nci->rsys)
nbytes += Bprint(pp->std[0]->fp, "([%s]) ", nci->rsys);
nbytes += Bprint(pp->std[0]->fp, "by %s; %s\n", me, thedate());
/*
* read first 16k obeying '.' escape. we're assuming
* the header will all be there.
*/
line = s_new();
hdr = s_new();
while(sawdot == 0 && s_len(hdr) < 16*1024){
n = getcrnl(s_reset(line), &bin);
/* eof or error ends the message */
if(n <= 0)
break;
/* a line with only a '.' ends the message */
cp = s_to_c(line);
if(n == 2 && *cp == '.' && *(cp+1) == '\n'){
sawdot = 1;
break;
}
s_append(hdr, *cp == '.' ? cp+1 : cp);
}
/*
* parse header
*/
yyinit(s_to_c(hdr), s_len(hdr));
yyparse();
/*
* Look for masquerades. Let Sender: trump From: to allow mailing list
* forwarded messages.
*/
if(fflag)
nbytes += forgedheaderwarnings();
/*
* add an orginator and/or destination if either is missing
*/
if(originator == 0){
if(senders.last == nil || senders.last->p == nil)
nbytes += Bprint(pp->std[0]->fp, "From: /dev/null@%s\n",
him);
else
nbytes += Bprint(pp->std[0]->fp, "From: %s\n",
s_to_c(senders.last->p));
}
if(destination == 0){
nbytes += Bprint(pp->std[0]->fp, "To: ");
for(l = rcvers.first; l; l = l->next){
if(l != rcvers.first)
nbytes += Bprint(pp->std[0]->fp, ", ");
nbytes += Bprint(pp->std[0]->fp, "%s", s_to_c(l->p));
}
nbytes += Bprint(pp->std[0]->fp, "\n");
}
/*
* add sender's domain to any domainless addresses
* (to avoid forging local addresses)
*/
cp = s_to_c(hdr);
for(f = firstfield; cp != nil && f; f = f->next){
for(p = f->node; cp != 0 && p; p = p->next) {
bpr = 0;
cp = bprintnode(pp->std[0]->fp, p, &bpr);
nbytes += bpr;
}
if(status == 0 && Bprint(pp->std[0]->fp, "\n") < 0){
piperror = "write error";
status = 1;
}
nbytes++; /* for newline */
}
if(cp == nil){
piperror = "sender domain";
status = 1;
}
/* write anything we read following the header */
nonhdr = s_to_c(hdr) + s_len(hdr) - cp;
if(status == 0 && Bwrite(pp->std[0]->fp, cp, nonhdr) < 0){
piperror = "write error 2";
status = 1;
}
nbytes += nonhdr;
s_free(hdr);
/*
* pass rest of message to mailer. take care of '.'
* escapes.
*/
while(sawdot == 0){
n = getcrnl(s_reset(line), &bin);
/* eof or error ends the message */
if(n <= 0)
break;
/* a line with only a '.' ends the message */
cp = s_to_c(line);
if(n == 2 && *cp == '.' && *(cp+1) == '\n'){
sawdot = 1;
break;
}
if(cp[0] == '.'){
cp++;
n--;
}
nbytes += n;
if(status == 0 && Bwrite(pp->std[0]->fp, cp, n) < 0){
piperror = "write error 3";
status = 1;
}
}
s_free(line);
if(sawdot == 0){
/* message did not terminate normally */
snprint(pipbuf, sizeof pipbuf, "network eof: %r");
piperror = pipbuf;
if (pp->pid > 0) {
syskillpg(pp->pid);
/* none can't syskillpg, so try a variant */
sleep(500);
syskill(pp->pid);
}
status = 1;
}
if(status == 0 && Bflush(pp->std[0]->fp) < 0){
piperror = "write error 4";
status = 1;
}
if (debug) {
stamp();
fprint(2, "at end of message; %s .\n",
(sawdot? "saw": "didn't see"));
}
stream_free(pp->std[0]);
pp->std[0] = 0;
*byteswritten = nbytes;
pipesigoff();
if(status && !piperror)
piperror = "write on closed pipe";
return status;
}
/**
* Update the cookies needed by webqq
*
* @param req
* @param key
* @param value
* @param update_cache Weather update lwcookies member
*/
static void update_cookies(LwqqCookies *cookies, LwqqHttpRequest *req,
const char *key, int update_cache)
{
if (!cookies || !req || !key) {
lwqq_log(LOG_ERROR, "Null pointer access\n");
return ;
}
char *value = req->get_cookie(req, key);
if (!value)
return ;
#define FREE_AND_STRDUP(a, b) \
if (a) \
s_free(a); \
a = s_strdup(b);
if (!strcmp(key, "ptvfsession")) {
FREE_AND_STRDUP(cookies->ptvfsession, value);
} else if (!strcmp(key, "ptcz")) {
FREE_AND_STRDUP(cookies->ptcz, value);
} else if (!strcmp(key, "skey")) {
FREE_AND_STRDUP(cookies->skey, value);
} else if (!strcmp(key, "ptwebqq")) {
FREE_AND_STRDUP(cookies->ptwebqq, value);
} else if (!strcmp(key, "ptuserinfo")) {
FREE_AND_STRDUP(cookies->ptuserinfo, value);
} else if (!strcmp(key, "uin")) {
FREE_AND_STRDUP(cookies->uin, value);
} else if (!strcmp(key, "ptisp")) {
FREE_AND_STRDUP(cookies->ptisp, value);
} else if (!strcmp(key, "pt2gguin")) {
FREE_AND_STRDUP(cookies->pt2gguin, value);
} else if (!strcmp(key, "verifysession")) {
FREE_AND_STRDUP(cookies->verifysession, value);
} else {
lwqq_log(LOG_WARNING, "No this cookie: %s\n", key);
}
s_free(value);
if (update_cache) {
char buf[4096] = {0}; /* 4K is enough for cookies. */
int buflen = 0;
if (cookies->ptvfsession) {
snprintf(buf, sizeof(buf), "ptvfsession=%s; ", cookies->ptvfsession);
buflen = strlen(buf);
}
if (cookies->ptcz) {
snprintf(buf + buflen, sizeof(buf) - buflen, "ptcz=%s; ", cookies->ptcz);
buflen = strlen(buf);
}
if (cookies->skey) {
snprintf(buf + buflen, sizeof(buf) - buflen, "skey=%s; ", cookies->skey);
buflen = strlen(buf);
}
if (cookies->ptwebqq) {
snprintf(buf + buflen, sizeof(buf) - buflen, "ptwebqq=%s; ", cookies->ptwebqq);
buflen = strlen(buf);
}
if (cookies->ptuserinfo) {
snprintf(buf + buflen, sizeof(buf) - buflen, "ptuserinfo=%s; ", cookies->ptuserinfo);
buflen = strlen(buf);
}
if (cookies->uin) {
snprintf(buf + buflen, sizeof(buf) - buflen, "uin=%s; ", cookies->uin);
buflen = strlen(buf);
}
if (cookies->ptisp) {
snprintf(buf + buflen, sizeof(buf) - buflen, "ptisp=%s; ", cookies->ptisp);
buflen = strlen(buf);
}
if (cookies->pt2gguin) {
snprintf(buf + buflen, sizeof(buf) - buflen, "pt2gguin=%s; ", cookies->pt2gguin);
buflen = strlen(buf);
}
if (cookies->verifysession) {
snprintf(buf + buflen, sizeof(buf) - buflen, "verifysession=%s; ", cookies->verifysession);
buflen = strlen(buf);
}
FREE_AND_STRDUP(cookies->lwcookies, buf);
}
#undef FREE_AND_STRDUP
}
void
data(void)
{
int status, nbytes;
char *cp, *ep;
char errx[ERRMAX];
Link *l;
String *cmd, *err;
if(rejectcheck())
return;
if(senders.last == 0){
reply("503 2.5.2 Data without MAIL FROM:\r\n");
rejectcount++;
return;
}
if(rcvers.last == 0){
reply("503 2.5.2 Data without RCPT TO:\r\n");
rejectcount++;
return;
}
if(!trusted && sendermxcheck()){
rerrstr(errx, sizeof errx);
if(strncmp(errx, "rejected:", 9) == 0)
reply("554 5.7.1 %s\r\n", errx);
else
reply("450 4.7.0 %s\r\n", errx);
for(l=rcvers.first; l; l=l->next)
syslog(0, "smtpd", "[%s/%s] %s -> %s sendercheck: %s",
him, nci->rsys, s_to_c(senders.first->p),
s_to_c(l->p), errx);
rejectcount++;
return;
}
cmd = startcmd();
if(cmd == 0)
return;
reply("354 Input message; end with <CRLF>.<CRLF>\r\n");
if(debug){
seek(2, 0, 2);
stamp();
fprint(2, "# sent 354; accepting DATA %s\n", thedate());
}
/*
* allow 145 more minutes to move the data
*/
alarm(145*60*1000);
status = pipemsg(&nbytes);
/*
* read any error messages
*/
err = s_new();
if (debug) {
stamp();
fprint(2, "waiting for upas/send to close stderr\n");
}
while(s_read_line(pp->std[2]->fp, err))
;
alarm(0);
atnotify(catchalarm, 0);
if (debug) {
stamp();
fprint(2, "waiting for upas/send to exit\n");
}
status |= proc_wait(pp);
if(debug){
seek(2, 0, 2);
stamp();
fprint(2, "# %d upas/send status %#ux at %s\n",
getpid(), status, thedate());
if(*s_to_c(err))
fprint(2, "# %d error %s\n", getpid(), s_to_c(err));
}
/*
* if process terminated abnormally, send back error message
*/
if(status){
int code;
char *ecode;
if(strstr(s_to_c(err), "mail refused")){
syslog(0, "smtpd", "++[%s/%s] %s %s refused: %s",
him, nci->rsys, s_to_c(senders.first->p),
s_to_c(cmd), firstline(s_to_c(err)));
code = 554;
ecode = "5.0.0";
} else {
syslog(0, "smtpd", "++[%s/%s] %s %s %s%s%sreturned %#q %s",
him, nci->rsys,
s_to_c(senders.first->p), s_to_c(cmd),
piperror? "error during pipemsg: ": "",
piperror? piperror: "",
piperror? "; ": "",
pp->waitmsg->msg, firstline(s_to_c(err)));
code = 450;
ecode = "4.0.0";
}
for(cp = s_to_c(err); ep = strchr(cp, '\n'); cp = ep){
*ep++ = 0;
reply("%d-%s %s\r\n", code, ecode, cp);
}
reply("%d %s mail process terminated abnormally\r\n",
code, ecode);
} else {
/*
* if a message appeared on stderr, despite good status,
* log it. this can happen if rewrite.in contains a bad
* r.e., for example.
*/
if(*s_to_c(err))
syslog(0, "smtpd",
"%s returned good status, but said: %s",
s_to_c(mailer), s_to_c(err));
if(filterstate == BLOCKED)
reply("554 5.7.1 we believe this is spam. "
"we don't accept it.\r\n");
else if(filterstate == DELAY)
reply("450 4.3.0 There will be a delay in delivery "
"of this message.\r\n");
else {
reply("250 2.5.0 sent\r\n");
logcall(nbytes);
if(debug){
seek(2, 0, 2);
stamp();
fprint(2, "# %d sent 250 reply %s\n",
getpid(), thedate());
}
}
}
proc_free(pp);
pp = 0;
s_free(cmd);
s_free(err);
listfree(&senders);
listfree(&rcvers);
}
/**
* WebQQ logout function
*
* @param client Lwqq Client
* @param err Error code
*/
void lwqq_logout(LwqqClient *client, LwqqErrorCode *err)
{
char url[512];
LwqqHttpRequest *req = NULL;
int ret;
json_t *json = NULL;
char *value;
struct timeval tv;
char *cookies;
long int re;
if (!client) {
lwqq_log(LOG_ERROR, "Invalid pointer\n");
return ;
}
/* Get the milliseconds of now */
if (gettimeofday(&tv, NULL)) {
if (err)
*err = LWQQ_EC_ERROR;
return ;
}
re = tv.tv_usec / 1000;
re += tv.tv_sec;
snprintf(url, sizeof(url), "%s/channel/logout2?clientid=%s&psessionid=%s&t=%ld",
"http://d.web2.qq.com", client->clientid, client->psessionid, re);
/* Create a GET request */
req = lwqq_http_create_default_request(url, err);
if (!req) {
goto done;
}
/* Set header needed by server */
req->set_header(req, "Referer", "http://ptlogin2.qq.com/proxy.html?v=20101025002");
/* Set http cookie */
cookies = lwqq_get_cookies(client);
if (cookies) {
req->set_header(req, "Cookie", cookies);
s_free(cookies);
}
ret = req->do_request(req, 0, NULL);
if (ret) {
lwqq_log(LOG_ERROR, "Send logout request failed\n");
if (err)
*err = LWQQ_EC_NETWORK_ERROR;
goto done;
}
if (req->http_code != 200) {
if (err)
*err = LWQQ_EC_HTTP_ERROR;
goto done;
}
ret = json_parse_document(&json, req->response);
if (ret != JSON_OK) {
if (err)
*err = LWQQ_EC_ERROR;
goto done;
}
/* Check whether logout correctly */
value = json_parse_simple_value(json, "retcode");
if (!value || strcmp(value, "0")) {
if (err)
*err = LWQQ_EC_ERROR;
goto done;
}
value = json_parse_simple_value(json, "result");
if (!value || strcmp(value, "ok")) {
if (err)
*err = LWQQ_EC_ERROR;
goto done;
}
/* Ok, seems like all thing is ok */
if (err)
*err = LWQQ_EC_OK;
done:
if (json)
json_free_value(&json);
lwqq_http_request_free(req);
}
void
auth(String *mech, String *resp)
{
char *user, *pass, *scratch = nil;
AuthInfo *ai = nil;
Chalstate *chs = nil;
String *s_resp1_64 = nil, *s_resp2_64 = nil, *s_resp1 = nil;
String *s_resp2 = nil;
if (rejectcheck())
goto bomb_out;
syslog(0, "smtpd", "auth(%s, %s) from %s", s_to_c(mech),
"(protected)", him);
if (authenticated) {
bad_sequence:
rejectcount++;
reply("503 5.5.2 Bad sequence of commands\r\n");
goto bomb_out;
}
if (cistrcmp(s_to_c(mech), "plain") == 0) {
if (!passwordinclear) {
rejectcount++;
reply("538 5.7.1 Encryption required for requested "
"authentication mechanism\r\n");
goto bomb_out;
}
s_resp1_64 = resp;
if (s_resp1_64 == nil) {
reply("334 \r\n");
s_resp1_64 = s_new();
if (getcrnl(s_resp1_64, &bin) <= 0)
goto bad_sequence;
}
s_resp1 = s_dec64(s_resp1_64);
if (s_resp1 == nil) {
rejectcount++;
reply("501 5.5.4 Cannot decode base64\r\n");
goto bomb_out;
}
memset(s_to_c(s_resp1_64), 'X', s_len(s_resp1_64));
user = s_to_c(s_resp1) + strlen(s_to_c(s_resp1)) + 1;
pass = user + strlen(user) + 1;
ai = auth_userpasswd(user, pass);
authenticated = ai != nil;
memset(pass, 'X', strlen(pass));
goto windup;
}
else if (cistrcmp(s_to_c(mech), "login") == 0) {
if (!passwordinclear) {
rejectcount++;
reply("538 5.7.1 Encryption required for requested "
"authentication mechanism\r\n");
goto bomb_out;
}
if (resp == nil) {
reply("334 VXNlcm5hbWU6\r\n");
s_resp1_64 = s_new();
if (getcrnl(s_resp1_64, &bin) <= 0)
goto bad_sequence;
}
reply("334 UGFzc3dvcmQ6\r\n");
s_resp2_64 = s_new();
if (getcrnl(s_resp2_64, &bin) <= 0)
goto bad_sequence;
s_resp1 = s_dec64(s_resp1_64);
s_resp2 = s_dec64(s_resp2_64);
memset(s_to_c(s_resp2_64), 'X', s_len(s_resp2_64));
if (s_resp1 == nil || s_resp2 == nil) {
rejectcount++;
reply("501 5.5.4 Cannot decode base64\r\n");
goto bomb_out;
}
ai = auth_userpasswd(s_to_c(s_resp1), s_to_c(s_resp2));
authenticated = ai != nil;
memset(s_to_c(s_resp2), 'X', s_len(s_resp2));
windup:
if (authenticated) {
/* if you authenticated, we trust you despite your IP */
trusted = 1;
reply("235 2.0.0 Authentication successful\r\n");
} else {
rejectcount++;
reply("535 5.7.1 Authentication failed\r\n");
syslog(0, "smtpd", "authentication failed: %r");
}
goto bomb_out;
}
else if (cistrcmp(s_to_c(mech), "cram-md5") == 0) {
int chal64n;
char *resp, *t;
chs = auth_challenge("proto=cram role=server");
if (chs == nil) {
rejectcount++;
reply("501 5.7.5 Couldn't get CRAM-MD5 challenge\r\n");
goto bomb_out;
}
scratch = malloc(chs->nchal * 2 + 1);
chal64n = enc64(scratch, chs->nchal * 2, (uchar *)chs->chal,
chs->nchal);
scratch[chal64n] = 0;
reply("334 %s\r\n", scratch);
s_resp1_64 = s_new();
if (getcrnl(s_resp1_64, &bin) <= 0)
goto bad_sequence;
s_resp1 = s_dec64(s_resp1_64);
if (s_resp1 == nil) {
rejectcount++;
reply("501 5.5.4 Cannot decode base64\r\n");
goto bomb_out;
}
/* should be of form <user><space><response> */
resp = s_to_c(s_resp1);
t = strchr(resp, ' ');
if (t == nil) {
rejectcount++;
reply("501 5.5.4 Poorly formed CRAM-MD5 response\r\n");
goto bomb_out;
}
*t++ = 0;
chs->user = resp;
chs->resp = t;
chs->nresp = strlen(t);
ai = auth_response(chs);
authenticated = ai != nil;
goto windup;
}
rejectcount++;
reply("501 5.5.1 Unrecognised authentication type %s\r\n", s_to_c(mech));
bomb_out:
if (ai)
auth_freeAI(ai);
if (chs)
auth_freechal(chs);
if (scratch)
free(scratch);
if (s_resp1)
s_free(s_resp1);
if (s_resp2)
s_free(s_resp2);
if (s_resp1_64)
s_free(s_resp1_64);
if (s_resp2_64)
s_free(s_resp2_64);
}
int main(int argc, char **argv)
{
HC_DEF_S(s);
s_catz(s, "hello world of possibilities!");
HC_SAFE_CSTR(s);
fprintf(stdout, "[%i][%i][%s]\n", s->len, s->a, s->s);
s->len = 0; /* truncate string */
s_catn(s, "hi ", 3);
fwrite(s->s, s->len, 1, stdout);
s_copyc(s, 'f');
s_catz(s, "olk");
s_catc(s, 's');
s_catc(s, '!');
s_catc(s, '\n');
fwrite(s->s, s->len, 1, stdout);
s_upper(s);
fwrite(s->s, s->len, 1, stdout);
s_lower(s);
fwrite(s->s, s->len, 1, stdout);
s_copyz(s, "aa");
assert(sdiff("aa", "aa") == 0);
assert(s_diffz(s, "aa") == 0);
assert(s_diffn(s, "aa", slen("aa")) == 0);
assert(sdiff("aa", "aaz") < 0);
assert(s_diffz(s, "aaz") < 0);
assert(s_diffn(s, "aaz", slen("aaz")) < 0);
assert(sdiff("aa", "a0z") > 0);
assert(s_diffz(s, "a0z") > 0);
assert(s_diffn(s, "a0z", slen("a0z")) > 0);
assert(sdiff("aa", "0") > 0);
assert(s_diffz(s, "0") > 0);
assert(s_diffn(s, "0", slen("0")) > 0);
assert(sdiff("aa", "0zz") > 0);
assert(s_diffz(s, "0zz") > 0);
assert(s_diffn(s, "0zz", slen("0zz")) > 0);
assert(sdiff("aa", "a") > 0);
assert(s_diffz(s, "a") > 0);
assert(s_diffn(s, "a", slen("a")) > 0);
assert(sdiff("aa", "a0") > 0);
assert(s_diffz(s, "a0") > 0);
assert(s_diffn(s, "a0", slen("a0")) > 0);
s_free(s);
/*
*/
assert(s_cat_u4_hex(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_hex(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_u4_hex(s, 0xffffffff) == 8);
assert(s_diffz(s, "ffffffff") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_hex(s, (int32_t)0xffffffff) == 2);
assert(s_diffz(s, "-1") == 0);
print_s("[", s, "]\n");
s_free(s);
/*
*/
assert(s_cat_u4_dec(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_dec(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_u4_dec(s, 0xffffffff) == 10);
assert(s_diffz(s, "4294967295") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_dec(s, (int32_t)0xffffffff) == 2);
assert(s_diffz(s, "-1") == 0);
print_s("[", s, "]\n");
s_free(s);
/*
*/
assert(s_cat_u4_base36(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_base36(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_u4_base36(s, 0xffffffff) == 7);
assert(s_diffz(s, "1z141z3") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_base36(s, (int32_t)0xffffffff) == 2);
assert(s_diffz(s, "-1") == 0);
print_s("[", s, "]\n");
s_free(s);
/*
*/
{
void *out;
int putlen;
HC_DEF_S(t);
s_copyz(s, "hello world of possibilities!");
putlen = s_putlen(s);
HC_ALLOC(out, putlen);
assert(s_put(s, out) == putlen);
assert(s_get(t, out) == putlen);
assert(s_diff(s, t) == 0);
s->len = 0;
s_reprn(s, out, putlen);
print_s("[", s, "]\n");
HC_FREE(out);
s_free(t);
}
/*
*/
s_free(s);
return 0;
}
void
sender(String *path)
{
String *s;
static char *lastsender;
if(rejectcheck())
return;
if (authenticate && !authenticated) {
rejectcount++;
reply("530 5.7.0 Authentication required\r\n");
return;
}
if(him == 0 || *him == 0){
rejectcount++;
reply("503 Start by saying HELO, please.\r\n", s_to_c(path));
return;
}
/* don't add the domain onto black holes or we will loop */
if(strchr(s_to_c(path), '!') == 0 && strcmp(s_to_c(path), "/dev/null") != 0){
s = s_new();
s_append(s, him);
s_append(s, "!");
s_append(s, s_to_c(path));
s_terminate(s);
s_free(path);
path = s;
}
if(shellchars(s_to_c(path))){
rejectcount++;
reply("501 5.1.3 Bad character in sender address %s.\r\n",
s_to_c(path));
return;
}
/*
* if the last sender address resulted in a rejection because the sending
* domain didn't exist and this sender has the same domain, reject
* immediately.
*/
if(lastsender){
if (strncmp(lastsender, s_to_c(path), strlen(lastsender)) == 0){
filterstate = REFUSED;
rejectcount++;
reply("554 5.1.8 Sender domain must exist: %s\r\n",
s_to_c(path));
return;
}
free(lastsender); /* different sender domain */
lastsender = 0;
}
/*
* see if this ip address, domain name, user name or account is blocked
*/
logged = 0;
filterstate = blocked(path);
/*
* permanently reject what we can before trying smtp ping, which
* often leads to merely temporary rejections.
*/
switch (filterstate){
case DENIED:
syslog(0, "smtpd", "Denied %s (%s/%s)",
s_to_c(path), him, nci->rsys);
rejectcount++;
logged++;
reply("554-5.7.1 We don't accept mail from %s.\r\n",
s_to_c(path));
reply("554 5.7.1 Contact postmaster@%s for more information.\r\n",
dom);
return;
case REFUSED:
syslog(0, "smtpd", "Refused %s (%s/%s)",
s_to_c(path), him, nci->rsys);
rejectcount++;
logged++;
reply("554 5.7.1 Sender domain must exist: %s\r\n",
s_to_c(path));
return;
}
listadd(&senders, path);
reply("250 2.0.0 sender is %s\r\n", s_to_c(path));
}
/* Free an sds string. No operation is performed if 's' is NULL. */
void sdsfree(sds s) {
if (s == NULL) return;
s_free((char*)s-sdsHdrSize(s[-1]));
}
String*
startcmd(void)
{
int n;
char *filename;
char **av;
Link *l;
String *cmd;
/*
* ignore the filterstate if the all the receivers prefer it.
*/
filterstate = optoutall(filterstate);
switch (filterstate){
case BLOCKED:
case DELAY:
rejectcount++;
logmsg("Blocked");
filename = dumpfile(s_to_c(senders.last->p));
cmd = s_new();
s_append(cmd, "cat > ");
s_append(cmd, filename);
pp = proc_start(s_to_c(cmd), instream(), 0, outstream(), 0, 0);
break;
case DIALUP:
logmsg("Dialup");
rejectcount++;
reply("554 5.7.1 We don't accept mail from dial-up ports.\r\n");
/*
* we could exit here, because we're never going to accept mail
* from this ip address, but it's unclear that RFC821 allows
* that. Instead we set the hardreject flag and go stupid.
*/
hardreject = 1;
return 0;
case DENIED:
logmsg("Denied");
rejectcount++;
reply("554-5.7.1 We don't accept mail from %s.\r\n",
s_to_c(senders.last->p));
reply("554 5.7.1 Contact postmaster@%s for more information.\r\n",
dom);
return 0;
case REFUSED:
logmsg("Refused");
rejectcount++;
reply("554 5.7.1 Sender domain must exist: %s\r\n",
s_to_c(senders.last->p));
return 0;
default:
case NONE:
logmsg("Confused");
rejectcount++;
reply("554-5.7.0 We have had an internal mailer error "
"classifying your message.\r\n");
reply("554-5.7.0 Filterstate is %d\r\n", filterstate);
reply("554 5.7.0 Contact postmaster@%s for more information.\r\n",
dom);
return 0;
case ACCEPT:
/*
* now that all other filters have been passed,
* do grey-list processing.
*/
if(gflag)
vfysenderhostok();
/* fall through */
case TRUSTED:
/*
* set up mail command
*/
cmd = s_clone(mailer);
n = 3;
for(l = rcvers.first; l; l = l->next)
n++;
av = malloc(n * sizeof(char*));
if(av == nil){
reply("450 4.3.2 We're busy right now, try later\r\n");
s_free(cmd);
return 0;
}
n = 0;
av[n++] = s_to_c(cmd);
av[n++] = "-r";
for(l = rcvers.first; l; l = l->next)
av[n++] = s_to_c(l->p);
av[n] = 0;
/*
* start mail process
*/
pp = noshell_proc_start(av, instream(), outstream(),
outstream(), 0, 0);
free(av);
break;
}
if(pp == 0) {
reply("450 4.3.2 We're busy right now, try later\r\n");
s_free(cmd);
return 0;
}
return cmd;
}
int s_handler_uninit (s_handler_t *handler)
{
s_free(handler);
return 0;
}
/* Free a window manager cursor
This function can be NULL if CreateWMCursor is also NULL.
*/
void sdl_xynth_FreeWMCursor (_THIS, WMcursor *cursor)
{
s_free(cursor);
debugf("sdl_xynth_FreeWMCursor\n");
}
/*
* send the damn thing
*/
char *
data(String *from, Biobuf *b)
{
char *buf, *cp;
int i, n, nbytes, bufsize, eof, r;
String *fromline;
char errmsg[Errlen];
char id[40];
/*
* input the header.
*/
buf = malloc(1);
if(buf == 0){
s_append(s_restart(reply), "out of memory");
return Retry;
}
n = 0;
eof = 0;
for(;;){
cp = Brdline(b, '\n');
if(cp == nil){
eof = 1;
break;
}
nbytes = Blinelen(b);
buf = realloc(buf, n+nbytes+1);
if(buf == 0){
s_append(s_restart(reply), "out of memory");
return Retry;
}
strncpy(buf+n, cp, nbytes);
n += nbytes;
if(nbytes == 1) /* end of header */
break;
}
buf[n] = 0;
bufsize = n;
/*
* parse the header, turn all addresses into @ format
*/
yyinit(buf, n);
yyparse();
/*
* print message observing '.' escapes and using \r\n for \n
*/
alarm(20*alarmscale);
if(!filter){
dBprint("DATA\r\n");
switch(getreply()){
case 3:
break;
case 5:
free(buf);
return Giveup;
default:
free(buf);
return Retry;
}
}
/*
* send header. add a message-id, a sender, and a date if there
* isn't one
*/
nbytes = 0;
fromline = convertheader(from);
uneaten = buf;
srand(truerand());
if(messageid == 0){
for(i=0; i<16; i++){
r = rand()&0xFF;
id[2*i] = hex[r&0xF];
id[2*i+1] = hex[(r>>4)&0xF];
}
id[2*i] = '\0';
nbytes += Bprint(&bout, "Message-ID: <%s@%s>\r\n", id, hostdomain);
if(debug)
Bprint(&berr, "Message-ID: <%s@%s>\r\n", id, hostdomain);
}
if(originator==0){
nbytes += Bprint(&bout, "From: %s\r\n", s_to_c(fromline));
if(debug)
Bprint(&berr, "From: %s\r\n", s_to_c(fromline));
}
s_free(fromline);
if(destination == 0 && toline)
if(*s_to_c(toline) == '@'){ /* route addr */
nbytes += Bprint(&bout, "To: <%s>\r\n", s_to_c(toline));
if(debug)
Bprint(&berr, "To: <%s>\r\n", s_to_c(toline));
} else {
nbytes += Bprint(&bout, "To: %s\r\n", s_to_c(toline));
if(debug)
Bprint(&berr, "To: %s\r\n", s_to_c(toline));
}
if(date==0 && udate)
nbytes += printdate(udate);
if (usys)
uneaten = usys->end + 1;
nbytes += printheader();
if (*uneaten != '\n')
putcrnl("\n", 1);
/*
* send body
*/
putcrnl(uneaten, buf+n - uneaten);
nbytes += buf+n - uneaten;
if(eof == 0){
for(;;){
n = Bread(b, buf, bufsize);
if(n < 0){
rerrstr(errmsg, sizeof(errmsg));
s_append(s_restart(reply), errmsg);
free(buf);
return Retry;
}
if(n == 0)
break;
alarm(10*alarmscale);
putcrnl(buf, n);
nbytes += n;
}
}
free(buf);
if(!filter){
if(last != '\n')
dBprint("\r\n.\r\n");
else
dBprint(".\r\n");
alarm(10*alarmscale);
switch(getreply()){
case 2:
break;
case 5:
return Giveup;
default:
return Retry;
}
syslog(0, "smtp", "%s sent %d bytes to %s", s_to_c(from),
nbytes, s_to_c(toline));/**/
}
return 0;
}
int main(int argc, char **argv)
{
int i; /* Loop over populations. */
population *pop[GA_STRUGGLE_NUM_POPS]; /* Array of populations. */
population *slavepop; /* Population for slave calculations. */
char *beststring=NULL; /* Human readable form of best solution. */
size_t beststrlen=0; /* Length of beststring. */
int rank; /* MPI rank. */
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
printf("Process %d initialised (rank %d)\n", getpid(), rank);
random_seed(42);
if (rank != 0)
{ /* This is a slave process. */
/*
* A population is created so that the callbacks are defined. Evolution doesn't
* occur with this population, so population_size can be zero. In such a case,
* no entities are ever seeded, so there is no significant overhead.
* Strictly, several of these callbacks are not needed on the slave processes, but
* their definition doesn't have any adverse effects.
*/
slavepop = ga_genesis_char(
0, /* const int population_size */
1, /* const int num_chromo */
(int) strlen(target_text), /* const int len_chromo */
NULL, /* GAgeneration_hook generation_hook */
NULL, /* GAiteration_hook iteration_hook */
NULL, /* GAdata_destructor data_destructor */
NULL, /* GAdata_ref_incrementor data_ref_incrementor */
struggle_score, /* GAevaluate evaluate */
ga_seed_printable_random, /* GAseed seed */
NULL, /* GAadapt adapt */
ga_select_one_sus, /* GAselect_one select_one */
ga_select_two_sus, /* GAselect_two select_two */
ga_mutate_printable_singlepoint_drift, /* GAmutate mutate */
ga_crossover_char_allele_mixing, /* GAcrossover crossover */
NULL, /* GAreplace replace */
NULL /* vpointer User data */
);
printf("DEBUG: Attaching process %d\n", rank);
ga_attach_mpi_slave( slavepop ); /* The slaves halt here until ga_detach_mpi_slaves(), below, is called. */
}
else
{
/*
* This is the master process. Other than calling ga_evolution_mpi() instead
* of ga_evolution(), there are no differences between this code and the usual
* GAUL invocation.
*/
for (i=0; i<GA_STRUGGLE_NUM_POPS; i++)
{
pop[i] = ga_genesis_char(
80, /* const int population_size */
1, /* const int num_chromo */
(int) strlen(target_text), /* const int len_chromo */
NULL, /* GAgeneration_hook generation_hook */
NULL, /* GAiteration_hook iteration_hook */
NULL, /* GAdata_destructor data_destructor */
NULL, /* GAdata_ref_incrementor data_ref_incrementor */
struggle_score, /* GAevaluate evaluate */
ga_seed_printable_random, /* GAseed seed */
NULL, /* GAadapt adapt */
ga_select_one_sus, /* GAselect_one select_one */
ga_select_two_sus, /* GAselect_two select_two */
ga_mutate_printable_singlepoint_drift, /* GAmutate mutate */
ga_crossover_char_allele_mixing, /* GAcrossover crossover */
NULL, /* GAreplace replace */
NULL /* vpointer User data */
);
ga_population_set_parameters( pop[i], GA_SCHEME_DARWIN, GA_ELITISM_PARENTS_DIE, 0.75, 0.25, 0.001 );
}
ga_evolution_archipelago_mpi( GA_STRUGGLE_NUM_POPS, pop, 250 );
for (i=0; i<GA_STRUGGLE_NUM_POPS; i++)
{
printf( "The best solution on island %d with score %f was:\n",
i, ga_get_entity_from_rank(pop[i],0)->fitness );
beststring = ga_chromosome_char_to_string(pop[i], ga_get_entity_from_rank(pop[i],0), beststring, &beststrlen);
printf("%s\n", beststring);
ga_extinction(pop[i]);
}
s_free(beststring);
ga_detach_mpi_slaves(); /* Allow all slave processes to continue. */
}
MPI_Finalize();
exit(EXIT_SUCCESS);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//detect and save detected boxes
FLOAT *detect(IplImage *IM,MODEL *MO,FLOAT thresh,int *D_NUMS,FLOAT *A_SCORE)
{
/* for measurement */
struct timeval tv;
struct timeval tv_ini_scales_start, tv_ini_scales_end;
float time_ini_scales;
struct timeval tv_ini_feat_size_start, tv_ini_feat_size_end;
float time_ini_feat_size;
struct timeval tv_get_boxes_start, tv_get_boxes_end;
float time_get_boxes;
struct timeval tv_calc_f_pyramid_start, tv_calc_f_pyramid_end;
float time_calc_f_pyramid = 0;
//for time measurement
clock_t t1,t2,t3;
//initialize scale information for hierachical detection
gettimeofday(&tv_ini_scales_start, NULL);
FLOAT *scales=ini_scales(MO->MI,IM,IM->width,IM->height);
gettimeofday(&tv_ini_scales_end, NULL);
//initialize feature-size matrix
gettimeofday(&tv_ini_feat_size_start, NULL);
int *featsize=ini_featsize(MO->MI);
gettimeofday(&tv_ini_feat_size_end, NULL);
//calculate feature pyramid
t1=clock();
gettimeofday(&tv_calc_f_pyramid_start, NULL);
FLOAT **feature=calc_f_pyramid(IM,MO->MI,featsize,scales);
gettimeofday(&tv_calc_f_pyramid_end, NULL);
tvsub(&tv_calc_f_pyramid_end, &tv_calc_f_pyramid_start, &tv);
time_kernel += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
time_calc_f_pyramid += tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
printf("\n");
printf("calc_f_pyramid %f[ms]\n", time_calc_f_pyramid);
t2=clock();
//detect boundary boxes
gettimeofday(&tv_get_boxes_start, NULL);
FLOAT *boxes = get_boxes(feature,scales,featsize,MO,D_NUMS,A_SCORE,thresh);
gettimeofday(&tv_get_boxes_end, NULL);
t3=clock();
#if 1
// tvsub(&tv_ini_scales_end, &tv_ini_scales_start, &tv);
// time_ini_scales = tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
// tvsub(&tv_ini_feat_size_end, &tv_ini_feat_size_start, &tv);
// time_ini_feat_size = tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
// tvsub(&tv_calc_f_pyramid_end, &tv_calc_f_pyramid_start, &tv);
// time_calc_f_pyramid = tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
// tvsub(&tv_get_boxes_end, &tv_get_boxes_start, &tv);
// time_get_boxes = tv.tv_sec * 1000.0 + (float)tv.tv_usec / 1000.0;
// printf("ini_scales : %f\n", time_ini_scales);
// printf("ini_feat_size : %f\n", time_ini_feat_size);
// printf("calc_f_pyramid : %f\n", time_calc_f_pyramid);
// printf("get_boxes : %f\n", time_get_boxes);
printf("\n");
#endif
s_free(scales); //release scale-information
s_free(featsize); //release feat size information
free_features(feature,MO->MI);
return boxes;
}
static STREAM
cssp_encode_tscspdatadetail(unsigned char keyspec, char *card, char *reader, char *container,
char *csp)
{
STREAM out;
STREAM h1, h2;
struct stream tmp = { 0 };
struct stream message = { 0 };
// keySpec [0]
s_realloc(&tmp, sizeof(uint8));
s_reset(&tmp);
out_uint8(&tmp, keyspec);
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_INTEGER, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
// cardName [1]
if (card)
{
s_realloc(&tmp, 4 + strlen(card) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, card, strlen(card) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 1, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
// readerName [2]
if (reader)
{
s_realloc(&tmp, 4 + strlen(reader) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, reader, strlen(reader) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 2, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
// containerName [3]
if (container)
{
s_realloc(&tmp, 4 + strlen(container) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, container, strlen(container) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 3, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
// cspName [4]
if (csp)
{
s_realloc(&tmp, 4 + strlen(csp) * sizeof(uint16));
s_reset(&tmp);
rdp_out_unistr(&tmp, csp, strlen(csp) * sizeof(uint16));
s_mark_end(&tmp);
h2 = ber_wrap_hdr_data(BER_TAG_OCTET_STRING, &tmp);
h1 = ber_wrap_hdr_data(BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 4, h2);
s_realloc(&message, s_length(&message) + s_length(h1));
out_uint8p(&message, h1->data, s_length(h1));
s_mark_end(&message);
s_free(h2);
s_free(h1);
}
s_mark_end(&message);
// build message
out = ber_wrap_hdr_data(BER_TAG_SEQUENCE | BER_TAG_CONSTRUCTED, &message);
// cleanup
free(tmp.data);
free(message.data);
return out;
}
