void AttachArea::undeleteLastDeletedAttachment( DtMailEnv &mail_error ) { Attachment *tmpAttachment; Attachment **list; time_t time_deleted = 0, tmpTime = 0; int i; if (_deleteCount == 0) { return; } list = getList(); tmpAttachment = list[0]; time_deleted = tmpAttachment->getBodyPart()->getDeleteTime(mail_error); if (mail_error.isSet()) { // do something } for (i=1; i<getIconCount(); i++) { if (list[i]->isDeleted()) { tmpTime = list[i]->getBodyPart()->getDeleteTime(mail_error); if (mail_error.isSet()) { // do something } if ( tmpTime > time_deleted) { time_deleted = tmpTime; tmpAttachment = list[i]; } } } tmpAttachment->undeleteIt(); _deleteCount--; // Unmanage all. // Their positions need to get recomputed and the deleted // ones get remanaged in manageList(). for (i=0; i<getIconCount(); i++) { list[i]->unmanageIconWidget(); } this->manageList(); }
void RFCFormat::msgToBuffer(DtMailEnv & error, DtMail::Message & msg, DtMailBoolean include_content_length, DtMailBoolean include_unix_from, DtMailBoolean, Buffer & headers, Buffer & body) { error.clear(); _use_cr = DTM_TRUE; if (include_content_length || include_unix_from) { _use_cr = DTM_FALSE; } // We will format the bodies first, then the headers. The // reason we do this is that the result of formatting the body // is required for the headers. The content-type, content-length, // and other content based headers need to be computed before // being written. // char * extra_headers = NULL; formatBodies(error, msg, include_content_length, &extra_headers, body); if (error.isSet()) { return; } formatHeaders(error, msg, include_unix_from, extra_headers, headers); free(extra_headers); return; }
boolean_t handleError (DtMailEnv &dterror, char *msg) { if (dterror.isSet () == DTM_TRUE) { fprintf (stderr, "dtmailpr: (%s) %s\n", msg, (const char *)dterror); dterror.logError (DTM_FALSE, "dtmailpr: (%s) %s\n", msg, (const char *)dterror); dterror.clear (); return B_TRUE; } dterror.clear (); return B_FALSE; }
char * DmxMsg::getHeaders (DtMailBoolean abbreviated_only) { DtMailEnv error; DtMail::Session *m_session = theRoamApp.session()->session(); DtMail::MailRc *mail_rc = m_session->mailRc(error); DtMail::Envelope *env = message->getEnvelope(error); DtMailHeaderHandle hdr_hnd; char *name; DtMailValueSeq value; // Code from MsgScrollingList - display_message(). // We're trying to reduce heap size by not allocating and // deleting space in every loop iteration. So just have a // fixed size buffer initially. // // Initial line size. When not enough, allocate more. int buffer_size = 2048; char *buffer = new char [buffer_size]; int count = 0; int hdr_num = 0; char *newline = "\n"; char *separator = ": "; int val = 0; // // Iterate through each header in the message and add it // to the buffer. // for (hdr_hnd = env->getFirstHeader(error, &name, value), *buffer = '\0'; hdr_hnd && !error.isSet(); hdr_hnd = env->getNextHeader(error, hdr_hnd, &name, value), hdr_num++) { if (abbreviated_only == DTM_TRUE && (hdr_num != 0 || strcmp(name, "From") != 0)) { DtMailEnv ierror; if (mail_rc->ignore(ierror, name)) { free(name); value.clear(); continue; } } for (val=0; val<value.length(); val++) count += strlen(name) + strlen(*(value[val])) + strlen(separator) + strlen(newline) + 1; if (count > buffer_size) { // Need to increase buffer size. char *new_buffer; buffer_size *= 2; new_buffer = new char [buffer_size]; memset(new_buffer, 0, buffer_size); strcpy(new_buffer, buffer); delete [] buffer; buffer = new_buffer; } for (val=0; val<value.length(); val++) { strcat(buffer, name); if (hdr_num != 0 || strcmp(name, "From") != 0) strcat(buffer, separator); else strcat(buffer, " "); strcat(buffer, *(value[val])); strcat(buffer, newline); } value.clear(); free(name); } // // Need to free this after using; // return buffer; }
void RFCFormat::writeHeaders(DtMailEnv & error, DtMail::Message & msg, DtMailBoolean include_unix_from, const char * extra_headers, const char ** suppress_headers, Buffer & buf) { error.clear(); // First we copy each header from the message to the // buffer. The headers may need encoding to put them away, so // we will apply RFC1522 if necessary. // DtMailHeaderHandle hnd; DtMail::Envelope * env = msg.getEnvelope(error); if (error.isSet()) { return; } char * name = NULL; DtMailValueSeq value; hnd = env->getFirstHeader(error, &name, value); if (!hnd || error.isSet()) { return; } if (include_unix_from && (error.isSet() || strcmp(name, "From") != 0)) { // We require a Unix from line, and we don't have one. // we will make one up using the sender, and the current // date. // char *unix_from = new char[100]; strcpy(unix_from, "From "); DtMailValueSeq sender; env->getHeader(error, DtMailMessageSender, DTM_TRUE, sender); if (error.isSet()) { // We no longer know who this is really from. // strcat(unix_from, "nobody@nowhere"); } else { DtMailAddressSeq * addrSeq = sender[0]->toAddress(); strcat(unix_from, (*addrSeq)[0]->dtm_address); delete addrSeq; } error.clear(); time_t now = time(NULL); char time_format[30]; SafeCtime(&now, time_format, sizeof(time_format)); strcat(unix_from, " "); strcat(unix_from, time_format); buf.appendData(unix_from, strlen(unix_from)); delete [] unix_from; } else { // Put out any header, except Unix From line // if (strcmp(name, "From") == 0) { value.clear(); free(name); hnd = env->getNextHeader(error, hnd, &name, value); } } for (; // First time is determined above. hnd && !error.isSet(); value.clear(), hnd = env->getNextHeader(error, hnd, &name, value)) { const char **hdr; for (hdr = suppress_headers; *hdr; hdr++) { if (strcasecmp(name, *hdr) == 0) break; } //add _is_write_bcc for fixing aix defect 177096 if (*hdr || strcasecmp(name, "bcc") == 0 && !_is_write_bcc ) { free(name); continue; // We will generate these headers. } int name_len = strlen(name); for (int val = 0; val < value.length(); val++) { // // If the value is null or empty do not emit this field const char *valPtr; for (valPtr = *(value[val]); *valPtr && (isspace((unsigned char)*valPtr)); valPtr++) {} if (!*valPtr) continue; buf.appendData(name, name_len); buf.appendData(": ", 2); rfc1522cpy(buf, *(value[val])); } free(name); } error.clear(); buf.appendData(extra_headers, strlen(extra_headers)); // Add new line that terminates the headers. // crlf(buf); }
DtMail::Session::Session(DtMailEnv & error, const char * app_name) : _events(16), _valid_keys(2048) { _DtMutex = MutexInit(); error.clear(); _object_signature = 0; _cur_key = 0; // Create the ToolTalk session for managing file locking, // if one doesn't exist. _tt_channel = tt_default_procid(); if (tt_pointer_error(_tt_channel) != TT_OK) { _tt_channel = ttdt_open(&_tt_fd, app_name, "SunSoft", "%I", 0); if (tt_pointer_error(_tt_channel) != TT_OK) { error.setError(DTME_TTFailure); DebugPrintf(1, "DtMail::createSession - ttdt_open returns %s\n", tt_status_message(tt_pointer_error(_tt_channel))); return; } } else { _tt_fd = tt_fd(); } // The event_fd is how we allow async behavior to occur in a // compatible way. We use a Unix domain socket as the file descriptor. // The client will watch for activity on this file descriptor, and // call our event routine when there is activity (either from XtMainLoop, // or through some other method). // pipe(_event_fd); _app_name = strdup(app_name); DtMailEnv b_error; _mail_rc = new MailRc(error, this); buildImplTable(error); if (error.isSet()) { return; } _obj_mutex = MutexInit(); // The default implementation is specified via the DEFAULT_BACKEND // variable. If this is not set in the .mailrc, then choose entry // zero. // const char * value; _mail_rc->getValue(b_error, "DEFAULT_BACKEND", &value); if (b_error.isNotSet()) { _default_impl = lookupImpl(value); if (_default_impl < 0) { _default_impl = 0; } } else { b_error.clear(); _default_impl = 0; } DtMailSigChldList = new DtVirtArray<SigChldInfo *>(8); _busy_cb = NULL; _busy_cb_data = NULL; _canAutoSave = DTM_TRUE; _object_signature = SessionSignature; return; }
void AttachArea::parseAttachments( DtMailEnv &mail_error, DtMail::Message* msg, Boolean empty, int startBP ) { DtMail::BodyPart * tmpBP; int index = 1; int num_attachments = 0; char * name; // First unmanage and empty out the current contents. // SMD sets this boolean to FALSE so that previous message's attachments // are not cleared. E.g. Including/forwarding multiple messages each // with attachments. // RMW sets this boolean to TRUE so that all attachments are cleared in // the attachment pane everytime a new message is displayed. if ( empty ) { // First unmanage the clipWindow. // Unmanaging the attachment pane is visually ugly XtUnmanageChild(_clipWindow); this->clearAttachArea(); } _deleteCount = 0; // Now fill list with new attachments. tmpBP = msg->getFirstBodyPart(mail_error); if (mail_error.isSet()) { // do something } // Sync up the index with the bodyPart from which to begin // adding attachments into attachPane. // while (startBP > index) { tmpBP = msg->getNextBodyPart(mail_error, tmpBP); index++; } while (tmpBP != NULL) { num_attachments++; tmpBP->getContents( mail_error, NULL, NULL, NULL, &name, NULL, NULL); if (mail_error.isSet()) { // do something } // It is possible for an attachment to not have a name. if (!name) { name = "NoName"; } this->addAttachment(name, tmpBP); tmpBP = msg->getNextBodyPart(mail_error, tmpBP); if (mail_error.isSet()) { // do something } free(name); } }