/*
* This routine allocates a block of memory large enough to hold a LINE
* containing "used" characters. The block is always rounded up a bit. Return
* a pointer to the new block, or NULL if there isn't any memory left. Print a
* message in the message line if no space.
*/
LINE *
lalloc(int used)
{
register LINE *lp;
register int size;
EML eml;
static int displayed = 0;
if((size = (used+NBLOCK-1) & ~(NBLOCK-1)) > NLINE)
size *= 2;
if (size == 0) /* Assume that an empty */
size = NBLOCK; /* line is for type-in. */
if (displayed == 0 && (lp = (LINE *) malloc(sizeof(LINE)+(size*sizeof(CELL)))) == NULL){
eml.s = comatose(size);
emlwrite("Cannot allocate %s bytes (read file incomplete)", &eml);
displayed++;
return (NULL);
}
lp->l_size = size;
lp->l_used = used;
return (lp);
}
int
check_point(MAILSTREAM *stream, CheckPointTime timing, int flags)
{
int freq, tm, check_count, tst1 = 0, tst2 = 0, accel;
long since_last_input, since_first_change;
time_t now, then;
#define AT_LEAST (180)
#define MIN_LONG_CHK_IDLE (10)
if(!stream || stream->rdonly || stream->halfopen
|| (check_count = sp_check_cnt(stream)) == 0)
return(0);
since_last_input = (long) time(0) - (long) time_of_last_input();
if(timing == GoodTime && since_last_input <= 0)
timing = VeryBadTime;
else if(timing == GoodTime && since_last_input <= 4)
timing = BadTime;
dprint((9, "check_point(%s: %s)\n",
timing == GoodTime ? "GoodTime" :
timing == BadTime ? "BadTime" :
timing == VeryBadTime ? "VeryBadTime" : "DoItNow",
STREAMNAME(stream)));
freq = CHECK_POINT_FREQ * (timing==GoodTime ? 1 : timing==BadTime ? 3 : 4);
tm = CHECK_POINT_TIME * (timing==GoodTime ? 2 : timing==BadTime ? 4 : 6);
tm = MAX(100, tm);
if(timing == DoItNow){
dprint((9, "DoItNow\n"));
}
else{
since_first_change = (long) (time(0) - sp_first_status_change(stream));
accel = MIN(3, MAX(1, (4 * since_first_change)/tm));
tst1 = ((check_count * since_last_input) >= (30/accel) * freq);
tst2 = ((since_first_change >= tm)
&& (since_last_input >= MIN_LONG_CHK_IDLE));
dprint((9,
"Chk changes(%d) x since_last_input(%ld) (=%ld) >= freq(%d) x 30/%d (=%d) ? %s\n",
check_count, since_last_input,
check_count * since_last_input, freq, accel, (30/accel)*freq,
tst1 ? "Yes" : "No"));
dprint((9,
" or since_1st_change(%ld) >= tm(%d) && since_last_input >= %d ? %s\n",
since_first_change, tm, MIN_LONG_CHK_IDLE,
tst2 ? "Yes" : "No"));
}
if(timing == DoItNow || tst1 || tst2){
if(timing == DoItNow
|| time(0) - sp_last_chkpnt_done(stream) >= AT_LEAST){
then = time(0);
dprint((2, "Checkpoint: %s Since 1st change: %ld secs idle: %ld secs\n",
debug_time(0,1),
(long) (then - sp_first_status_change(stream)),
since_last_input))
;
if((flags & NM_STATUS_MSG) && pith_opt_checkpoint_cue)
(*pith_opt_checkpoint_cue)(TRUE);
pine_mail_check(stream); /* write file state */
now = time(0);
dprint((2,
"Checkpoint complete: %s%s%s%s\n",
debug_time(0,1),
(now-then > 0) ? " (elapsed: " : "",
(now-then > 0) ? comatose((long)(now-then)) : "",
(now-then > 0) ? " secs)" : ""));
if((flags & NM_STATUS_MSG) && pith_opt_checkpoint_cue)
(*pith_opt_checkpoint_cue)(FALSE);
return(1);
}
else{
dprint((9,
"Skipping checkpoint since last was only %ld secs ago (< %d)\n",
(long) (time(0) - sp_last_chkpnt_done(stream)), AT_LEAST));
}
}
return(0);
}
/*
* Do an LDAP lookup to the server described in the info argument.
*
* Args info -- LDAP info for server.
* string -- String to lookup.
* cust -- Possible custom filter description.
* wp_err -- We set this is we get a white pages error.
* name_in_error -- Caller sets this if they want us to include the server
* name in error messages.
*
* Returns Results of lookup, NULL if lookup failed.
*/
LDAP_SERV_RES_S *
ldap_lookup(LDAP_SERV_S *info, char *string, CUSTOM_FILT_S *cust,
WP_ERR_S *wp_err, int name_in_error)
{
char ebuf[900];
char buf[900];
char *serv, *base, *serv_errstr;
char *mailattr, *snattr, *gnattr, *cnattr;
int we_cancel = 0, we_turned_on = 0;
LDAP_SERV_RES_S *serv_res = NULL;
LDAP *ld;
long pwdtrial = 0L;
int ld_errnum;
char *ld_errstr;
if(!info)
return(serv_res);
serv = cpystr((info->serv && *info->serv) ? info->serv : "?");
if(name_in_error)
snprintf(ebuf, sizeof(ebuf), " (%s)",
(info->nick && *info->nick) ? info->nick : serv);
else
ebuf[0] = '\0';
serv_errstr = cpystr(ebuf);
base = cpystr(info->base ? info->base : "");
if(info->port < 0)
info->port = LDAP_PORT;
if(info->type < 0)
info->type = DEF_LDAP_TYPE;
if(info->srch < 0)
info->srch = DEF_LDAP_SRCH;
if(info->time < 0)
info->time = DEF_LDAP_TIME;
if(info->size < 0)
info->size = DEF_LDAP_SIZE;
if(info->scope < 0)
info->scope = DEF_LDAP_SCOPE;
mailattr = (info->mailattr && info->mailattr[0]) ? info->mailattr
: DEF_LDAP_MAILATTR;
snattr = (info->snattr && info->snattr[0]) ? info->snattr
: DEF_LDAP_SNATTR;
gnattr = (info->gnattr && info->gnattr[0]) ? info->gnattr
: DEF_LDAP_GNATTR;
cnattr = (info->cnattr && info->cnattr[0]) ? info->cnattr
: DEF_LDAP_CNATTR;
/*
* We may want to keep ldap handles open, but at least for
* now, re-open them every time.
*/
dprint((3, "ldap_lookup(%s,%d)\n", serv ? serv : "?", info->port));
snprintf(ebuf, sizeof(ebuf), "Searching%s%s%s on %s",
(string && *string) ? " for \"" : "",
(string && *string) ? string : "",
(string && *string) ? "\"" : "",
serv);
we_turned_on = intr_handling_on(); /* this erases keymenu */
we_cancel = busy_cue(ebuf, NULL, 0);
if(wp_err->mangled)
*(wp_err->mangled) = 1;
#ifdef _SOLARIS_SDK
if(info->tls || info->tlsmust)
ldapssl_client_init(NULL, NULL);
if((ld = ldap_init(serv, info->port)) == NULL)
#else
#if (LDAPAPI >= 11)
if((ld = ldap_init(serv, info->port)) == NULL)
#else
if((ld = ldap_open(serv, info->port)) == NULL)
#endif
#endif
{
/* TRANSLATORS: All of the three args together are an error message */
snprintf(ebuf, sizeof(ebuf), _("Access to LDAP server failed: %s%s(%s)"),
errno ? error_description(errno) : "",
errno ? " " : "",
serv);
wp_err->wp_err_occurred = 1;
if(wp_err->error)
fs_give((void **)&wp_err->error);
wp_err->error = cpystr(ebuf);
if(we_cancel)
cancel_busy_cue(-1);
q_status_message(SM_ORDER, 3, 5, wp_err->error);
display_message('x');
dprint((2, "%s\n", ebuf));
}
else if(!ps_global->intr_pending){
int proto = 3, tlsmustbail = 0;
char pwd[NETMAXPASSWD], user[NETMAXUSER];
char *passwd = NULL;
char hostbuf[1024];
NETMBX mb;
#ifndef _WINDOWS
int rc;
#endif
memset(&mb, 0, sizeof(mb));
#ifdef _SOLARIS_SDK
if(info->tls || info->tlsmust)
rc = ldapssl_install_routines(ld);
#endif
if(ldap_v3_is_supported(ld) &&
our_ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &proto) == 0){
dprint((5, "ldap: using version 3 protocol\n"));
}
/*
* If we don't set RESTART then the select() waiting for the answer
* in libldap will be interrupted and stopped by our busy_cue.
*/
our_ldap_set_option(ld, LDAP_OPT_RESTART, LDAP_OPT_ON);
/*
* If we need to authenticate, get the password. We are not
* supporting SASL authentication, just LDAP simple.
*/
if(info->binddn && info->binddn[0]){
char pmt[500];
char *space;
snprintf(hostbuf, sizeof(hostbuf), "{%s}dummy", info->serv ? info->serv : "?");
/*
* We don't handle multiple space-delimited hosts well.
* We don't know which we're asking for a password for.
* We're not connected yet so we can't know.
*/
if((space=strindex(hostbuf, ' ')) != NULL)
*space = '\0';
mail_valid_net_parse_work(hostbuf, &mb, "ldap");
mb.port = info->port;
mb.tlsflag = (info->tls || info->tlsmust) ? 1 : 0;
try_password_again:
if(mb.tlsflag
&& (pwdtrial > 0 ||
#ifndef _WINDOWS
#ifdef _SOLARIS_SDK
(rc == LDAP_SUCCESS)
#else /* !_SOLARIS_SDK */
((rc=ldap_start_tls_s(ld, NULL, NULL)) == LDAP_SUCCESS)
#endif /* !_SOLARIS_SDK */
#else /* _WINDOWS */
0 /* TODO: find a way to do this in Windows */
#endif /* _WINDOWS */
))
mb.tlsflag = 1;
else
mb.tlsflag = 0;
if((info->tls || info->tlsmust) && !mb.tlsflag){
q_status_message(SM_ORDER, 3, 5, "Not able to start TLS encryption for LDAP server");
if(info->tlsmust)
tlsmustbail++;
}
if(!tlsmustbail){
snprintf(pmt, sizeof(pmt), " %s", (info->nick && *info->nick) ? info->nick : serv);
mm_login_work(&mb, user, pwd, pwdtrial, pmt, info->binddn);
if(pwd && pwd[0])
passwd = pwd;
}
}
/*
* LDAPv2 requires the bind. v3 doesn't require it but we want
* to tell the server we're v3 if the server supports v3, and if the
* server doesn't support v3 the bind is required.
*/
if(tlsmustbail || ldap_simple_bind_s(ld, info->binddn, passwd) != LDAP_SUCCESS){
wp_err->wp_err_occurred = 1;
ld_errnum = our_ldap_get_lderrno(ld, NULL, &ld_errstr);
if(!tlsmustbail && info->binddn && info->binddn[0] && pwdtrial < 2L
&& ld_errnum == LDAP_INVALID_CREDENTIALS){
pwdtrial++;
q_status_message(SM_ORDER, 3, 5, _("Invalid password"));
goto try_password_again;
}
snprintf(ebuf, sizeof(ebuf), _("LDAP server failed: %s%s%s%s"),
ldap_err2string(ld_errnum),
serv_errstr,
(ld_errstr && *ld_errstr) ? ": " : "",
(ld_errstr && *ld_errstr) ? ld_errstr : "");
if(wp_err->error)
fs_give((void **)&wp_err->error);
if(we_cancel)
cancel_busy_cue(-1);
ldap_unbind(ld);
wp_err->error = cpystr(ebuf);
q_status_message(SM_ORDER, 3, 5, wp_err->error);
display_message('x');
dprint((2, "%s\n", ebuf));
}
else if(!ps_global->intr_pending){
int srch_res, args, slen, flen;
#define TEMPLATELEN 512
char filt_template[TEMPLATELEN + 1];
char filt_format[2*TEMPLATELEN + 1];
char filter[2*TEMPLATELEN + 1];
char scp[2*TEMPLATELEN + 1];
char *p, *q;
LDAPMessage *res = NULL;
int intr_happened = 0;
int tl;
tl = (info->time == 0) ? info->time : info->time + 10;
our_ldap_set_option(ld, LDAP_OPT_TIMELIMIT, &tl);
our_ldap_set_option(ld, LDAP_OPT_SIZELIMIT, &info->size);
/*
* If a custom filter has been passed in and it doesn't include a
* request to combine it with the configured filter, then replace
* any configured filter with the passed in filter.
*/
if(cust && cust->filt && !cust->combine){
if(info->cust)
fs_give((void **)&info->cust);
info->cust = cpystr(cust->filt);
}
if(info->cust && *info->cust){ /* use custom filter if present */
strncpy(filt_template, info->cust, sizeof(filt_template));
filt_template[sizeof(filt_template)-1] = '\0';
}
else{ /* else use configured filter */
switch(info->type){
case LDAP_TYPE_SUR:
snprintf(filt_template, sizeof(filt_template), "(%s=%%s)", snattr);
break;
case LDAP_TYPE_GIVEN:
snprintf(filt_template, sizeof(filt_template), "(%s=%%s)", gnattr);
break;
case LDAP_TYPE_EMAIL:
snprintf(filt_template, sizeof(filt_template), "(%s=%%s)", mailattr);
break;
case LDAP_TYPE_CN_EMAIL:
snprintf(filt_template, sizeof(filt_template), "(|(%s=%%s)(%s=%%s))", cnattr,
mailattr);
break;
case LDAP_TYPE_SUR_GIVEN:
snprintf(filt_template, sizeof(filt_template), "(|(%s=%%s)(%s=%%s))",
snattr, gnattr);
break;
case LDAP_TYPE_SEVERAL:
snprintf(filt_template, sizeof(filt_template),
"(|(%s=%%s)(%s=%%s)(%s=%%s)(%s=%%s))",
cnattr, mailattr, snattr, gnattr);
break;
default:
case LDAP_TYPE_CN:
snprintf(filt_template, sizeof(filt_template), "(%s=%%s)", cnattr);
break;
}
}
/* just copy if custom */
if(info->cust && *info->cust)
info->srch = LDAP_SRCH_EQUALS;
p = filt_template;
q = filt_format;
memset((void *)filt_format, 0, sizeof(filt_format));
args = 0;
while(*p && (q - filt_format) + 4 < sizeof(filt_format)){
if(*p == '%' && *(p+1) == 's'){
args++;
switch(info->srch){
/* Exact match */
case LDAP_SRCH_EQUALS:
*q++ = *p++;
*q++ = *p++;
break;
/* Append wildcard after %s */
case LDAP_SRCH_BEGINS:
*q++ = *p++;
*q++ = *p++;
*q++ = '*';
break;
/* Insert wildcard before %s */
case LDAP_SRCH_ENDS:
*q++ = '*';
*q++ = *p++;
*q++ = *p++;
break;
/* Put wildcard before and after %s */
default:
case LDAP_SRCH_CONTAINS:
*q++ = '*';
*q++ = *p++;
*q++ = *p++;
*q++ = '*';
break;
}
}
else
*q++ = *p++;
}
if(q - filt_format < sizeof(filt_format))
*q = '\0';
filt_format[sizeof(filt_format)-1] = '\0';
/*
* If combine is lit we put the custom filter and the filt_format
* filter and combine them with an &.
*/
if(cust && cust->filt && cust->combine){
char *combined;
size_t l;
l = strlen(filt_format) + strlen(cust->filt) + 3;
combined = (char *) fs_get((l+1) * sizeof(char));
snprintf(combined, l+1, "(&%s%s)", cust->filt, filt_format);
strncpy(filt_format, combined, sizeof(filt_format));
filt_format[sizeof(filt_format)-1] = '\0';
fs_give((void **) &combined);
}
/*
* Ad hoc attempt to make "Steve Hubert" match
* Steven Hubert but not Steven Shubert.
* We replace a <SPACE> with * <SPACE> (not * <SPACE> *).
*/
memset((void *)scp, 0, sizeof(scp));
if(info->nosub)
strncpy(scp, string, sizeof(scp));
else{
p = string;
q = scp;
while(*p && (q - scp) + 1 < sizeof(scp)){
if(*p == SPACE && *(p+1) != SPACE){
*q++ = '*';
*q++ = *p++;
}
else
*q++ = *p++;
}
}
scp[sizeof(scp)-1] = '\0';
slen = strlen(scp);
flen = strlen(filt_format);
/* truncate string if it will overflow filter */
if(args*slen + flen - 2*args > sizeof(filter)-1)
scp[(sizeof(filter)-1 - flen)/args] = '\0';
/*
* Replace %s's with scp.
*/
switch(args){
case 0:
snprintf(filter, sizeof(filter), "%s", filt_format);
break;
case 1:
snprintf(filter, sizeof(filter), filt_format, scp);
break;
case 2:
snprintf(filter, sizeof(filter), filt_format, scp, scp);
break;
case 3:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp);
break;
case 4:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp);
break;
case 5:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp, scp);
break;
case 6:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp, scp, scp);
break;
case 7:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp, scp, scp, scp);
break;
case 8:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp, scp, scp, scp,
scp);
break;
case 9:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp, scp, scp, scp,
scp, scp);
break;
case 10:
default:
snprintf(filter, sizeof(filter), filt_format, scp, scp, scp, scp, scp, scp, scp,
scp, scp, scp);
break;
}
/* replace double *'s with single *'s in filter */
for(p = q = filter; *p; p++)
if(*p != '*' || p == filter || *(p-1) != '*')
*q++ = *p;
*q = '\0';
(void) removing_double_quotes(base);
dprint((5, "about to ldap_search(\"%s\", %s)\n",
base ? base : "?", filter ? filter : "?"));
if(ps_global->intr_pending)
srch_res = LDAP_PROTOCOL_ERROR;
else{
int msgid;
time_t start_time;
start_time = time((time_t *)0);
dprint((6, "ldap_lookup: calling ldap_search\n"));
msgid = ldap_search(ld, base, info->scope, filter, NULL, 0);
if(msgid == -1)
srch_res = our_ldap_get_lderrno(ld, NULL, NULL);
else{
int lres;
/*
* Warning: struct timeval is not portable. However, since it is
* part of LDAP api it must be portable to all platforms LDAP
* has been ported to.
*/
struct timeval t;
t.tv_sec = 1; t.tv_usec = 0;
do {
if(ps_global->intr_pending)
intr_happened = 1;
dprint((6, "ldap_result(id=%d): ", msgid));
if((lres=ldap_result(ld, msgid, LDAP_MSG_ALL, &t, &res)) == -1){
/* error */
srch_res = our_ldap_get_lderrno(ld, NULL, NULL);
dprint((6, "error (-1 returned): ld_errno=%d\n",
srch_res));
}
else if(lres == 0){ /* timeout, no results available */
if(intr_happened){
ldap_abandon(ld, msgid);
srch_res = LDAP_PROTOCOL_ERROR;
if(our_ldap_get_lderrno(ld, NULL, NULL) == LDAP_SUCCESS)
our_ldap_set_lderrno(ld, LDAP_PROTOCOL_ERROR, NULL, NULL);
dprint((6, "timeout, intr: srch_res=%d\n",
srch_res));
}
else if(info->time > 0 &&
((long)time((time_t *)0) - start_time) > info->time){
/* try for partial results */
t.tv_sec = 0; t.tv_usec = 0;
lres = ldap_result(ld, msgid, LDAP_MSG_RECEIVED, &t, &res);
if(lres > 0 && lres != LDAP_RES_SEARCH_RESULT){
srch_res = LDAP_SUCCESS;
dprint((6, "partial result: lres=0x%x\n", lres));
}
else{
if(lres == 0)
ldap_abandon(ld, msgid);
srch_res = LDAP_TIMEOUT;
if(our_ldap_get_lderrno(ld, NULL, NULL) == LDAP_SUCCESS)
our_ldap_set_lderrno(ld, LDAP_TIMEOUT, NULL, NULL);
dprint((6,
"timeout, total_time (%d), srch_res=%d\n",
info->time, srch_res));
}
}
else{
dprint((6, "timeout\n"));
}
}
else{
srch_res = ldap_result2error(ld, res, 0);
dprint((6, "lres=0x%x, srch_res=%d\n", lres,
srch_res));
}
}while(lres == 0 &&
!(intr_happened ||
(info->time > 0 &&
((long)time((time_t *)0) - start_time) > info->time)));
}
}
if(intr_happened){
wp_exit = 1;
if(we_cancel)
cancel_busy_cue(-1);
if(wp_err->error)
fs_give((void **)&wp_err->error);
else{
q_status_message(SM_ORDER, 0, 1, "Interrupt");
display_message('x');
fflush(stdout);
}
if(res)
ldap_msgfree(res);
if(ld)
ldap_unbind(ld);
res = NULL; ld = NULL;
}
else if(srch_res != LDAP_SUCCESS &&
srch_res != LDAP_TIMELIMIT_EXCEEDED &&
srch_res != LDAP_RESULTS_TOO_LARGE &&
srch_res != LDAP_TIMEOUT &&
srch_res != LDAP_SIZELIMIT_EXCEEDED){
wp_err->wp_err_occurred = 1;
ld_errnum = our_ldap_get_lderrno(ld, NULL, &ld_errstr);
snprintf(ebuf, sizeof(ebuf), _("LDAP search failed: %s%s%s%s"),
ldap_err2string(ld_errnum),
serv_errstr,
(ld_errstr && *ld_errstr) ? ": " : "",
(ld_errstr && *ld_errstr) ? ld_errstr : "");
if(wp_err->error)
fs_give((void **)&wp_err->error);
wp_err->error = cpystr(ebuf);
if(we_cancel)
cancel_busy_cue(-1);
q_status_message(SM_ORDER, 3, 5, wp_err->error);
display_message('x');
dprint((2, "%s\n", ebuf));
if(res)
ldap_msgfree(res);
if(ld)
ldap_unbind(ld);
res = NULL; ld = NULL;
}
else{
int cnt;
cnt = ldap_count_entries(ld, res);
if(cnt > 0){
if(srch_res == LDAP_TIMELIMIT_EXCEEDED ||
srch_res == LDAP_RESULTS_TOO_LARGE ||
srch_res == LDAP_TIMEOUT ||
srch_res == LDAP_SIZELIMIT_EXCEEDED){
wp_err->wp_err_occurred = 1;
ld_errnum = our_ldap_get_lderrno(ld, NULL, &ld_errstr);
snprintf(ebuf, sizeof(ebuf), _("LDAP partial results: %s%s%s%s"),
ldap_err2string(ld_errnum),
serv_errstr,
(ld_errstr && *ld_errstr) ? ": " : "",
(ld_errstr && *ld_errstr) ? ld_errstr : "");
dprint((2, "%s\n", ebuf));
if(wp_err->error)
fs_give((void **)&wp_err->error);
wp_err->error = cpystr(ebuf);
if(we_cancel)
cancel_busy_cue(-1);
q_status_message(SM_ORDER, 3, 5, wp_err->error);
display_message('x');
}
dprint((5, "Matched %d entries on %s\n",
cnt, serv ? serv : "?"));
serv_res = (LDAP_SERV_RES_S *)fs_get(sizeof(LDAP_SERV_RES_S));
memset((void *)serv_res, 0, sizeof(*serv_res));
serv_res->ld = ld;
serv_res->res = res;
serv_res->info_used = copy_ldap_serv_info(info);
/* Save by reference? */
if(info->ref){
snprintf(buf, sizeof(buf), "%s:%s", serv, comatose(info->port));
serv_res->serv = cpystr(buf);
}
else
serv_res->serv = NULL;
serv_res->next = NULL;
}
else{
if(srch_res == LDAP_TIMELIMIT_EXCEEDED ||
srch_res == LDAP_RESULTS_TOO_LARGE ||
srch_res == LDAP_TIMEOUT ||
srch_res == LDAP_SIZELIMIT_EXCEEDED){
wp_err->wp_err_occurred = 1;
wp_err->ldap_errno = srch_res;
ld_errnum = our_ldap_get_lderrno(ld, NULL, &ld_errstr);
snprintf(ebuf, sizeof(ebuf), _("LDAP search failed: %s%s%s%s"),
ldap_err2string(ld_errnum),
serv_errstr,
(ld_errstr && *ld_errstr) ? ": " : "",
(ld_errstr && *ld_errstr) ? ld_errstr : "");
if(wp_err->error)
fs_give((void **)&wp_err->error);
wp_err->error = cpystr(ebuf);
if(we_cancel)
cancel_busy_cue(-1);
q_status_message(SM_ORDER, 3, 5, wp_err->error);
display_message('x');
dprint((2, "%s\n", ebuf));
}
dprint((5, "Matched 0 entries on %s\n",
serv ? serv : "?"));
if(res)
ldap_msgfree(res);
if(ld)
ldap_unbind(ld);
res = NULL; ld = NULL;
}
}
}
}
if(we_cancel)
cancel_busy_cue(-1);
if(we_turned_on)
intr_handling_off();
if(serv)
fs_give((void **)&serv);
if(base)
fs_give((void **)&base);
if(serv_errstr)
fs_give((void **)&serv_errstr);
return(serv_res);
}
int
main(int argc, char *argv[])
#endif
{
UCS c;
register int f;
register int n;
register BUFFER *bp;
int viewflag = FALSE; /* are we starting in view mode?*/
int starton = 0; /* where's dot to begin with? */
int setlocale_collate = 1;
char bname[NBUFN]; /* buffer name of file to read */
char *file_to_edit = NULL;
char *display_charmap = NULL, *dc;
char *keyboard_charmap = NULL;
int use_system = 0;
char *err = NULL;
set_input_timeout(600);
Pmaster = NULL; /* turn OFF composer functionality */
km_popped = 0;
/*
* Read command line flags before initializing, otherwise, we never
* know to init for f_keys...
*/
file_to_edit = pico_args(argc, argv, &starton, &viewflag, &setlocale_collate);
set_collation(setlocale_collate, 1);
#define cpstr(s) strcpy((char *)fs_get(1+strlen(s)), s)
#ifdef _WINDOWS
init_utf8_display(1, NULL);
#else /* UNIX */
if(display_character_set)
display_charmap = cpstr(display_character_set);
#if HAVE_LANGINFO_H && defined(CODESET)
else if((dc = nl_langinfo_codeset_wrapper()) != NULL)
display_charmap = cpstr(dc);
#endif
if(!display_charmap)
display_charmap = cpstr("US-ASCII");
if(keyboard_character_set)
keyboard_charmap = cpstr(keyboard_character_set);
else
keyboard_charmap = cpstr(display_charmap);
if(use_system_translation){
#if PREREQ_FOR_SYS_TRANSLATION
use_system++;
/* This modifies its arguments */
if(setup_for_input_output(use_system, &display_charmap, &keyboard_charmap,
&input_cs, &err) == -1){
fprintf(stderr, "%s\n", err ? err : "trouble with character set");
exit(1);
}
else if(err){
fprintf(stderr, "%s\n", err);
fs_give((void **) &err);
}
#endif
}
if(!use_system){
if(setup_for_input_output(use_system, &display_charmap, &keyboard_charmap,
&input_cs, &err) == -1){
fprintf(stderr, "%s\n", err ? err : "trouble with character set");
exit(1);
}
else if(err){
fprintf(stderr, "%s\n", err);
fs_give((void **) &err);
}
}
if(keyboard_charmap){
set_locale_charmap(keyboard_charmap);
free((void *) keyboard_charmap);
}
if(display_charmap)
free((void *) display_charmap);
#endif /* UNIX */
/*
* There are a couple arguments that we need to be sure
* are converted for internal use.
*/
if(alt_speller)
alt_speller = cpstr(fname_to_utf8(alt_speller));
if(opertree && opertree[0]){
strncpy(opertree, fname_to_utf8(opertree), sizeof(opertree));
opertree[sizeof(opertree)-1] = '\0';
}
if(glo_quote_str_orig)
glo_quote_str = utf8_to_ucs4_cpystr(fname_to_utf8(glo_quote_str_orig));
if(glo_wordseps_orig)
glo_wordseps = utf8_to_ucs4_cpystr(fname_to_utf8(glo_wordseps_orig));
if(file_to_edit)
file_to_edit = cpstr(fname_to_utf8(file_to_edit));
#undef cpstr
#if defined(DOS) || defined(OS2)
if(file_to_edit){ /* strip quotes? */
int l;
if(strchr("'\"", file_to_edit[0])
&& (l = strlen(file_to_edit)) > 1
&& file_to_edit[l-1] == file_to_edit[0]){
file_to_edit[l-1] = '\0'; /* blat trailing quote */
file_to_edit++; /* advance past leading quote */
}
}
#endif
if(!vtinit()) /* Displays. */
exit(1);
strncpy(bname, "main", sizeof(bname)); /* default buffer name */
bname[sizeof(bname)-1] = '\0';
edinit(bname); /* Buffers, windows. */
update(); /* let the user know we are here */
#ifdef _WINDOWS
mswin_setwindow(NULL, NULL, NULL, NULL, NULL, NULL);
mswin_showwindow();
mswin_showcaret(1); /* turn on for main window */
mswin_allowpaste(MSWIN_PASTE_FULL);
mswin_setclosetext("Use the ^X command to exit Pico.");
mswin_setscrollcallback (pico_scroll_callback);
#endif
#if defined(USE_TERMCAP) || defined(USE_TERMINFO) || defined(VMS)
if(kbesc == NULL){ /* will arrow keys work ? */
(*term.t_putchar)('\007');
emlwrite("Warning: keypad keys may be non-functional", NULL);
}
#endif /* USE_TERMCAP/USE_TERMINFO/VMS */
if(file_to_edit){ /* Any file to edit? */
makename(bname, file_to_edit); /* set up a buffer for this file */
bp = curbp; /* read in first file */
makename(bname, file_to_edit);
strncpy(bp->b_bname, bname, sizeof(bp->b_bname));
bp->b_bname[sizeof(bp->b_bname)-1] = '\0';
if(strlen(file_to_edit) >= NFILEN){
char buf[128];
snprintf(buf, sizeof(buf), "Filename \"%.10s...\" too long", file_to_edit);
emlwrite(buf, NULL);
file_to_edit = NULL;
}
else{
strncpy(bp->b_fname, file_to_edit, sizeof(bp->b_fname));
bp->b_fname[sizeof(bp->b_fname)-1] = '\0';
if (((gmode&MDTREE) && !in_oper_tree(file_to_edit)) ||
readin(file_to_edit, (viewflag==FALSE), TRUE) == ABORT) {
if ((gmode&MDTREE) && !in_oper_tree(file_to_edit)){
EML eml;
eml.s = opertree;
emlwrite(_("Can't read file from outside of %s"), &eml);
}
file_to_edit = NULL;
}
}
if(!file_to_edit){
strncpy(bp->b_bname, "main", sizeof(bp->b_bname));
bp->b_bname[sizeof(bp->b_bname)-1] = '\0';
strncpy(bp->b_fname, "", sizeof(bp->b_fname));
bp->b_fname[sizeof(bp->b_fname)-1] = '\0';
}
bp->b_dotp = bp->b_linep;
bp->b_doto = 0;
if (viewflag) /* set the view mode */
bp->b_mode |= MDVIEW;
}
/* setup to process commands */
lastflag = 0; /* Fake last flags. */
curbp->b_mode |= gmode; /* and set default modes*/
curwp->w_flag |= WFMODE; /* and force an update */
if(timeoutset){
EML eml;
eml.s = comatose(get_input_timeout());
emlwrite(_("Checking for new mail every %s seconds"), &eml);
}
forwline(0, starton - 1); /* move dot to specified line */
while(1){
if(km_popped){
km_popped--;
if(km_popped == 0) /* cause bottom three lines to be repainted */
curwp->w_flag |= WFHARD;
}
if(km_popped){ /* temporarily change to cause menu to be painted */
term.t_mrow = 2;
curwp->w_ntrows -= 2;
curwp->w_flag |= WFMODE;
movecursor(term.t_nrow-2, 0); /* clear status line, too */
peeol();
}
update(); /* Fix up the screen */
if(km_popped){
term.t_mrow = 0;
curwp->w_ntrows += 2;
}
#ifdef MOUSE
#ifdef EX_MOUSE
/* New mouse function for real mouse text seletion. */
register_mfunc(mouse_in_pico, 2, 0, term.t_nrow - (term.t_mrow + 1),
term.t_ncol);
#else
mouse_in_content(KEY_MOUSE, -1, -1, 0, 0);
register_mfunc(mouse_in_content, 2, 0, term.t_nrow - (term.t_mrow + 1),
term.t_ncol);
#endif
#endif
#ifdef _WINDOWS
mswin_setdndcallback (pico_file_drop);
mswin_mousetrackcallback(pico_cursor);
#endif
c = GetKey();
#ifdef MOUSE
#ifdef EX_MOUSE
clear_mfunc(mouse_in_pico);
#else
clear_mfunc(mouse_in_content);
#endif
#endif
#ifdef _WINDOWS
mswin_cleardndcallback ();
mswin_mousetrackcallback(NULL);
#endif
if(timeoutset && (c == NODATA || time_to_check())){
if(pico_new_mail())
emlwrite(_("You may possibly have new mail."), NULL);
}
if(km_popped)
switch(c){
case NODATA:
case (CTRL|'L'):
km_popped++;
break;
default:
/* clear bottom three lines */
mlerase();
break;
}
if(c == NODATA)
continue;
if(mpresf){ /* erase message line? */
if(mpresf++ > MESSDELAY)
mlerase();
}
f = FALSE;
n = 1;
#ifdef MOUSE
clear_mfunc(mouse_in_content);
#endif
/* Do it. */
execute(normalize_cmd(c, fkm, 1), f, n);
}
}
/* Ask the user about every occurence of orig pattern and replace it with a
repl pattern if the response is affirmative. */
int
replace_all(UCS *orig, UCS *repl)
{
register int status = 0;
UCS *b;
UCS realpat[NPAT];
char utf8tmp[NPMT];
UCS *promptp;
UCS prompt[NPMT];
int wrapt, n = 0;
LINE *stop_line = curwp->w_dotp;
int stop_offset = curwp->w_doto;
EML eml;
while (1)
if (forscan(&wrapt, orig, stop_line, stop_offset, PTBEG)){
curwp->w_flag |= WFMOVE; /* put cursor back */
update();
(*term.t_rev)(1);
get_pat_cases(realpat, orig);
pputs(realpat, 1); /* highlight word */
(*term.t_rev)(0);
fflush(stdout);
snprintf(utf8tmp, NPMT, "Replace \"");
b = utf8_to_ucs4_cpystr(utf8tmp);
if(b){
ucs4_strncpy(prompt, b, NPMT);
prompt[NPMT-1] = '\0';
fs_give((void **) &b);
}
promptp = &prompt[ucs4_strlen(prompt)];
expandp(orig, promptp, NPMT-(promptp-prompt));
prompt[NPMT-1] = '\0';
promptp += ucs4_strlen(promptp);
b = utf8_to_ucs4_cpystr("\" with \"");
if(b){
ucs4_strncpy(promptp, b, NPMT-(promptp-prompt));
promptp += ucs4_strlen(promptp);
prompt[NPMT-1] = '\0';
fs_give((void **) &b);
}
expandp(repl, promptp, NPMT-(promptp-prompt));
prompt[NPMT-1] = '\0';
promptp += ucs4_strlen(promptp);
if((promptp-prompt) < NPMT-1){
*promptp++ = '\"';
*promptp = '\0';
}
prompt[NPMT-1] = '\0';
status = mlyesno(prompt, TRUE); /* ask user */
if (status == TRUE){
n++;
chword(realpat, repl); /* replace word */
update();
}else{
chword(realpat, realpat); /* replace word by itself */
update();
if(status == ABORT){ /* if cancelled return */
eml.s = comatose(n);
emlwrite("Replace All cancelled after %s changes", &eml);
return (ABORT); /* ... else keep looking */
}
}
}
else{
char *utf8;
utf8 = ucs4_to_utf8_cpystr(orig);
if(utf8){
eml.s = utf8;
emlwrite(_("No more matches for \"%s\""), &eml);
fs_give((void **) &utf8);
}
else
emlwrite(_("No more matches"), NULL);
return (FALSE);
}
}