static void
folder_restore_session(struct folder_ref_info * ref_info)
{
chashiter * iter;
mailsession * session;
session = ref_info->folder->fld_session;
for(iter = chash_begin(ref_info->msg_hash) ; iter != NULL ;
iter = chash_next(ref_info->msg_hash, iter)) {
chashdatum key;
mailmessage * msg;
chash_key(iter, &key);
memcpy(&msg, key.data, sizeof(msg));
msg->msg_session = session;
if (msg->msg_driver == imap_cached_message_driver) {
struct imap_cached_session_state_data * imap_cached_data;
mailmessage * ancestor_msg;
imap_cached_data = ref_info->folder->fld_session->sess_data;
ancestor_msg = msg->msg_data;
ancestor_msg->msg_session = imap_cached_data->imap_ancestor;
}
}
}
static void storage_disconnect(struct storage_ref_info * ref_info)
{
chashiter * iter;
/* disconnect folders */
while ((iter = chash_begin(ref_info->folder_ref_info)) != NULL) {
chashdatum key;
struct mailfolder * folder;
chash_key(iter, &key);
memcpy(&folder, key.data, sizeof(folder));
storage_folder_disconnect(ref_info, folder);
}
/* disconnect storage */
do_storage_disconnect(ref_info);
}
static int smime_decrypt(struct mailprivacy * privacy,
mailmessage * msg,
struct mailmime * mime, struct mailmime ** result)
{
char smime_filename[PATH_MAX];
char quoted_smime_filename[PATH_MAX];
char description_filename[PATH_MAX];
char decrypted_filename[PATH_MAX];
char command[PATH_MAX];
struct mailmime * description_mime;
struct mailmime * decrypted_mime;
int r;
int res;
int sign_ok;
struct mailmime * multipart;
char * smime_cert;
char * smime_key;
char quoted_smime_cert[PATH_MAX];
char quoted_smime_key[PATH_MAX];
char * email;
chashiter * iter;
/* fetch the whole multipart and write it to a file */
r = mailprivacy_fetch_mime_body_to_file(privacy,
smime_filename, sizeof(smime_filename),
msg, mime);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
/* we are in a safe directory */
r = mailprivacy_get_tmp_filename(privacy, decrypted_filename,
sizeof(decrypted_filename));
if (r != MAIL_NO_ERROR) {
res = MAIL_ERROR_FILE;
goto unlink_smime;
}
/* description */
r = mailprivacy_get_tmp_filename(privacy, description_filename,
sizeof(description_filename));
if (r != MAIL_NO_ERROR) {
res = MAIL_ERROR_FILE;
goto unlink_decrypted;
}
sign_ok = 0;
for(iter = chash_begin(private_keys) ; iter != NULL ;
iter = chash_next(private_keys, iter)) {
chashdatum key;
char email_buf[BUF_SIZE];
chash_key(iter, &key);
if (key.len >= sizeof(email_buf))
continue;
strncpy(email_buf, key.data, key.len);
email_buf[key.len] = '\0';
email = email_buf;
/* get encryption key */
smime_key = get_private_key_file(email);
smime_cert = get_cert_file(email);
if ((smime_cert == NULL) || (smime_key == NULL)) {
res = MAIL_ERROR_INVAL;
goto unlink_description;
}
r = mail_quote_filename(quoted_smime_cert, sizeof(quoted_smime_cert),
smime_cert);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
r = mail_quote_filename(quoted_smime_key, sizeof(quoted_smime_key),
smime_key);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
/* run the command */
r = mail_quote_filename(quoted_smime_filename,
sizeof(quoted_smime_filename), smime_filename);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
sign_ok = 0;
snprintf(command, sizeof(command),
"openssl smime -decrypt -passin fd:0 -in '%s' -inkey '%s' -recip '%s'",
quoted_smime_filename, quoted_smime_key, quoted_smime_cert);
unlink(description_filename);
r = smime_command_passphrase(privacy, msg, command,
email, decrypted_filename, description_filename);
switch (r) {
case NO_ERROR_SMIME:
sign_ok = 1;
break;
case ERROR_SMIME_CHECK:
case ERROR_SMIME_NOPASSPHRASE:
sign_ok = 0;
break;
case ERROR_SMIME_COMMAND:
res = MAIL_ERROR_COMMAND;
goto unlink_description;
case ERROR_SMIME_FILE:
res = MAIL_ERROR_FILE;
goto unlink_description;
}
if (sign_ok) {
break;
}
}
if (!sign_ok) {
if (chash_count(private_keys) == 0) {
FILE * description_f;
description_f = mailprivacy_get_tmp_file(privacy, description_filename,
sizeof(description_filename));
if (description_f == NULL) {
res = MAIL_ERROR_FILE;
goto unlink_decrypted;
}
fprintf(description_f, SMIME_DECRYPT_FAILED);
fclose(description_f);
}
}
else {
mailprivacy_smime_encryption_id_list_clear(privacy, msg);
}
/* building multipart */
r = mailmime_new_with_content("multipart/x-decrypted", NULL, &multipart);
if (r != MAILIMF_NO_ERROR) {
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
/* building the description part */
description_mime = mailprivacy_new_file_part(privacy,
description_filename,
"text/plain", MAILMIME_MECHANISM_8BIT);
if (description_mime == NULL) {
mailprivacy_mime_clear(multipart);
mailmime_free(multipart);
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
/* adds the description part */
r = mailmime_smart_add_part(multipart, description_mime);
if (r != MAIL_NO_ERROR) {
mailprivacy_mime_clear(description_mime);
mailmime_free(description_mime);
mailprivacy_mime_clear(multipart);
mailmime_free(multipart);
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
/* building the decrypted part */
r = mailprivacy_get_part_from_file(privacy, 1, 0,
decrypted_filename, &decrypted_mime);
if (r == MAIL_NO_ERROR) {
/* adds the decrypted part */
r = mailmime_smart_add_part(multipart, decrypted_mime);
if (r != MAIL_NO_ERROR) {
mailprivacy_mime_clear(decrypted_mime);
mailmime_free(decrypted_mime);
mailprivacy_mime_clear(multipart);
mailmime_free(multipart);
res = MAIL_ERROR_MEMORY;
goto unlink_description;
}
}
unlink(description_filename);
unlink(decrypted_filename);
unlink(smime_filename);
* result = multipart;
return MAIL_NO_ERROR;
unlink_description:
unlink(description_filename);
unlink_decrypted:
unlink(decrypted_filename);
unlink_smime:
unlink(smime_filename);
err:
return res;
}
static void nearCB(void *data, dGeomID o1, dGeomID o2)
{
ODEObj *odeobj1 = ODEObjectContainer::getInstance()->getODEObjFromGeomID(o1);
ODEObj *odeobj2 = ODEObjectContainer::getInstance()->getODEObjFromGeomID(o2);
/*
SSimRobotEntity *ent1 = ODEObjectContainer::getInstance()->getSSimRobotEntityFromGeomID(o1);
SSimRobotEntity *ent2 = ODEObjectContainer::getInstance()->getSSimRobotEntityFromGeomID(o2);
if(ent1 != NULL && ent2 != NULL && ent1->name() == ent2->name()){
//LOG_MSG(("name (%s, %s)",ent1->name().c_str(), ent2->name().c_str()));
return;
}
*/
SParts *p1 = NULL;
SParts *p2 = NULL;
dBodyID b1 = dGeomGetBody(o1);
dBodyID b2 = dGeomGetBody(o2);
if (b1 == b2) {
return;
}
ODEWorld *world = ODEWorld::get();
dGeomID ground = world->getGround();
if (b1 && b2) {
if (dAreConnected(b1, b2)) {
return;
}
}
if (b1) {
void *d = dBodyGetData(b1);
if (d) {
p1 = (SParts*)d;
if (p1->isBlind()) { return; }
}
}
if (b2) {
void *d = dBodyGetData(b2);
if (d) {
p2 = (SParts*)d;
if (p2->isBlind()) { return; }
}
}
if (p1 && p2 && p1->sameParent(*p2)) { return; }
if (dGeomIsSpace(o1) && dGeomIsSpace(o2)) {
dSpaceCollide2(o1, o2, data, &collideCB);
return;
}
#define F_SCHOLAR(V) sqrt(V[0]*V[0] + V[1]*V[1] + V[2]*V[2])
static dJointFeedback fb;
#define MAX_COLLISION 32
const int N = MAX_COLLISION;
dContact contacts[N];
int n = dCollide(o1, o2, N, &(contacts[0].geom), sizeof(contacts[0]));
if (n > 0) {
ODEWorld *world = ODEWorld::get();
for (int i=0; i<n; i++) {
dContact *c = &contacts[i];
dContactGeom &g = c->geom;
if (p1 && p2) {
#if 0
LOG_SYS(("Collision #%d/%d %s(geomID=%d) <-> %s(geomID=%d)", i, n,
p1->getParent()->name(), o1,
p2->getParent()->name(), o2));
LOG_SYS(("\tpos = (%f, %f, %f)", g.pos[0], g.pos[1], g.pos[2]));
LOG_SYS(("\tnormal = (%f, %f, %f)", g.normal[0], g.normal[1], g.normal[2]));
LOG_SYS(("\tfdir = (%f, %f, %f)", c->fdir1[0], c->fdir1[1], c->fdir1[2]));
LOG_SYS(("\tdepth = %f", g.depth));
#endif
const char *name1 = p1->getParent()->name();
const char *name2 = p2->getParent()->name();
std::string key = chash_key(name1, name2);
if (key.length() <= 0) { continue; }
if (chash_find(key)) { continue; }
s_chash[key] = true;
s_collisions.push_back(ODEWorld::Collision(name1, name2, p1->name(), p2->name()));
// Set the collision flag to be ON
p1->setOnCollision(true);
p2->setOnCollision(true);
}
//c->surface.mode = dContactBounce;
c->surface.mode = dContactSlip1 | dContactSlip2 | dContactSoftERP | dContactSoftCFM | dContactApprox1 | dContactBounce;
//c->surface.mode = dContactSlip1 | dContactSoftERP | dContactSoftCFM | dContactApprox1 | dContactBounce;
//
// Reflection of material parameters of the collided object
// Fliction force should be regarded as average of contiguous material (???)
// TODO: Calclation of fliction force sould be considered
//
#if 0
if (odeobj1 && odeobj2) {
c->surface.mu = ( odeobj1->getMu1() + odeobj2->getMu1() ) / 2.0;
c->surface.mu2 = ( odeobj1->getMu2() + odeobj2->getMu2() ) / 2.0;
c->surface.slip1 = ( odeobj1->getSlip1() + odeobj2->getSlip1() ) / 2.0;
c->surface.slip2 = ( odeobj1->getSlip2() + odeobj2->getSlip2() ) / 2.0;
c->surface.soft_erp = ( odeobj1->getSoftErp() + odeobj2->getSoftErp() ) / 2.0;
c->surface.soft_cfm = ( odeobj1->getSoftCfm() + odeobj2->getSoftCfm() ) / 2.0;
c->surface.bounce = ( odeobj1->getBounce() + odeobj2->getBounce() ) / 2.0;
}
else {
c->surface.bounce_vel = world->getCollisionParam("bounce_vel");
c->surface.bounce = world->getCollisionParam("bounce");
c->surface.mu = world->getCollisionParam("mu");
c->surface.mu2 = world->getCollisionParam("mu2");
c->surface.slip1 = world->getCollisionParam("slip1");
c->surface.slip2 = world->getCollisionParam("slip2");
c->surface.soft_erp = world->getCollisionParam("soft_erp");
c->surface.soft_cfm = world->getCollisionParam("soft_cfm");
}
#else
c->surface.mu = SPARTS_MU1;
c->surface.mu2 = SPARTS_MU2;
c->surface.slip1 = SPARTS_SLIP1;
c->surface.slip2 = SPARTS_SLIP2;
c->surface.soft_erp = SPARTS_ERP; // parameter for modify the error of Joint position (0..1); if it is 1, modification will be perfect
c->surface.soft_cfm = SPARTS_CFM; // If this value=0, joint velocity is strange
c->surface.bounce = SPARTS_BOUNCE; // is a little smaller than ball
c->surface.bounce_vel = 0.0;
#endif
dJointID cj = dJointCreateContact(world->world(), world->jointGroup(), c);
//dJointAttach(cj, dGeomGetBody(o1), dGeomGetBody(o2)); //by MSI
dJointAttach(cj, dGeomGetBody(c->geom.g1), dGeomGetBody(c->geom.g2)); // by Demura.net
#if 0
if (p1 && p2) {
dJointSetFeedback(cj, &fb);
dJointFeedback *pfb = dJointGetFeedback(cj);
if (F_SCHOLAR(pfb->f1) > 1.0) {
LOG_SYS(("\tF1 = (%f, %f, %f)", pfb->f1[0], pfb->f1[1], pfb->f1[2]));
LOG_SYS(("\tF2 = (%f, %f, %f)\n", pfb->f2[0], pfb->f2[1], pfb->f2[2]));
}
}
#endif
}
}
}
static int folder_update_msg_list(struct folder_ref_info * ref_info,
struct mailmessage_list ** p_new_msg_list,
struct mailmessage_list ** p_lost_msg_list)
{
int r;
int res;
struct mailmessage_list * new_env_list;
unsigned int i;
carray * lost_msg_tab;
struct mailmessage_list * lost_msg_list;
unsigned int free_start_index;
chashiter * iter;
unsigned int lost_count;
r = mailfolder_get_messages_list(ref_info->folder, &new_env_list);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
for(iter = chash_begin(ref_info->msg_hash) ; iter != NULL ;
iter = chash_next(ref_info->msg_hash, iter)) {
struct message_ref_elt * msg_ref;
chashdatum data;
chash_value(iter, &data);
msg_ref = data.data;
msg_ref->lost = 1;
}
lost_count = chash_count(ref_info->msg_hash);
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
mailmessage * old_msg;
msg = carray_get(new_env_list->msg_tab, i);
if (msg->msg_uid == NULL)
continue;
old_msg = folder_info_get_msg_by_uid(ref_info, msg->msg_uid);
if (old_msg != NULL) {
struct message_ref_elt * msg_ref;
/* replace old message */
old_msg->msg_index = msg->msg_index;
carray_set(new_env_list->msg_tab, i, old_msg);
mailmessage_free(msg);
msg_ref = folder_info_get_msg_ref(ref_info, old_msg);
msg_ref->lost = 0;
lost_count --;
}
else {
/* set new message */
r = folder_message_add(ref_info, msg);
if (r != MAIL_NO_ERROR) {
free_start_index = i;
res = r;
goto free_remaining;
}
}
}
/* build the table of lost messages */
lost_msg_tab = carray_new(lost_count);
if (lost_msg_tab == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_env_list;
}
carray_set_size(lost_msg_tab, lost_count);
i = 0;
for(iter = chash_begin(ref_info->msg_hash) ; iter != NULL ;
iter = chash_next(ref_info->msg_hash, iter)) {
struct message_ref_elt * msg_ref;
chashdatum key;
chashdatum value;
mailmessage * msg;
chash_key(iter, &key);
memcpy(&msg, key.data, sizeof(msg));
chash_value(iter, &value);
msg_ref = value.data;
if (msg_ref->lost) {
carray_set(lost_msg_tab, i, msg);
i ++;
}
}
lost_msg_list = mailmessage_list_new(lost_msg_tab);
if (lost_msg_list == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_lost_msg_tab;
}
/* reference messages */
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(new_env_list->msg_tab, i);
folder_message_ref(ref_info, msg);
}
* p_new_msg_list = new_env_list;
* p_lost_msg_list = lost_msg_list;
return MAIL_NO_ERROR;
free_lost_msg_tab:
carray_free(lost_msg_tab);
free_env_list:
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
struct message_ref_elt * msg_ref;
msg = carray_get(new_env_list->msg_tab, i);
msg_ref = folder_info_get_msg_ref(ref_info, msg);
if (msg_ref != NULL) {
if (msg_ref->ref_count == 0)
folder_message_remove(ref_info, msg);
}
}
carray_set_size(new_env_list->msg_tab, 0);
mailmessage_list_free(new_env_list);
goto err;
free_remaining:
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
struct message_ref_elt * msg_ref;
msg = carray_get(new_env_list->msg_tab, i);
msg_ref = folder_info_get_msg_ref(ref_info, msg);
if (msg_ref != NULL) {
if (msg_ref->ref_count == 0)
folder_message_remove(ref_info, msg);
}
}
for(i = free_start_index ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(new_env_list->msg_tab, i);
mailmessage_free(msg);
}
carray_set_size(new_env_list->msg_tab, 0);
mailmessage_list_free(new_env_list);
err:
return res;
}
