static SAMPLE_VGM *cross_covariogram(DATA *a, DATA *b, SAMPLE_VGM *ev) {
int i, j, index = 0;
unsigned long uli, ulj;
double gamma, ddist;
ev->evt = CROSSCOVARIOGRAM;
ev = alloc_exp_variogram(a, b, ev);
for (i = 0; i < a->n_list; i++) { /* i -> a */
for (j = 0; j < b->n_list; j++) { /* j -> b */
ddist = valid_distance(a->list[i], b->list[j], ev->cutoff,
gl_sym_ev, a, b, (GRIDMAP *) ev->map);
if (ddist >= 0.0) {
if (! ev->cloud) {
index = get_index(ddist, ev);
ev->gamma[index] += a->list[i]->attr * b->list[j]->attr;
ev->dist[index] += ddist;
ev->pairs[index] = register_pairs(ev->pairs[index],
ev->nh[index], a->list[i], b->list[j]);
ev->nh[index]++;
} else if (! (ev->zero == ZERO_AVOID && ddist == 0.0)) {
gamma = a->list[i]->attr * b->list[j]->attr;
uli = i;
ulj = j;
push_to_cloud(ev, gamma, ddist, TO_NH(uli,ulj));
}
}/* if ddist >= 0 */
} /* for j */
} /* for i */
divide(ev);
ev->recalc = 0;
return ev;
} /* cross_covariogram() */
/* covariograms: */
static SAMPLE_VGM *covariogram(DATA *d, SAMPLE_VGM *ev) {
int i, j, index = 0;
unsigned long uli, ulj;
double gamma, ddist;
ev->evt = COVARIOGRAM;
ev = alloc_exp_variogram(d, NULL, ev);
for (i = 0; i < d->n_list; i++) {
for (j = 0; j <= (ev->map != NULL ? d->n_list-1 : i); j++) {
ddist = valid_distance(d->list[i], d->list[j], ev->cutoff, 1,
d, d, (GRIDMAP *) ev->map);
if (ddist >= 0.0) {
if (! ev->cloud) {
index = get_index(ddist, ev);
ev->gamma[index] += d->list[i]->attr * d->list[j]->attr;
#ifdef ADJUST_VARIANCE
if (d->colnvariance && i == j)
ev->gamma[index] -= d->list[i]->variance;
#endif
ev->dist[index] += ddist;
ev->pairs[index] = register_pairs(ev->pairs[index],
ev->nh[index], d->list[i], d->list[j]);
ev->nh[index]++;
} else {
if (! (ev->zero == ZERO_AVOID && ddist == 0.0)) {
gamma = d->list[i]->attr * d->list[j]->attr;
#ifdef ADJUST_VARIANCE
if (d->colnvariance && i == j)
gamma -= d->list[i]->variance;
#endif
uli = i;
ulj = j;
push_to_cloud(ev, gamma, ddist, TO_NH(uli,ulj));
}
}
}/* if ddist >= 0 */
} /* for j */
} /* for i */
divide(ev);
ev->recalc = 0;
return ev;
} /* covariogram() */
static SAMPLE_VGM *cross_variogram(DATA *a, DATA *b, SAMPLE_VGM *ev) {
int i, j, index = 0;
unsigned long uli, ulj;
double gamma, ddist;
ev->evt = CROSSVARIOGRAM;
ev = alloc_exp_variogram(a, b, ev);
for (i = 0; i < a->n_list; i++) {
for (j = 0; j < b->n_list; j++) {
ddist = valid_distance(a->list[i], b->list[j], ev->cutoff,
gl_sym_ev || !ev->pseudo, a, b, (GRIDMAP *) ev->map);
if (ddist >= 0.0) {
if (!ev->pseudo && i != j) {
if (! ev->cloud) {
index = get_index(ddist, ev);
ev->gamma[index] +=
(a->list[i]->attr - a->list[j]->attr) *
(b->list[i]->attr - b->list[j]->attr);
ev->dist[index] += ddist;
ev->pairs[index] = register_pairs(ev->pairs[index],
ev->nh[index], a->list[i], a->list[j]);
ev->nh[index]++;
} else if (!(ddist == 0.0 && ev->zero == ZERO_AVOID)) {
gamma = (a->list[i]->attr - a->list[j]->attr) *
(b->list[i]->attr - b->list[j]->attr);
uli = i;
ulj = j;
push_to_cloud(ev, gamma / 2.0, ddist, TO_NH(uli,ulj));
}
} else if (ev->pseudo) {
if (! ev->cloud) {
index = get_index(ddist, ev);
ev->gamma[index] +=
SQR(a->list[i]->attr - b->list[j]->attr);
#ifdef ADJUST_VARIANCE
if (a->colnvariance || b->colnvariance)
ev->gamma[index] -= a->list[i]->variance +
b->list[j]->variance;
#endif
ev->dist[index] += ddist;
ev->pairs[index] = register_pairs(ev->pairs[index],
ev->nh[index], a->list[i], b->list[j]);
ev->nh[index]++;
} else if (! (ev->zero == ZERO_AVOID && ddist == 0.0)) {
gamma = SQR(a->list[i]->attr - b->list[j]->attr);
#ifdef ADJUST_VARIANCE
if (a->colnvariance || b->colnvariance)
gamma -= a->list[i]->variance + b->list[j]->variance;
#endif
uli = i;
ulj = j;
push_to_cloud(ev, gamma / 2.0, ddist, TO_NH(uli,ulj));
}
}
}/* if ddist >= 0 */
} /* for j */
} /* for i */
divide(ev);
ev->recalc = 0;
return ev;
} /* cross_variogram */
static SAMPLE_VGM *semivariogram_grid(DATA *d, SAMPLE_VGM *ev) {
typedef struct {
int row, col, ev_index;
double dist;
} grid_index;
struct {
int n;
grid_index *gi;
} grid_ev;
int row, col, irow, icol, i, max_index, index;
unsigned long ula, ulb;
double gamma, ddist;
DPOINT a, b, *dpa = NULL, *dpb = NULL;
max_index = floor(ev->cutoff / SQUARECELLSIZE(d->grid));
grid_ev.gi = (grid_index *) emalloc(2 * (max_index + 1) * (max_index + 1)
* sizeof(grid_index));
grid_ev.n = 0;
a.x = a.y = a.z = 0;
/* setup the grid: */
for (row = 0; row <= max_index; row++) {
for (col = (row == 0 ? 1 : -max_index); col <= max_index; col++) {
b.x = col * SQUARECELLSIZE(d->grid);
b.y = row * SQUARECELLSIZE(d->grid);
ddist = valid_distance(&a, &b, ev->cutoff, 1,
d, d, (GRIDMAP *) ev->map);
if (ddist > 0.0) {
grid_ev.gi[grid_ev.n].row = row;
grid_ev.gi[grid_ev.n].col = col;
grid_ev.gi[grid_ev.n].dist = ddist;
if (! ev->cloud)
grid_ev.gi[grid_ev.n].ev_index = get_index(ddist, ev);
if (DEBUG_DUMP)
printlog("row %d col %d index %d\n",
row, col, grid_ev.gi[grid_ev.n].ev_index);
grid_ev.n++;
}
}
}
print_progress(0, d->grid->rows);
for (row = 0; row < d->grid->rows; row++) {
for (col = 0; col < d->grid->cols; col++) {
if ((dpa = d->grid->dpt[row][col]) != NULL) {
for (i = 0; i < grid_ev.n; i++) {
irow = row + grid_ev.gi[i].row;
icol = col + grid_ev.gi[i].col;
if (irow >= 0 && icol >= 0 && irow < d->grid->rows
&& icol < d->grid->cols
&& ((dpb = d->grid->dpt[irow][icol]) != NULL)) {
ddist = grid_ev.gi[i].dist;
if (! ev->cloud) {
index = grid_ev.gi[i].ev_index;
if (gl_cressie) /* sqrt abs diff */
ev->gamma[index] +=
sqrt(fabs(dpa->attr - dpb->attr));
else {
ev->gamma[index] += SQR(dpa->attr - dpb->attr);
#ifdef ADJUST_VARIANCE
if (d->colnvariance)
ev->gamma[index] -= dpa->variance +
dpb->variance;
#endif
}
ev->dist[index] += ddist;
ev->pairs[index] = register_pairs(ev->pairs[index],
ev->nh[index], dpa, dpb);
ev->nh[index]++;
} else { /* cloud: */
if (gl_cressie)
gamma = sqrt(fabs(dpa->attr - dpb->attr));
else
gamma = SQR(dpa->attr - dpb->attr);
#ifdef ADJUST_VARIANCE
if (d->colnvariance)
gamma -= dpa->variance + dpb->variance;
#endif
ula = GET_INDEX(dpa);
ulb = GET_INDEX(dpb);
push_to_cloud(ev, gamma / 2.0, ddist, TO_NH(ula,ulb));
} /* else !cloud */
} /* if we have two non-NULL points */
} /* for all possibly relevant pairs */
} /* if this grid cell is non-NULL */
} /* for all cols */
print_progress(row + 1, d->grid->rows);
} /* for all rows */
efree(grid_ev.gi);
return ev;
}
static SAMPLE_VGM *semivariogram_list(DATA *d, SAMPLE_VGM *ev) {
unsigned long uli, ulj;
int i, j, index = 0, divide_by = 1;
unsigned int total_steps;
double gamma, ddist;
while (d->n_sel / divide_by > sqrt(INT_MAX))
divide_by <<= 1; /* prevent overflow on calculating total_steps */
total_steps = (d->n_sel / divide_by) * (d->n_sel - 1) / 2;
print_progress(0, total_steps);
if (DEBUG_DUMP)
printlog("Calculating semivariogram from %d points...\n", d->n_sel);
for (i = 0; i < d->n_sel; i++) {
print_progress((i / divide_by) * (i - 1) / 2, total_steps);
/*
printlog("step: %u of %u\n", (i /divide_by) * (i - 1) / 2, total_steps);
*/
for (j = 0; j < (ev->map != NULL ? d->n_sel : i); j++) {
ddist = valid_distance(d->sel[i], d->sel[j], ev->cutoff, 1,
d, d, (GRIDMAP *) ev->map);
if (ddist >= 0.0 && i != j) {
if (! ev->cloud) {
index = get_index(ddist, ev);
if (gl_cressie) /* sqrt abs diff */
ev->gamma[index] +=
sqrt(fabs(d->sel[i]->attr - d->sel[j]->attr));
else {
ev->gamma[index] +=
SQR(d->sel[i]->attr - d->sel[j]->attr);
#ifdef ADJUST_VARIANCE
if (d->colnvariance)
ev->gamma[index] -= d->sel[i]->variance +
d->sel[j]->variance;
#endif
}
ev->dist[index] += ddist;
if (d->sel == d->list)
ev->pairs[index] = register_pairs(ev->pairs[index],
ev->nh[index], d->sel[i], d->sel[j]);
ev->nh[index]++;
} else { /* cloud: */
if (! (ev->zero == ZERO_AVOID && ddist == 0.0)) {
if (gl_cressie)
gamma = sqrt(fabs(d->sel[i]->attr - d->sel[j]->attr));
else
gamma = SQR(d->sel[i]->attr - d->sel[j]->attr);
#ifdef ADJUST_VARIANCE
if (d->colnvariance)
gamma -= d->sel[i]->variance + d->sel[j]->variance;
#endif
uli = i; ulj = j;
push_to_cloud(ev, gamma / 2.0, ddist, TO_NH(uli,ulj));
}
}
}/* if ddist >= 0 */
} /* for j */
} /* for i */
print_progress(total_steps, total_steps);
if (DEBUG_DUMP)
printlog("ready\n");
return ev;
}
/***************************************************************************
Function: modify_alias
Description: read old alias and check, write new alias to alias.conf & push to cloud server
Input: cgi_result, the return value of cgiFormString
old_alias_str, null terminated, not check yet
new_alias_str, null terminated, already check
Output:
Return: 0 OK, other Error
Others: none
***************************************************************************/
int modify_alias(cgiFormResultType cgi_result, const char * old_alias_str, const char * new_alias_str)
{
int fd_alias;
char gateway_alias[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1];
int res;
int len, tries = 5;
int mqid;
struct client_admin_msgbuf mesg;
fd_alias = open(FEATURE_GDGL_ALIAS_PATH, O_RDWR, 0777);
if (fd_alias < 0) {
return clientAdminAliasFileOpenErr;
}
res = write_lock(fd_alias, 0, SEEK_SET, 0);
if (res == -1) {
close(fd_alias);
return clientAdminAliasFileLockErr;
}
// Read old alias
res = read(fd_alias, gateway_alias, FEATURE_GDGL_ACCOUNT_MAX_LEN);
if (res < 0) {
close(fd_alias);
return clientAdminAliasFileReadErr;
}
gateway_alias[res] = '\0';
//add yanly150625
if((gateway_alias[res-1] == 0x0a)||(gateway_alias[res-1] == 0x0d)) { //如果最后一个字符等于换行符号或者回车键，就换成结束符
gateway_alias[res-1] = '\0';
}
// Check old alias
res = check_alias(cgi_result, old_alias_str, gateway_alias);
if (res != 0) {
close(fd_alias);
return res;
}
// Check if old == new
if (strcmp(old_alias_str, new_alias_str) == 0) {
close(fd_alias);
return clientAdminTwoAliasEqualErr;
}
// Push to cloud
//if push failed, return push error
if ( (res = push_to_cloud(modifyAliasType, "modifyalias", old_alias_str, new_alias_str)) < 0 ) {
close(fd_alias);
return clientAdminPushToCloudErr;
}
else if (res > 0) {
close(fd_alias);
return res;
}
// Write new alias
len = strlen(new_alias_str);
while (tries > 0) {
// seek to beginning of file
res = lseek(fd_alias, 0, SEEK_SET);
if (res < 0) {
close(fd_alias);
return clientAdminAliasFileSeekErr;
}
// truncate the file to 0 byte
res = ftruncate(fd_alias, 0);
if (res < 0) {
close(fd_alias);
return clientAdminAliasFileTruncErr;
}
res = writen(fd_alias, new_alias_str, len);
if (res != len) {
tries--;
}
else {
break;
}
}
if (tries == 0) {
close(fd_alias);
return clientAdminAliasFileWriteErr;
}
close(fd_alias); //also unlock
// Send IPC msg
mqid = msgget(CLIENTADMIN_MQ_KEY, 0);
if (mqid == -1) {
CA_DEBUG("msgget error %d:%s\n", mqid, strerror(errno));
}
else {
len = construct_msg(clientAdmintMsgAlias, new_alias_str, &mesg);
if (len > 0) {
res = msgsnd(mqid, &mesg, len, 0);
if (res == -1) {
CA_DEBUG("msgsnd error %s\n", strerror(errno));
}
}
}
return 0;
}
/***************************************************************************
Function: modify_password
Description: read old password and check, write new password to password.conf & push to cloud server
Input: cgi_result, the return value of cgiFormString
old_passwd_str, null terminated, not check yet
new_passwd_str, null terminated, already check
Output:
Return: 0 OK, other Error
Others: none
***************************************************************************/
int modify_password(cgiFormResultType cgi_result, const char * old_passwd_str, const char * new_passwd_str)
{
int fd_passwd;
char gateway_passwd[FEATURE_GDGL_PASSWD_MAX_LEN + 1];
int res;
int len, tries = 5;
int mqid;
struct client_admin_msgbuf mesg;
fd_passwd = open(FEATURE_GDGL_PASSWD_PATH, O_RDWR, 0777);
if (fd_passwd < 0) {
return clientAdminPasswdFileOpenErr;
}
res = write_lock(fd_passwd, 0, SEEK_SET, 0);
if (res == -1) {
close(fd_passwd);
return clientAdminPasswdFileLockErr;
}
// Read old password
res = read(fd_passwd, gateway_passwd, FEATURE_GDGL_PASSWD_MAX_LEN);
if (res < 0) {
close(fd_passwd);
return clientAdminPasswdFileReadErr;
}
gateway_passwd[res] = '\0';
if((gateway_passwd[res-1] == 0x0a)||(gateway_passwd[res-1] == 0x0d)) { //如果最后一个字符等于换行符号或者回车键
gateway_passwd[res-1] = '\0';
}
// Check old password
res = check_password(cgi_result, old_passwd_str, gateway_passwd);
if (res != 0) {
close(fd_passwd);
return res;
}
// Check if old == new
if (strcmp(old_passwd_str, new_passwd_str) == 0) {
close(fd_passwd);
return clientAdminTwoPasswdEqualErr;
}
// Push to cloud
//if push failed, return push error
if ( (res = push_to_cloud(modifyPasswordType, "modifypassword", old_passwd_str, new_passwd_str)) < 0 ) {
close(fd_passwd);
return clientAdminPushToCloudErr;
}
else if (res > 0) {
close(fd_passwd);
return res;
} //debug yan
// Write new password
len = strlen(new_passwd_str);
while (tries > 0) {
// seek to beginning of file
res = lseek(fd_passwd, 0, SEEK_SET);
if (res < 0) {
close(fd_passwd);
return clientAdminPasswdFileSeekErr;
}
// truncate the file to 0 byte
res = ftruncate(fd_passwd, 0);
if (res < 0) {
close(fd_passwd);
return clientAdminPasswdFileTruncErr;
}
res = writen(fd_passwd, new_passwd_str, len);
if (res != len) {
tries--;
}
else {
break;
}
}
// ����ظ���Ȼʧ�ܣ���ʱ�����ϴ洢����Ϣ������ģ�Ӧ����ô����????
if (tries == 0) {
close(fd_passwd);
return clientAdminPasswdFileWriteErr;
}
close(fd_passwd); //also unlock
// Send IPC msg
mqid = msgget(CLIENTADMIN_MQ_KEY, 0);
if (mqid == -1) {
CA_DEBUG("msgget error %d:%s\n", mqid, strerror(errno));
}
else {
len = construct_msg(clientAdmintMsgPassword, new_passwd_str, &mesg);
if (len > 0) {
res = msgsnd(mqid, &mesg, len, 0);
if (res == -1) {
CA_DEBUG("msgsnd error %s\n", strerror(errno));
}
}
}
return 0;
}
