root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ba/ba7100.cpp
alex a86682531f Patch level : xx.54 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            : Riportata la versione 01.05 patch 354


git-svn-id: svn://10.65.10.50/trunk@8178 c028cbd2-c16b-5b4b-a496-9718f37d4682
1999-05-24 13:34:11 +00:00

856 lines
19 KiB
C++
Executable File
Raw Blame History

#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <defmask.h>
#include <execp.h>
#include <expr.h>
#include <golem.h>
#include <tabutil.h>
#include <prefix.h>
#include <recarray.h>
#include <relation.h>
#include <sheet.h>
#include <utility.h>
#define NO_MFC
#include <netsock.h>
#include "ba7.h"
#include "ba7100a.h"
///////////////////////////////////////////////////////////
// TConfig utilities
///////////////////////////////////////////////////////////
TString& set_ini_var(int cfg, const char* para,
const char* var, const char* val)
{
static TString80 prev;
TConfig ini(cfg, para);
prev = ini.get(var);
if (val != NULL)
ini.set(var, val);
return prev;
}
inline TString& get_ini_var(int cfg, const char* para, const char* var)
{ return set_ini_var(cfg, para, var, NULL); }
///////////////////////////////////////////////////////////
// TMail_box
///////////////////////////////////////////////////////////
class TMail_box : public TSocketClient
{
unsigned long _connection;
public:
bool default_params(TString& server, TString& user,TString& password);
bool logon(const char* server = NULL,
const char* usr = NULL, const char* pwd = NULL);
virtual bool ok() const { return _connection != NULL; }
bool list(TString_array& a);
int get(TMail_messages& m);
bool remove(const char* id);
void logoff();
TMail_box();
~TMail_box();
};
bool TMail_box::default_params(TString& server, TString& user,TString& password)
{
bool ok = TRUE;
if (server.empty())
{
server = get_ini_var(CONFIG_INSTALL, "Server", "POP3");
if (server.empty())
ok = FALSE;
}
if (user.empty())
user = ::user();
if (password.empty())
{
const TString& pwd = cache().get(LF_USER, user).get("PASSWORD");
password = ::decode(pwd);
}
return ok;
}
bool TMail_box::logon(const char* ser, const char* usr, const char* pwd)
{
if (_connection)
logoff();
if (!IsOk())
return error_box("Impossibile inizializzare il client POP3");
TString server(ser);
TString user(usr);
TString password(pwd);
if (!default_params(server, user, password))
return error_box("E' necessario specificare un server POP3, un utente ed una password");
_connection = QueryConnection("110", server);
if (_connection != 0)
{
TString buf;
ReadLine(_connection, buf);
if (buf[0] != '+')
return error_box("Il server POP3 %s non risponde",
(const char*)server);
buf = "USER "; buf << user << '\n';
WriteLine(_connection, buf);
ReadLine(_connection, buf);
if (buf[0] != '+')
return error_box("Il server POP3 %s non accetta l'utente %s",
(const char*)server, (const char*)user);
buf = "PASS "; buf << password << '\n';
WriteLine(_connection, buf);
ReadLine(_connection, buf);
if (buf[0] != '+')
return error_box("Il server POP3 %s non accetta l'utente %s",
(const char*)server, (const char*)user);
}
else
return error_box("Impossibile contattare il server POP3 %s",
(const char*)server);
return TRUE;
}
void TMail_box::logoff()
{
if (_connection)
{
WriteLine(_connection, "QUIT\n");
RemoveConnection(_connection);
_connection = NULL;
}
}
bool TMail_box::list(TString_array& a)
{
bool ok = _connection != NULL;
if (ok)
{
TString buf;
buf = "LIST\n";
WriteLine(_connection, buf);
ReadLine(_connection, buf);
ok = buf[0] == '+';
while (ok)
{
if (!ReadLine(_connection, buf))
break; // Unexpected EOF
if (buf[0] == '.')
break;
int pos = buf.find(' ');
if (pos > 0)
buf.cut(pos);
a.add(buf);
}
}
return ok;
}
HIDDEN int str2month(const char* str)
{
const char* const mese[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
int m;
for (m = 11; m > 0; m--)
{
if (stricmp(str, mese[m]) == 0)
break;
}
return m+1;
}
int TMail_box::get(TMail_messages& m)
{
// Lista dei caratteri validi
const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+*";
// Lista per decodifica dei caratteri validi
char Deco64[256];
memset(Deco64, ' ', sizeof(Deco64));
for (int i = 0; Base64[i]; i++)
Deco64[Base64[i]] = i;
TString_array a;
list(a);
TString buf;
FOR_EACH_ARRAY_ROW(a, r, row)
{
TMail_message* msgptr = new TMail_message(user());
m.add(msgptr);
TMail_message& msg = *msgptr;
buf = "RETR "; buf << *row << '\n';
WriteLine(_connection, buf);
ReadLine(_connection, buf);
bool ok = buf[0] == '+';
bool base64 = FALSE;
bool in_body = FALSE;
while (ok)
{
if (!ReadLine(_connection, buf))
{
ok = FALSE;
break; // Unexpected EOF
}
if (buf[0] == '.')
{
buf.ltrim(1);
if (buf.blank())
break;
}
if (in_body)
{
if (base64)
{
unsigned val = 0;
int bits = 0;
for (const char* s = buf; *s && *s != '='; s++)
{
if (*s==0x0A || *s==0x0D || *s==0x20 || *s==0x09)
continue; // Salta eventuali blanks
val <<= 6;
val |= Deco64[*s];
bits += 6;
if (bits >= 8)
{
const char c = char((val >> (bits - 8)) & 0xFF);
msg << c;
bits -= 8;
}
}
}
else
{
const char last = buf.right(1)[0];
if (last > '\0' && last < ' ')
buf.rtrim(1);
msg << buf << '\n';
}
}
else
{
if (buf.blank())
in_body = TRUE; else
if (buf.compare("From:", 5, TRUE) == 0)
{
buf.ltrim(6);
msg.set_sender(buf);
} else
if (buf.compare("To:", 3, TRUE) == 0)
{
buf.ltrim(4);
msg.add_recipient(buf);
} else
if (buf.compare("Cc:", 3, TRUE) == 0)
{
buf.ltrim(4);
msg.add_copy_recipient(buf);
} else
if (buf.compare("Subject:", 8, TRUE) == 0)
{
buf.ltrim(9);
msg.set_subject(buf);
} else
if (buf.compare("Date:", 5, TRUE) == 0)
{
TToken_string d(buf.mid(6), ' ');
int giorno = d.get_int(1);
int mese = str2month(d.get());
int anno = d.get_int();
if (anno < 1000) anno += anno >= 98 ? 1900 : 2000;
TString16 ora = d.get();
buf.cut(0);
buf << anno << '/' << mese << '/' << giorno << ' ' << ora;
msg.set_date_time(buf);
} else
if (buf.compare("Content-Transfer-Encoding:", 26, TRUE) == 0)
{
base64 = buf.find("base64") > 0;
}
}
}
}
return m.items();
}
bool TMail_box::remove(const char* id)
{
bool ok = _connection != NULL;
if (ok)
{
TString buf;
buf << "DELE " << id << '\n';
WriteLine(_connection, buf);
ReadLine(_connection, buf);
ok = buf[0] == '+';
}
return ok;
}
TMail_box::TMail_box() : _connection(NULL)
{
}
TMail_box::~TMail_box()
{
logoff();
}
///////////////////////////////////////////////////////////
// TFilter_expr
///////////////////////////////////////////////////////////
class TFilter_expr : public TExpression
{
TAutomask& _mask;
protected:
virtual bool print_error(const char* msg) const;
public:
TFilter_expr(TAutomask& m, int logicnum, const char* expr);
virtual ~TFilter_expr() { }
};
bool TFilter_expr::print_error(const char* msg) const
{
return _mask.error_box(msg);
}
TFilter_expr::TFilter_expr(TAutomask& m, int logicnum, const char* expr)
: _mask(m)
{
bool ok = set(expr, _strexpr);
if (ok)
{
if (logicnum < LF_USER || logicnum >= prefix().items())
logicnum = LF_TABCOM;
TLocalisamfile isf(logicnum);
TRectype& rec = isf.curr();
for (int i = 0; i < numvar(); i++) if (rec.exist(varname(i)))
{
_error = 883;
TString msg;
msg << "Il campo " << varname(i)
<< " non appartiene al file " << logicnum;
print_error(msg);
break;
}
}
}
///////////////////////////////////////////////////////////
// TMailer_mask
///////////////////////////////////////////////////////////
class TMailer_mask : public TAutomask
{
int _timer_id;
int _mail_semaphore;
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
virtual void handler(WINDOW win, EVENT* ep);
protected:
bool file2app(const TString& file, TString& app) const;
void expand_tabs(TString& str, const int tab = 8) const;
void save_sheet(TConfig& ini, short dlg, const char* var) const;
void load_sheet(TConfig& ini, short dlg, const char* var);
public:
void test_delete();
int fill_messages();
bool save_curr_line();
void save_all_lines();
void auto_save_all();
void save() const;
void load();
void mail_lock()
{ _mail_semaphore++; }
void mail_unlock()
{ CHECK(_mail_semaphore > 0, "Bad timer unlock"); _mail_semaphore--; }
TMailer_mask();
virtual ~TMailer_mask();
};
class TMail_lock
{
TMailer_mask* _mm;
public:
TMail_lock(TMailer_mask* mm) : _mm(mm) { _mm->mail_lock(); }
~TMail_lock() { _mm->mail_unlock(); }
};
void TMailer_mask::test_delete()
{
TMail_lock ml(this);
TWait_cursor hourglass;
xvt_statbar_set("Eliminazione messaggi POP3...");
do_events();
TSheet_field& sf = sfield(F_MESSAGES);
TString16 mailer, id;
TMail_messages mapidel; // Lista dei messaggi MAPI da cancellare
TMail_box mailbox;
FOR_EACH_SHEET_ROW_BACK(sf, nrow, row) if (*row->get(0) == 'X')
{
row->get(sf.cid2index(F_MAILER), mailer);
row->get(sf.cid2index(F_ID), id);
if (mailer == "POP3")
{
if (!mailbox.ok())
{
if (!mailbox.logon(get(F_SERVER), get(F_USER), get(F_PASSWORD)))
break;
}
if (!mailbox.remove(id))
error_box("Impossibile cancellare il messagio POP3 %s", (const char*)id);
}
else
{
TMail_message* msg = new TMail_message("");
msg->set_id(id);
mapidel.add(msg);
}
sf.destroy(nrow);
}
mailbox.logoff();
if (mapidel.items() > 0)
{
xvt_statbar_set("Eliminazione messaggi MAPI...");
do_events();
mapidel.remove();
}
xvt_statbar_set("Pronto");
do_events();
}
void TMailer_mask::expand_tabs(TString& str, const int tab) const
{
int start = 0;
for (int i = 0; str[i]; i++)
{
switch(str[i])
{
case '\n':
case '\r':
start = i+1;
break;
case '\t':
{
const int t = tab - ((i-start) % tab) - 1;
str[i] = ' ';
if (t > 0)
{
TString80 spac; spac.spaces(t);
str.insert(spac, i+1);
i += t;
}
}
break;
default:
break;
}
}
}
int TMailer_mask::fill_messages()
{
TMail_lock ml(this);
TWait_cursor hourglass;
TMail_messages box;
TString server(get(F_SERVER));
TString user(get(F_USER));
TString password(get(F_PASSWORD));
TMail_box mailbox;
if (mailbox.default_params(server, user, password))
{
set(F_SERVER, server);
set(F_USER, user);
set(F_PASSWORD, password);
}
int totmapi = 0;
if (get_bool(F_MAPI))
{
xvt_statbar_set("Ricezione messaggi MAPI...");
do_events();
totmapi = box.get();
}
xvt_statbar_set("Ricezione messaggi POP3...");
do_events();
mailbox.logon(server, user, password);
mailbox.get(box);
mailbox.logoff();
TSheet_field& sf = sfield(F_MESSAGES);
sf.destroy();
for (int m = 0; m < box.items(); m++)
{
TMail_message& msg = box.msg(m);
TToken_string& row = sf.row(m);
row.add(msg.sender(), sf.cid2index(F_SENDER));
row.add(msg.date(), sf.cid2index(F_DATE));
const real t = msg.time();
row.add(t.string("@@:@@:@@"), sf.cid2index(F_TIME));
row.add(msg.subject(), sf.cid2index(F_SUBJECT));
expand_tabs(msg);
row.add(msg, sf.cid2index(F_BODY));
row.add(m<totmapi?"MAPI":"POP3", sf.cid2index(F_MAILER));
if (m < totmapi)
{
row.add("MAPI", sf.cid2index(F_MAILER));
row.add(msg.id(), sf.cid2index(F_ID));
}
else
{
row.add("POP3", sf.cid2index(F_MAILER));
row.add(m-totmapi+1, sf.cid2index(F_ID));
}
}
sf.force_update();
xvt_statbar_set("Pronto");
return sf.items();
}
bool TMailer_mask::file2app(const TString& file, TString& app) const
{
bool ok = FALSE;
if (isdigit(file[0]))
{
const int filenum = atoi(file);
if (filenum >= LF_USER && filenum < prefix().items())
{
TLocalisamfile isf(filenum);
ok = isf.get_relapp(app);
}
}
else
{
const int len = file.len();
if (len == 3 || (len == 4 && file[0] == '%'))
{
TTable table(file);
ok = table.get_relapp(app);
}
}
return ok;
}
bool TMailer_mask::save_curr_line()
{
TMail_lock ml(this);
TSheet_field& sf = sfield(F_MESSAGES);
TMask& m = sf.sheet_mask();
const int nrow = sf.selected();
TToken_string& row = sf.row(nrow);
const TString& msg = m.get(F_BODY);
if (msg.find("[Transaction]") < 0)
return FALSE; // It's not a transaction
TFilename appname;
if (!file2app(m.get(F_SUBJECT), appname))
return FALSE; // It hasn't a valid application
TFilename tmp; tmp.temp();
ofstream outf(tmp);
outf << msg;
outf.close();
const TString old_mailto = set_ini_var(CONFIG_INSTALL, "Main", "MailTo", "");
appname << " /i" << tmp;
TExternal_app app(appname);
bool ok = app.run() == NOERR;
if (ok)
{
TConfig ini(tmp, "Transaction");
ok = ini.get("Result") == "OK";
}
::remove(tmp);
if (ok)
{
if (m.is_running())
{
m.set(F_CHECKED, "X");
m.stop_run(K_AUTO_ENTER);
}
else
{
row.add("X", 0);
sf.force_update(nrow);
}
}
// Restore mail recipient
if (old_mailto.not_empty())
set_ini_var(CONFIG_INSTALL, "Main", "MailTo", old_mailto);
return TRUE;
}
void TMailer_mask::save_all_lines()
{
TMail_lock ml(this);
TWait_cursor hourglass;
TSheet_field& sf = sfield(F_MESSAGES);
TString body;
bool one_saved = FALSE;
FOR_EACH_SHEET_ROW(sf, nrow, row) if (*row->get(0) != 'X')
{
row->get(sf.cid2index(F_BODY), body);
if (body.find("[Transaction]") >= 0)
{
sf.select(nrow);
one_saved |= save_curr_line();
}
}
if (one_saved && yesno_box("Si desidera eliminare i messaggi processati?"))
{
test_delete();
fill_messages();
}
}
bool TMailer_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_TIMER:
if (e == fe_init || e == fe_modify)
{
if (_timer_id)
{
xvt_timer_destroy(_timer_id);
_timer_id = XVT_TIMER_ERROR;
}
const long minutes = atol(o.get());
if (minutes > 0)
{
_timer_id = xvt_timer_create(win(), minutes * 60000L);
if (_timer_id == XVT_TIMER_ERROR)
return error_box("Impossibile impostare il timer");
}
}
break;
case F_MESSAGES:
if (e == fe_init)
{
if (!field(F_SERVER).empty() &&
!field(F_USER).empty() &&
!field(F_PASSWORD).empty())
{
auto_save_all();
}
} else
if (e == se_query_add)
{
auto_save_all();
return FALSE;
}
break;
case DLG_USER:
if (e == fe_button)
save_curr_line();
break;
case DLG_SAVEREC:
if (e == fe_button)
save_all_lines();
break;
case DLG_DELREC:
if (e == fe_button)
{
test_delete();
fill_messages();
return FALSE;
}
break;
case F_FILE:
if (jolly == 3)
{
if (e == fe_button)
{
TMask& m = o.mask();
TArray_sheet sht(-1,-1,-4,-4,"Selezione archivio", "Codice@6R|Descrizione archivio@70");
const TPrefix& pref = prefix();
const int total = pref.items();
if (total > 0)
{
TWait_cursor hourglass;
for (int i = LF_USER; i < total; i++)
{
TToken_string* row = new TToken_string;
*row << i;
row->add(pref.description(*row));
sht.rows_array().add(row);
}
sht.select(m.get_int(o.dlg()) - LF_USER);
}
if (sht.run() == K_ENTER)
m.set(o.dlg(), sht.selected() + LF_USER);
}
}
break;
case F_EXPR:
if (jolly == 3)
{
if (e == fe_modify || e == fe_close)
{
TAutomask& m = (TAutomask&)o.mask();
const int num = m.get_int(F_FILE);
TFilter_expr expr(m, num, o.get());
return expr.error() == 0;
}
}
break;
default:
break;
}
return TRUE;
}
void TMailer_mask::save_sheet(TConfig& ini, short dlg, const char* var) const
{
TSheet_field& sf = sfield(dlg);
FOR_EACH_SHEET_ROW(sf, r, row)
ini.set(var, *row, NULL, TRUE, r);
}
void TMailer_mask::load_sheet(TConfig& ini, short dlg, const char* var)
{
TSheet_field& sf = sfield(dlg);
sf.destroy();
for (int r = 0; ini.exist(var, r); r++)
sf.row(r) = ini.get(var, NULL, r);
}
void TMailer_mask::auto_save_all()
{
if (_mail_semaphore == 0)
{
TMail_lock ml(this);
test_delete();
fill_messages();
if (!field(F_TIMER).empty())
save_all_lines();
}
else
NFCHECK("Can't save locked mail");
}
void TMailer_mask::handler(WINDOW win, EVENT* ep)
{
if (ep->type == E_TIMER)
{
if (ep->v.timer.id == _timer_id && _mail_semaphore == 0)
auto_save_all();
}
TAutomask::handler(win, ep);
}
void TMailer_mask::save() const
{
TConfig ini(CONFIG_DITTA, "MailTransactions");
ini.remove_all();
ini.set("Server", get(F_SERVER));
ini.set("User", get(F_USER));
ini.set("Password", encode(get(F_PASSWORD)));
ini.set("Timer", get(F_TIMER));
save_sheet(ini, F_ADDRESSES, "Recipient");
save_sheet(ini, F_PARAMS, "Filter");
}
void TMailer_mask::load()
{
TConfig ini(CONFIG_DITTA, "MailTransactions");
set(F_SERVER, ini.get("Server"));
set(F_USER, ini.get("User"));
set(F_PASSWORD, decode(ini.get("Password")));
set(F_TIMER, ini.get_int("Timer"));
load_sheet(ini, F_ADDRESSES, "Recipient");
load_sheet(ini, F_PARAMS, "Filter");
}
TMailer_mask::TMailer_mask()
: TAutomask("ba7100a"),
_timer_id(XVT_TIMER_ERROR), _mail_semaphore(0)
{
load();
}
TMailer_mask::~TMailer_mask()
{
if (_timer_id != XVT_TIMER_ERROR)
{
xvt_timer_destroy(_timer_id);
_timer_id = XVT_TIMER_ERROR;
}
save();
}
///////////////////////////////////////////////////////////
// TMailer
///////////////////////////////////////////////////////////
class TMailer : public TSkeleton_application
{
public:
virtual void main_loop();
};
void TMailer::main_loop()
{
open_files(LF_USER, 0);
TMailer_mask mm;
mm.run();
}
int ba7100(int argc, char* argv[])
{
TMailer app;
app.run(argc, argv, "Postino");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink