/*----------------------------------------------------------------------
Add the given number of raw message numbers to the end of the
current list...
Accepts: msgs - pointer to message manipulation struct
n - number to add
Returns: with fixed up msgno struct
Only have to adjust the sort array, as since new mail can't cause
selection!
----*/
void
msgno_add_raw(MSGNO_S *msgs, long int n)
{
long slop, islop, old_total, old_size, old_isize;
size_t len, ilen;
if(!msgs || n <= 0L)
return;
old_total = msgs->max_msgno;
old_size = msgs->sort_size;
old_isize = msgs->isort_size;
slop = (msgs->max_msgno + n + 1L) % 64;
islop = (msgs->nmsgs + n + 1L) % 64;
msgs->sort_size = (msgs->max_msgno + n + 1L) + (64 - slop);
msgs->isort_size = (msgs->nmsgs + n + 1L) + (64 - islop);
len = (size_t) msgs->sort_size * sizeof(long);
ilen = (size_t) msgs->isort_size * sizeof(long);
if(msgs->sort){
if(old_size != msgs->sort_size)
fs_resize((void **) &(msgs->sort), len);
}
else
msgs->sort = (long *) fs_get(len);
if(msgs->isort){
if(old_isize != msgs->isort_size)
fs_resize((void **) &(msgs->isort), ilen);
}
else
msgs->isort = (long *) fs_get(ilen);
while(n-- > 0){
msgs->sort[++msgs->max_msgno] = ++msgs->nmsgs;
msgs->isort[msgs->nmsgs] = msgs->max_msgno;
}
if(old_total <= 0L){ /* if no previous messages, */
if(!msgs->select){ /* select the new message */
msgs->sel_size = 8L;
len = (size_t) msgs->sel_size * sizeof(long);
msgs->select = (long *) fs_get(len);
}
msgs->sel_cnt = 1L;
msgs->sel_cur = 0L;
msgs->select[0] = 1L;
}
}
int scandir (char *dirname,struct _finddata_t ***namelist,select_t select,
compar_t compar)
{
struct _finddata_t *p, d, **names;
int nitems;
long nlmax;
long hDir;
char *filemask = (char *)fs_get((strlen(dirname) + 5) * sizeof(char));
strcpy(filemask, dirname);
strcat(filemask, "/*.*");
hDir = _findfirst(filemask, &d);/* open directory */
fs_give((void **)&filemask);
if (hDir == -1) return -1;
nlmax = 100; /* FIXME how to get number of files in dir? */
names = (struct _finddata_t **) fs_get (nlmax * sizeof (struct _finddata_t *));
nitems = 0; /* initially none found */
do { /* loop over all files */
/* matches select criterion? */
if (select && !(*select) (&d)) continue;
p = (struct _finddata_t *)fs_get(sizeof(d));
strcpy (p->name,d.name);
if (++nitems >= nlmax) { /* if out of space, try bigger guesstimate */
nlmax *= 2; /* double it */
fs_resize ((void **) &names,nlmax * sizeof (struct _finddata_t *));
}
names[nitems - 1] = p; /* store this file there */
}
while (_findnext(hDir, &d) == 0);
_findclose(hDir); /* done with directory */
/* sort if necessary */
if (nitems && compar) qsort (names,nitems,sizeof (struct _finddata_t *),compar);
*namelist = names; /* return directory */
return nitems; /* and size */
}
int scandir (char *dirname,struct direct ***namelist,select_t select,
compar_t compar)
{
struct direct *p,*d,**names;
int nitems;
struct stat stb;
long nlmax;
DIR *dirp = opendir (dirname);/* open directory and get status poop */
if ((!dirp) || (fstat (dirp->dd_fd,&stb) < 0)) return -1;
nlmax = stb.st_size / 24; /* guesstimate at number of files */
names = (struct direct **) fs_get (nlmax * sizeof (struct direct *));
nitems = 0; /* initially none found */
while (d = readdir (dirp)) { /* read directory item */
/* matches select criterion? */
if (select && !(*select) (d)) continue;
/* get size of direct record for this file */
p = (struct direct *) fs_get (DIR_SIZE (d));
p->d_ino = d->d_ino; /* copy the poop */
strcpy (p->d_name,d->d_name);
if (++nitems >= nlmax) { /* if out of space, try bigger guesstimate */
void *s = (void *) names; /* stupid language */
nlmax *= 2; /* double it */
fs_resize ((void **) &s,nlmax * sizeof (struct direct *));
names = (struct direct **) s;
}
names[nitems - 1] = p; /* store this file there */
}
closedir (dirp); /* done with directory */
/* sort if necessary */
if (nitems && compar) qsort (names,nitems,sizeof (struct direct *),compar);
*namelist = names; /* return directory */
return nitems; /* and size */
}
char *
get_prev_hist(HISTORY_S *history, char *savethis, unsigned saveflags, void *cntxt)
{
int nextcurindex;
size_t l;
if(!(history && history->histsize > 0))
return NULL;
nextcurindex = (history->curindex + 1) % history->histsize;
/* already at start of history */
if(nextcurindex == history->origindex
|| !(history->hist[nextcurindex] && history->hist[nextcurindex]->str
&& history->hist[nextcurindex]->str[0]))
return NULL;
/* save what user typed */
if(history->curindex == history->origindex){
if(!savethis)
savethis = "";
if(!history->hist[history->origindex]){
history->hist[history->origindex] = (ONE_HIST_S *) fs_get(sizeof(ONE_HIST_S));
memset(history->hist[history->origindex], 0, sizeof(ONE_HIST_S));
}
if(history->hist[history->origindex]->str){
if(strlen(history->hist[history->origindex]->str) < (l=strlen(savethis)))
fs_resize((void **) &history->hist[history->origindex]->str, l+1);
strncpy(history->hist[history->origindex]->str, savethis, l+1);
history->hist[history->origindex]->str[l] = '\0';
}
else
history->hist[history->origindex]->str = cpystr(savethis);
history->hist[history->origindex]->flags = saveflags;
history->hist[history->origindex]->cntxt = cntxt;
}
history->curindex = nextcurindex;
return((history->hist[history->curindex] && history->hist[history->curindex]->str)
? history->hist[history->curindex]->str : NULL);
}
void
save_hist(HISTORY_S *history, char *savethis, unsigned saveflags, void *cntxt)
{
size_t l;
int plusone;
if(!(history && history->histsize > 0))
return;
plusone = (history->origindex + 1) % history->histsize;
if(!history->hist[history->origindex]){
history->hist[history->origindex] = (ONE_HIST_S *) fs_get(sizeof(ONE_HIST_S));
memset(history->hist[history->origindex], 0, sizeof(ONE_HIST_S));
}
if(savethis && savethis[0]
&& (!history->hist[history->origindex]->str
|| strcmp(history->hist[history->origindex]->str, savethis)
|| history->hist[history->origindex]->flags != saveflags
|| history->hist[history->origindex]->cntxt != cntxt)
&& !(history->hist[plusone] && history->hist[plusone]->str
&& !strcmp(history->hist[plusone]->str, savethis)
&& history->hist[history->origindex]->flags == saveflags
&& history->hist[history->origindex]->cntxt == cntxt)){
if(history->hist[history->origindex]->str){
if(strlen(history->hist[history->origindex]->str) < (l=strlen(savethis)))
fs_resize((void **) &history->hist[history->origindex]->str, l+1);
strncpy(history->hist[history->origindex]->str, savethis, l+1);
history->hist[history->origindex]->str[l] = '\0';
}
else{
history->hist[history->origindex]->str = cpystr(savethis);
}
history->hist[history->origindex]->flags = saveflags;
history->hist[history->origindex]->cntxt = cntxt;
history->origindex = (history->origindex + history->histsize - 1) % history->histsize;
if(history->hist[history->origindex] && history->hist[history->origindex]->str)
history->hist[history->origindex]->str[0] = '\0';
}
}
int
optionally_enter(char *utf8string, int y_base, int x_base, int utf8string_size,
char *utf8prompt, ESCKEY_S *escape_list, HelpType help, int *flags)
{
UCS *string = NULL, ucs;
size_t string_size;
UCS *s2;
UCS *saved_original = NULL;
char *candidate;
UCS *kill_buffer = NULL;
UCS *k, *kb;
int field_pos; /* offset into array dline.vl */
int i, j, return_v, cols, prompt_width, too_thin,
real_y_base, km_popped, passwd;
char **help_text;
long fkey_table[12];
struct key_menu *km;
bitmap_t bitmap;
COLOR_PAIR *lastc = NULL, *promptc = NULL;
struct variable *vars = ps_global->vars;
struct display_line dline;
#ifdef _WINDOWS
int cursor_shown;
#endif
dprint((5, "=== optionally_enter called ===\n"));
dprint((9, "utf8string:\"%s\" y:%d x:%d length: %d append: %d\n",
utf8string ? utf8string : "",
x_base, y_base, utf8string_size,
(flags && *flags & OE_APPEND_CURRENT)));
dprint((9, "passwd:%d utf8prompt:\"%s\" label:\"%s\"\n",
(flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0,
utf8prompt ? utf8prompt : "",
(escape_list && escape_list[0].ch != -1 && escape_list[0].label)
? escape_list[0].label: ""));
if(!ps_global->ttyo)
return(pre_screen_config_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#ifdef _WINDOWS
if (mswin_usedialog ())
return(win_dialog_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#endif
/*
* Utf8string comes in as UTF-8. We'll convert it to a UCS-4 array and operate on
* that array, then convert it back before returning. Utf8string_size is the size
* of the utf8string array but that doesn't help us much for the array we need to
* operate on here. We'll just allocate a big array and then cut it off when
* sending it back.
*
* This should come before the specialized calls above but those aren't
* converted to use UCS-4 yet.
*/
string = utf8_to_ucs4_cpystr(utf8string);
dline.vused = ucs4_strlen(string);
string_size = (2 * MAX(utf8string_size,dline.vused) + 100);
fs_resize((void **) &string, string_size * sizeof(UCS));
suspend_busy_cue();
cols = ps_global->ttyo->screen_cols;
prompt_width = utf8_width(utf8prompt);
too_thin = 0;
km_popped = 0;
if(y_base > 0)
real_y_base = y_base;
else{
real_y_base = y_base + ps_global->ttyo->screen_rows;
real_y_base = MAX(real_y_base, 0);
}
flush_ordered_messages();
mark_status_dirty();
if(flags && *flags & OE_APPEND_CURRENT) /* save a copy in case of cancel */
saved_original = ucs4_cpystr(string);
/*
* build the function key mapping table, skipping predefined keys...
*/
memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(long));
for(i = 0, j = 0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
fkey_table[i+j] = escape_list[i].ch;
}
/* assumption that HelpType is char ** */
help_text = help;
if(help_text){ /*---- Show help text -----*/
int width = ps_global->ttyo->screen_cols - x_base;
if(FOOTER_ROWS(ps_global) == 1){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
y_base = -3;
real_y_base = y_base + ps_global->ttyo->screen_rows;
}
for(j = 0; j < 2 && help_text[j]; j++){
MoveCursor(real_y_base + 1 + j, x_base);
CleartoEOLN();
if(width < utf8_width(help_text[j])){
char *tmp = cpystr(help_text[j]);
(void) utf8_truncate(tmp, width);
PutLine0(real_y_base + 1 + j, x_base, tmp);
fs_give((void **) &tmp);
}
else
PutLine0(real_y_base + 1 + j, x_base, help_text[j]);
}
}
else{
clrbitmap(bitmap);
clrbitmap((km = &oe_keymenu)->bitmap); /* force formatting */
if(!(flags && (*flags) & OE_DISALLOW_HELP))
setbitn(OE_HELP_KEY, bitmap);
setbitn(OE_ENTER_KEY, bitmap);
if(!(flags && (*flags) & OE_DISALLOW_CANCEL))
setbitn(OE_CANCEL_KEY, bitmap);
setbitn(OE_CTRL_T_KEY, bitmap);
/*---- Show the usual possible keys ----*/
for(i=0,j=0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
oe_keymenu.keys[i+j].label = escape_list[i].label;
oe_keymenu.keys[i+j].name = escape_list[i].name;
setbitn(i+j, bitmap);
}
for(i = i+j; i < 12; i++)
if(!(i == OE_HELP_KEY || i == OE_ENTER_KEY || i == OE_CANCEL_KEY))
oe_keymenu.keys[i].name = NULL;
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), 0, FirstMenu);
}
if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
VAR_PROMPT_BACK_COLOR &&
pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
lastc = pico_get_cur_color();
if(lastc){
promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
VAR_PROMPT_BACK_COLOR);
(void)pico_set_colorp(promptc, PSC_NONE);
}
}
else
StartInverse();
/*
* if display length isn't wide enough to support input,
* shorten up the prompt...
*/
if((dline.dwid = cols - (x_base + prompt_width)) < MIN_OPT_ENT_WIDTH){
char *p;
unsigned got_width;
/*
* Scoot prompt pointer forward at least (MIN_OPT_ENT_WIDTH - dline.dwid) screencells.
*/
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH-dline.dwid, &got_width);
if(got_width < MIN_OPT_ENT_WIDTH-dline.dwid)
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH+1-dline.dwid, &got_width);
if(p){
prompt_width = utf8_width(p);
dline.dwid = cols - (x_base + prompt_width);
utf8prompt = p;
}
}
/*
* How many UCS-4 characters will we need to make up the width dwid? It could be
* unlimited because of zero-width characters, I suppose, but realistically it
* isn't going to be much more than dwid.
*/
dline.dlen = 2 * dline.dwid + 100;
dline.dl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
dline.olddl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
dline.movecursor = MoveCursor;
dline.writechar = Writewchar;
dline.row = real_y_base;
dline.col = x_base + prompt_width;
dline.vl = string;
dline.vlen = --string_size; /* -1 for terminating zero */
dline.vbase = field_pos = 0;
#ifdef _WINDOWS
cursor_shown = mswin_showcaret(1);
#endif
PutLine0(real_y_base, x_base, utf8prompt);
/*
* If appending, position field_pos at end of input.
*/
if(flags && *flags & OE_APPEND_CURRENT)
while(string[field_pos])
field_pos++;
passwd = (flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0;
line_paint(field_pos, &dline, &passwd);
/*----------------------------------------------------------------------
The main loop
loops until someone sets the return_v.
----------------------------------------------------------------------*/
return_v = -10;
while(return_v == -10) {
#ifdef MOUSE
mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
register_mfunc(mouse_in_content,
real_y_base, x_base + prompt_width,
real_y_base, ps_global->ttyo->screen_cols);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_LINE);
g_mc_row = real_y_base;
g_mc_col = x_base + prompt_width;
mswin_mousetrackcallback(pcpine_oe_cursor);
#endif
/* Timeout 10 min to keep imap mail stream alive */
ps_global->conceal_sensitive_debugging = passwd ? 1 : 0;
ucs = read_char(600);
ps_global->conceal_sensitive_debugging = 0;
#ifdef MOUSE
clear_mfunc(mouse_in_content);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_DISABLE);
mswin_mousetrackcallback(NULL);
#endif
/*
* Don't want to intercept all characters if typing in passwd.
* We select an ad hoc set that we will catch and let the rest
* through. We would have caught the set below in the big switch
* but we skip the switch instead. Still catch things like ^K,
* DELETE, ^C, RETURN.
*/
if(passwd)
switch(ucs){
case ctrl('F'):
case KEY_RIGHT:
case ctrl('B'):
case KEY_LEFT:
case ctrl('U'):
case ctrl('A'):
case KEY_HOME:
case ctrl('E'):
case KEY_END:
case TAB:
goto ok_for_passwd;
}
if(too_thin && ucs != KEY_RESIZE && ucs != ctrl('Z') && ucs != ctrl('C'))
goto bleep;
switch(ucs){
/*--------------- KEY RIGHT ---------------*/
case ctrl('F'):
case KEY_RIGHT:
if(field_pos >= string_size || string[field_pos] == '\0')
goto bleep;
line_paint(++field_pos, &dline, &passwd);
break;
/*--------------- KEY LEFT ---------------*/
case ctrl('B'):
case KEY_LEFT:
if(field_pos <= 0)
goto bleep;
line_paint(--field_pos, &dline, &passwd);
break;
/*-------------------- WORD SKIP --------------------*/
case ctrl('@'):
/*
* Note: read_char *can* return NO_OP_COMMAND which is
* the def'd with the same value as ^@ (NULL), BUT since
* read_char has a big timeout (>25 secs) it won't.
*/
/* skip thru current word */
while(string[field_pos]
&& isalnum((unsigned char) string[field_pos]))
field_pos++;
/* skip thru current white space to next word */
while(string[field_pos]
&& !isalnum((unsigned char) string[field_pos]))
field_pos++;
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- RETURN --------------------*/
case PF4:
if(F_OFF(F_USE_FK,ps_global)) goto bleep;
case ctrl('J'):
case ctrl('M'):
return_v = 0;
break;
/*-------------------- Destructive backspace --------------------*/
case '\177': /* DEL */
case ctrl('H'):
/* Try and do this with by telling the terminal to delete a
a character. If that fails, then repaint the rest of the
line, acheiving the same much less efficiently
*/
if(field_pos <= 0)
goto bleep;
field_pos--;
/* drop thru to pull line back ... */
/*-------------------- Delete char --------------------*/
case ctrl('D'):
case KEY_DEL:
if(field_pos >= string_size || !string[field_pos])
goto bleep;
dline.vused--;
for(s2 = &string[field_pos]; *s2 != 0; s2++)
*s2 = s2[1];
*s2 = 0; /* Copy last NULL */
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
break;
/*--------------- Kill line -----------------*/
case ctrl('K'):
if(kill_buffer != NULL)
fs_give((void **) &kill_buffer);
if(field_pos != 0 || string[0]){
if(!passwd && F_ON(F_DEL_FROM_DOT, ps_global))
dline.vused -= ucs4_strlen(&string[i = field_pos]);
else
dline.vused = i = 0;
kill_buffer = ucs4_cpystr(&string[field_pos = i]);
string[field_pos] = '\0';
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
}
break;
/*------------------- Undelete line --------------------*/
case ctrl('U'):
if(kill_buffer == NULL)
goto bleep;
/* Make string so it will fit */
kb = ucs4_cpystr(kill_buffer);
if(ucs4_strlen(kb) + ucs4_strlen(string) > string_size)
kb[string_size - ucs4_strlen(string)] = '\0';
if(string[field_pos] == '\0') {
/*--- adding to the end of the string ----*/
for(k = kb; *k; k++)
string[field_pos++] = *k;
string[field_pos] = '\0';
}
else{
int shift;
shift = ucs4_strlen(kb);
/* shift field_pos ... end to right */
for(k = &string[field_pos] + ucs4_strlen(&string[field_pos]);
k >= &string[field_pos]; k--)
*(k+shift) = *k;
for(k = kb; *k; k++)
string[field_pos++] = *k;
}
if(*kb && flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
dline.vused = ucs4_strlen(string);
fs_give((void **) &kb);
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- Interrupt --------------------*/
case ctrl('C'): /* ^C */
if(F_ON(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
goto cancel;
case PF2:
if(F_OFF(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
cancel:
return_v = 1;
if(saved_original){
for(i = 0; saved_original[i]; i++)
string[i] = saved_original[i];
string[i] = 0;
}
break;
case ctrl('A'):
case KEY_HOME:
/*-------------------- Start of line -------------*/
line_paint(field_pos = 0, &dline, &passwd);
break;
case ctrl('E'):
case KEY_END:
/*-------------------- End of line ---------------*/
line_paint(field_pos = dline.vused, &dline, &passwd);
break;
/*-------------------- Help --------------------*/
case ctrl('G') :
case PF1:
if(flags && ((*flags) & OE_DISALLOW_HELP))
goto bleep;
else if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global),
0, FirstMenu);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
mark_keymenu_dirty();
y_base = -3;
dline.row = real_y_base = y_base + ps_global->ttyo->screen_rows;
PutLine0(real_y_base, x_base, utf8prompt);
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
break;
}
if(FOOTER_ROWS(ps_global) > 1){
mark_keymenu_dirty();
return_v = 3;
}
else
goto bleep;
break;
#ifdef MOUSE
/* Mouse support untested in pine 5.00 */
case KEY_MOUSE :
{
MOUSEPRESS mp;
int w;
mouse_get_last (NULL, &mp);
switch(mp.button){
case M_BUTTON_LEFT : /* position cursor */
mp.col -= dline.col;
/*
* We have to figure out which character is under the cursor.
* This is complicated by the fact that characters may
* be other than one cell wide.
*/
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
/* just allow line_paint to choose vbase */
line_paint(field_pos, &dline, &passwd);
break;
case M_BUTTON_RIGHT :
#ifdef _WINDOWS
/*
* Same as M_BUTTON_LEFT except we paste in text after
* moving the cursor.
*/
mp.col -= dline.col;
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
line_paint(field_pos, &dline, &passwd);
mswin_allowpaste(MSWIN_PASTE_LINE);
mswin_paste_popup();
mswin_allowpaste(MSWIN_PASTE_DISABLE);
break;
#endif
case M_BUTTON_MIDDLE : /* NO-OP for now */
default: /* just ignore */
break;
}
}
break;
#endif
case NO_OP_IDLE:
/*
* Keep mail stream alive by checking for new mail.
* If we're asking for a password in a login prompt
* we don't want to check for new_mail because the
* new mail check might be what got us here in the first
* place (because of a filter trying to save a message).
* If we need to wait for the user to come back then
* the caller will just have to deal with the failure
* to login.
*/
i = -1;
if(!ps_global->no_newmail_check_from_optionally_enter)
i = new_mail(0, 2, NM_DEFER_SORT);
if(sp_expunge_count(ps_global->mail_stream) &&
flags && ((*flags) & OE_SEQ_SENSITIVE))
goto cancel;
if(i < 0){
line_paint(field_pos, &dline, &passwd);
break; /* no changes, get on with life */
}
/* Else fall into redraw */
/*-------------------- Redraw --------------------*/
case ctrl('L'):
/*---------------- re size ----------------*/
case KEY_RESIZE:
dline.row = real_y_base = y_base > 0 ? y_base :
y_base + ps_global->ttyo->screen_rows;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
ClearScreen();
redraw_titlebar();
if(ps_global->redrawer != (void (*)(void))NULL)
(*ps_global->redrawer)();
redraw_keymenu();
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
PutLine0(real_y_base, x_base, utf8prompt);
cols = ps_global->ttyo->screen_cols;
too_thin = 0;
if(cols < x_base + prompt_width + 4){
Writechar(BELL, 0);
PutLine0(real_y_base, 0, "Screen's too thin. Ouch!");
too_thin = 1;
}
else{
dline.col = x_base + prompt_width;
dline.dwid = cols - (x_base + prompt_width);
dline.dlen = 2 * dline.dwid + 100;
fs_resize((void **) &dline.dl, (size_t) dline.dlen * sizeof(UCS));
fs_resize((void **) &dline.olddl, (size_t) dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
}
fflush(stdout);
dprint((9,
"optionally_enter RESIZE new_cols:%d too_thin: %d\n",
cols, too_thin));
break;
case PF3 : /* input to potentially remap */
case PF5 :
case PF6 :
case PF7 :
case PF8 :
case PF9 :
case PF10 :
case PF11 :
case PF12 :
if(F_ON(F_USE_FK,ps_global)
&& fkey_table[ucs - PF1] != NO_OP_COMMAND)
ucs = fkey_table[ucs - PF1]; /* remap function key input */
default:
if(escape_list){ /* in the escape key list? */
for(j=0; escape_list[j].ch != -1; j++){
if(escape_list[j].ch == ucs){
return_v = escape_list[j].rval;
break;
}
}
if(return_v != -10)
break;
}
if(ucs < 0x80 && FILTER_THIS((unsigned char) ucs)){
bleep:
putc(BELL, stdout);
continue;
}
ok_for_passwd:
/*--- Insert a character -----*/
if(dline.vused >= string_size)
goto bleep;
/*---- extending the length of the string ---*/
for(s2 = &string[++dline.vused]; s2 - string > field_pos; s2--)
*s2 = *(s2-1);
string[field_pos++] = ucs;
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
} /*---- End of switch on char ----*/
}
#ifdef _WINDOWS
if(!cursor_shown)
mswin_showcaret(0);
#endif
if(dline.dl)
fs_give((void **) &dline.dl);
if(dline.olddl)
fs_give((void **) &dline.olddl);
if(saved_original)
fs_give((void **) &saved_original);
if(kill_buffer)
fs_give((void **) &kill_buffer);
/*
* Change string back into UTF-8.
*/
candidate = ucs4_to_utf8_cpystr(string);
if(string)
fs_give((void **) &string);
if(candidate){
strncpy(utf8string, candidate, utf8string_size);
utf8string[utf8string_size-1] = '\0';
fs_give((void **) &candidate);
}
if (!(flags && (*flags) & OE_KEEP_TRAILING_SPACE))
removing_trailing_white_space(utf8string);
if(lastc){
(void)pico_set_colorp(lastc, PSC_NONE);
free_color_pair(&lastc);
if(promptc)
free_color_pair(&promptc);
}
else
EndInverse();
MoveCursor(real_y_base, x_base); /* Move the cursor to show we're done */
fflush(stdout);
resume_busy_cue(0);
if(km_popped){
FOOTER_ROWS(ps_global) = 1;
clearfooter(ps_global);
ps_global->mangled_body = 1;
}
return(return_v);
}
/*----------------------------------------------------------------------
Initialize a message manipulation structure for the given total
Accepts: msgs - pointer to pointer to message manipulation struct
tot - number of messages to initialize with
----*/
void
msgno_init(MSGNO_S **msgs, long int tot, SortOrder def_sort, int def_sort_rev)
{
long slop = (tot + 1L) % 64;
size_t len;
if(!msgs)
return;
if(!(*msgs)){
(*msgs) = (MSGNO_S *)fs_get(sizeof(MSGNO_S));
memset((void *)(*msgs), 0, sizeof(MSGNO_S));
}
(*msgs)->sel_cur = 0L;
(*msgs)->sel_cnt = 1L;
(*msgs)->sel_size = 8L;
len = (size_t)(*msgs)->sel_size * sizeof(long);
if((*msgs)->select)
fs_resize((void **)&((*msgs)->select), len);
else
(*msgs)->select = (long *)fs_get(len);
(*msgs)->select[0] = (tot) ? 1L : 0L;
(*msgs)->sort_size = (tot + 1L) + (64 - slop);
len = (size_t)(*msgs)->sort_size * sizeof(long);
if((*msgs)->sort)
fs_resize((void **)&((*msgs)->sort), len);
else
(*msgs)->sort = (long *)fs_get(len);
memset((void *)(*msgs)->sort, 0, len);
for(slop = 1L ; slop <= tot; slop++) /* reusing "slop" */
(*msgs)->sort[slop] = slop;
/*
* If there is filtering happening, isort will become larger than sort.
* Sort is a list of raw message numbers in their sorted order. There
* are missing raw numbers because some of the messages are excluded
* (MN_EXLD) from the view. Isort has one entry for every raw message
* number, which maps to the corresponding msgno (the row in the sort
* array). Some of the entries in isort are not used because those
* messages are excluded, but the entry is still there because we want
* to map from rawno to message number and the row number is the rawno.
*/
(*msgs)->isort_size = (*msgs)->sort_size;
if((*msgs)->isort)
fs_resize((void **)&((*msgs)->isort), len);
else
(*msgs)->isort = (long *)fs_get(len);
(*msgs)->max_msgno = tot;
(*msgs)->nmsgs = tot;
/* set the inverse array */
msgno_reset_isort(*msgs);
(*msgs)->sort_order = def_sort;
(*msgs)->reverse_sort = def_sort_rev;
(*msgs)->flagged_hid = 0L;
(*msgs)->flagged_exld = 0L;
(*msgs)->flagged_chid = 0L;
(*msgs)->flagged_chid2= 0L;
(*msgs)->flagged_coll = 0L;
(*msgs)->flagged_usor = 0L;
(*msgs)->flagged_tmp = 0L;
(*msgs)->flagged_stmp = 0L;
/*
* This one is the total number of messages which are flagged
* hid OR chid. It isn't the sum of those two because a
* message may be flagged both at the same time.
*/
(*msgs)->flagged_invisible = 0L;
/*
* And this keeps track of visible threads in the THRD_INDX. This is
* weird because a thread is visible if any of its messages are
* not hidden, including those that are CHID hidden. You can't just
* count up all the messages that are hid or chid because you would
* miss a thread that has its top-level message hidden but some chid
* message not hidden.
*/
(*msgs)->visible_threads = -1L;
}
/*----------------------------------------------------------------------
Accepts: stream -- mail stream to removed message references from
msgs -- pointer to message manipulation struct
flags
MI_REFILTERING -- do includes appropriate for refiltering
MI_STATECHGONLY -- when refiltering, maybe only re-include
messages which have had state changes
since they were originally filtered
Returns 1 if any new messages are included (indicating that we need
to re-sort)
0 if no new messages are included
----*/
int
msgno_include(MAILSTREAM *stream, MSGNO_S *msgs, int flags)
{
long i, slop, old_total, old_size;
int exbits, ret = 0;
size_t len;
MESSAGECACHE *mc;
if(!msgs)
return(ret);
for(i = 1L; i <= stream->nmsgs; i++){
if(!msgno_exceptions(stream, i, "0", &exbits, FALSE))
exbits = 0;
if((((flags & MI_REFILTERING) && (exbits & MSG_EX_FILTERED)
&& !(exbits & MSG_EX_FILED)
&& (!(flags & MI_STATECHGONLY) || (exbits & MSG_EX_STATECHG)))
|| (!(flags & MI_REFILTERING) && !(exbits & MSG_EX_FILTERED)))
&& get_lflag(stream, NULL, i, MN_EXLD)){
old_total = msgs->max_msgno;
old_size = msgs->sort_size;
slop = (msgs->max_msgno + 1L) % 64;
msgs->sort_size = (msgs->max_msgno + 1L) + (64 - slop);
len = (size_t) msgs->sort_size * sizeof(long);
if(msgs->sort){
if(old_size != msgs->sort_size)
fs_resize((void **)&(msgs->sort), len);
}
else
msgs->sort = (long *)fs_get(len);
ret = 1;
msgs->sort[++msgs->max_msgno] = i;
msgs->isort[i] = msgs->max_msgno;
set_lflag(stream, msgs, msgs->max_msgno, MN_EXLD, 0);
if(flags & MI_REFILTERING){
exbits &= ~(MSG_EX_FILTERED | MSG_EX_TESTED);
msgno_exceptions(stream, i, "0", &exbits, TRUE);
}
if(old_total <= 0L){ /* if no previous messages, */
if(!msgs->select){ /* select the new message */
msgs->sel_size = 8L;
len = (size_t)msgs->sel_size * sizeof(long);
msgs->select = (long *)fs_get(len);
}
msgs->sel_cnt = 1L;
msgs->sel_cur = 0L;
msgs->select[0] = 1L;
}
}
else if((flags & MI_REFILTERING)
&& (exbits & (MSG_EX_FILTERED | MSG_EX_TESTED))
&& !(exbits & MSG_EX_FILED)
&& (!(exbits & MSG_EX_MANUNDEL)
|| ((mc = mail_elt(stream, i)) && mc->deleted))
&& (!(flags & MI_STATECHGONLY) || (exbits & MSG_EX_STATECHG))){
/*
* We get here if the message was filtered by a filter that
* just changes status bits (it wasn't excluded), and now also
* if the message was merely tested for filtering. It has also
* not been manually undeleted. If it was manually undeleted, we
* don't want to reprocess the filter, undoing the user's
* manual undeleting. Of course, a new pine will re check this
* message anyway, so the user had better be using this
* manual undeleting only to temporarily save him or herself
* from an expunge before Saving or printing or something.
* Also, we want to still try filtering if the message has at
* all been marked deleted, even if the there was any manual
* undeleting, since this directly precedes an expunge, we want
* to make sure the filter does the right thing before getting
* rid of the message forever.
*/
exbits &= ~(MSG_EX_FILTERED | MSG_EX_TESTED);
msgno_exceptions(stream, i, "0", &exbits, TRUE);
}
}
return(ret);
}
/*----------------------------------------------------------------------
Open the printer
Args: desc -- Description of item to print. Should have one trailing blank.
Return value: < 0 is a failure.
0 a success.
This does most of the work of popen so we can save the standard output of the
command we execute and send it back to the user.
----*/
int
open_printer(char *desc)
{
#ifndef _WINDOWS
char command[201], prompt[200];
int cmd, rc, just_one;
char *p, *init, *nick;
char aname[100], wname[100];
char *printer;
int done = 0, i, lastprinter, cur_printer = 0;
HelpType help;
char **list;
static ESCKEY_S ekey[] = {
/* TRANSLATORS: these are command labels for printing screen */
{'y', 'y', "Y", N_("Yes")},
{'n', 'n', "N", N_("No")},
/* TRANSLATORS: go to Previous Printer in list */
{ctrl('P'), 10, "^P", N_("Prev Printer")},
{ctrl('N'), 11, "^N", N_("Next Printer")},
{-2, 0, NULL, NULL},
/* TRANSLATORS: use Custom Print command */
{'c', 'c', "C", N_("CustomPrint")},
{KEY_UP, 10, "", ""},
{KEY_DOWN, 11, "", ""},
{-1, 0, NULL, NULL}};
#define PREV_KEY 2
#define NEXT_KEY 3
#define CUSTOM_KEY 5
#define UP_KEY 6
#define DOWN_KEY 7
trailer = NULL;
init = NULL;
nick = NULL;
command[sizeof(command)-1] = '\0';
if(ps_global->VAR_PRINTER == NULL){
q_status_message(SM_ORDER | SM_DING, 3, 5,
"No printer has been chosen. Use SETUP on main menu to make choice.");
return(-1);
}
/* Is there just one print command available? */
just_one = (ps_global->printer_category!=3&&ps_global->printer_category!=2)
|| (ps_global->printer_category == 2
&& !(ps_global->VAR_STANDARD_PRINTER
&& ps_global->VAR_STANDARD_PRINTER[0]
&& ps_global->VAR_STANDARD_PRINTER[1]))
|| (ps_global->printer_category == 3
&& !(ps_global->VAR_PERSONAL_PRINT_COMMAND
&& ps_global->VAR_PERSONAL_PRINT_COMMAND[0]
&& ps_global->VAR_PERSONAL_PRINT_COMMAND[1]));
if(F_ON(F_CUSTOM_PRINT, ps_global))
ekey[CUSTOM_KEY].ch = 'c'; /* turn this key on */
else
ekey[CUSTOM_KEY].ch = -2; /* turn this key off */
if(just_one){
ekey[PREV_KEY].ch = -2; /* turn these keys off */
ekey[NEXT_KEY].ch = -2;
ekey[UP_KEY].ch = -2;
ekey[DOWN_KEY].ch = -2;
}
else{
ekey[PREV_KEY].ch = ctrl('P'); /* turn these keys on */
ekey[NEXT_KEY].ch = ctrl('N');
ekey[UP_KEY].ch = KEY_UP;
ekey[DOWN_KEY].ch = KEY_DOWN;
/*
* count how many printers in list and find the default in the list
*/
if(ps_global->printer_category == 2)
list = ps_global->VAR_STANDARD_PRINTER;
else
list = ps_global->VAR_PERSONAL_PRINT_COMMAND;
for(i = 0; list[i]; i++)
if(strcmp(ps_global->VAR_PRINTER, list[i]) == 0)
cur_printer = i;
lastprinter = i - 1;
}
help = NO_HELP;
ps_global->mangled_footer = 1;
while(!done){
if(init)
fs_give((void **)&init);
if(trailer)
fs_give((void **)&trailer);
if(just_one)
printer = ps_global->VAR_PRINTER;
else
printer = list[cur_printer];
parse_printer(printer, &nick, &p, &init, &trailer, NULL, NULL);
strncpy(command, p, sizeof(command)-1);
command[sizeof(command)-1] = '\0';
fs_give((void **)&p);
/* TRANSLATORS: Print something1 using something2.
For example, Print configuration using printer three. */
snprintf(prompt, sizeof(prompt), _("Print %s using \"%s\" ? "),
desc ? desc : "",
*nick ? nick : command);
prompt[sizeof(prompt)-1] = '\0';
fs_give((void **)&nick);
cmd = radio_buttons(prompt, -FOOTER_ROWS(ps_global),
ekey, 'y', 'x', help, RB_NORM);
switch(cmd){
case 'y':
q_status_message1(SM_ORDER, 0, 9,
"Printing with command \"%s\"", command);
done++;
break;
case 10:
cur_printer = (cur_printer>0)
? (cur_printer-1)
: lastprinter;
break;
case 11:
cur_printer = (cur_printer<lastprinter)
? (cur_printer+1)
: 0;
break;
case 'n':
case 'x':
done++;
break;
case 'c':
done++;
break;
default:
break;
}
}
if(cmd == 'c'){
if(init)
fs_give((void **)&init);
if(trailer)
fs_give((void **)&trailer);
snprintf(prompt, sizeof(prompt), "Enter custom command : ");
prompt[sizeof(prompt)-1] = '\0';
command[0] = '\0';
rc = 1;
help = NO_HELP;
while(rc){
int flags = OE_APPEND_CURRENT;
rc = optionally_enter(command, -FOOTER_ROWS(ps_global), 0,
sizeof(command), prompt, NULL, help, &flags);
if(rc == 1){
cmd = 'x';
rc = 0;
}
else if(rc == 3)
help = (help == NO_HELP) ? h_custom_print : NO_HELP;
else if(rc == 0){
removing_trailing_white_space(command);
removing_leading_white_space(command);
q_status_message1(SM_ORDER, 0, 9,
"Printing with command \"%s\"", command);
}
}
}
if(cmd == 'x' || cmd == 'n'){
q_status_message(SM_ORDER, 0, 2, "Print cancelled");
if(init)
fs_give((void **)&init);
if(trailer)
fs_give((void **)&trailer);
return(-1);
}
display_message('x');
ps_global->print = (PRINT_S *)fs_get(sizeof(PRINT_S));
memset(ps_global->print, 0, sizeof(PRINT_S));
strncpy(aname, ANSI_PRINTER, sizeof(aname)-1);
aname[sizeof(aname)-1] = '\0';
strncat(aname, "-no-formfeed", sizeof(aname)-strlen(aname)-1);
strncpy(wname, WYSE_PRINTER, sizeof(wname)-1);
wname[sizeof(wname)-1] = '\0';
strncat(wname, "-no-formfeed", sizeof(wname)-strlen(wname)-1);
if(strucmp(command, ANSI_PRINTER) == 0
|| strucmp(command, aname) == 0
|| strucmp(command, WYSE_PRINTER) == 0
|| strucmp(command, wname) == 0){
/*----------- Attached printer ---------*/
q_status_message(SM_ORDER, 0, 9,
"Printing to attached desktop printer...");
display_message('x');
xonxoff_proc(1); /* make sure XON/XOFF used */
crlf_proc(1); /* AND LF->CR xlation */
if(strucmp(command, ANSI_PRINTER) == 0
|| strucmp(command, aname) == 0){
fputs("\033[5i", stdout);
ansi_off = 1;
}
else{
ansi_off = 0;
printf("%c", 18); /* aux on for wyse60,
Chuck Everett <*****@*****.**> */
}
ps_global->print->fp = stdout;
if(strucmp(command, ANSI_PRINTER) == 0
|| strucmp(command, WYSE_PRINTER) == 0){
/* put formfeed at the end of the trailer string */
if(trailer){
int len = strlen(trailer);
fs_resize((void **)&trailer, len+2);
trailer[len] = '\f';
trailer[len+1] = '\0';
}
else
trailer = cpystr("\f");
}
}
else{
/*----------- Print by forking off a UNIX command ------------*/
dprint((4, "Printing using command \"%s\"\n",
command ? command : "?"));
ps_global->print->result = temp_nam(NULL, "pine_prt");
if(ps_global->print->result &&
(ps_global->print->pipe = open_system_pipe(command,
&ps_global->print->result, NULL,
PIPE_WRITE | PIPE_STDERR, 0,
pipe_callback, NULL))){
ps_global->print->fp = ps_global->print->pipe->out.f;
}
else{
if(ps_global->print->result){
our_unlink(ps_global->print->result);
fs_give((void **)&ps_global->print->result);
}
q_status_message1(SM_ORDER | SM_DING, 3, 4,
"Error opening printer: %s",
error_description(errno));
dprint((2, "Error popening printer \"%s\"\n",
error_description(errno)));
if(init)
fs_give((void **)&init);
if(trailer)
fs_give((void **)&trailer);
return(-1);
}
}
ps_global->print->err = 0;
if(init){
if(*init)
fputs(init, ps_global->print->fp);
fs_give((void **)&init);
}
cb.cbuf[0] = '\0';
cb.cbufp = cb.cbuf;
cb.cbufend = cb.cbuf;
#else /* _WINDOWS */
int status;
LPTSTR desclpt = NULL;
if(desc)
desclpt = utf8_to_lptstr(desc);
if (status = mswin_print_ready (0, desclpt)) {
q_status_message1(SM_ORDER | SM_DING, 3, 4,
"Error starting print job: %s",
mswin_print_error(status));
if(desclpt)
fs_give((void **) &desclpt);
return(-1);
}
if(desclpt)
fs_give((void **) &desclpt);
q_status_message(SM_ORDER, 0, 9, "Printing to windows printer...");
display_message('x');
/* init print control structure */
ps_global->print = (PRINT_S *)fs_get(sizeof(PRINT_S));
memset(ps_global->print, 0, sizeof(PRINT_S));
ps_global->print->err = 0;
#endif /* _WINDOWS */
return(0);
}
void fs_test(int tid)
{
fun_string f[25];
unsigned char d1[] = "kungfu\0kaleidescopes", d2[] = "funintheSun";
size_t count;
printf("[%d] START: FUN STRING test!\n", tid);
assert(f[1] = fs_new(d1, 20, 0));
assert(f[2] = fs_new(d1, 20, 0));
assert(f[3] = fs_new(d2, 11, 0));
assert(!fs_cmp(f[1], f[2]));
assert(fs_cmp(f[1], f[3]));
assert(f[4] = fs_resize(f[1], 10));
assert(f[5] = fs_resize(f[2], 15));
assert(f[6] = fs_resize(f[3], 10));
assert(fs_cmp(f[4], f[5]));
assert(!fs_ncmp(f[4], f[5], 10));
assert(!fs_ncmp(f[3], f[6], 10));
assert(f[7] = fs_access(f[1], 3, 10));
assert(f[8] = fs_access(f[4], 3, 5));
assert(f[9] = fs_access(f[5], 5, 10));
assert(!fs_ncmp(f[7], f[8], 3));
assert(fs_cmp(f[7], f[8]));
assert(fs_ncmp(f[7], f[9], 5));
assert(10 == fs_len(f[7]));
assert(5 == fs_len(f[8]));
assert(10 == fs_len(f[7]));
assert(20 == fs_len(f[1]));
assert(10 == fs_len(f[4]));
assert(11 == fs_len(f[3]));
assert(f[10] = fs_set(f[1], '9', 40));
assert(f[11] = fs_set(f[1], '9', 50));
assert(f[12] = fs_set(f[1], 'A', 40));
assert(!fs_ncmp(f[10], f[11], 30));
assert(fs_cmp(f[10], f[11]));
assert(fs_cmp(f[10], f[12]));
assert(fs_cmp(f[1], f[10]));
assert(f[13] = fs_dup(f[1]));
assert(f[14] = fs_dup(f[2]));
assert(f[15] = fs_dup(f[4]));
assert(!fs_cmp(f[13], f[14]));
assert(!fs_ncmp(f[13], f[15], 5));
assert(fs_cmp(f[13], f[6]));
assert(f[16] = fs_chr(f[1], 'g'));
assert(f[17] = fs_chr(f[4], 'g'));
assert(f[18] = fs_rchr(f[1], 'g'));
assert(!fs_ncmp(f[16], f[17], 3));
assert(!fs_cmp(f[16], f[18]));
assert(fs_cmp(f[16], f[7]));
assert(f[19] = fs_cat(f[3], f[16]));
assert(f[20] = fs_cat(f[3], f[18]));
assert(f[21] = fs_ncat(f[3], f[17], 2));
assert(!fs_cmp(f[19], f[20]));
assert(fs_cmp(f[19], f[21]));
assert(!fs_ncmp(f[19], f[21], 13));
// To test
// cat
// ncat
fs_free(&f[1]);
fs_free(&f[2]);
fs_free(&f[3]);
fs_free(&f[4]);
fs_free(&f[5]);
fs_free(&f[6]);
fs_free(&f[7]);
fs_free(&f[8]);
fs_free(&f[9]);
fs_free(&f[10]);
fs_free(&f[11]);
fs_free(&f[12]);
fs_free(&f[13]);
fs_free(&f[14]);
fs_free(&f[15]);
fs_free(&f[16]);
fs_free(&f[17]);
fs_free(&f[18]);
fs_free(&f[19]);
fs_free(&f[20]);
fs_free(&f[21]);
printf("[%d] Strings destroyed!\n", tid);
printf("[%d] END: FUN STRING Test!\n\n", tid);
return;
}
int main (int argc,char *argv[])
{
MAILSTREAM *source = NIL;
MAILSTREAM *dest = NIL;
SEARCHPGM *criteria;
char c,*s,*dp,*t,*t1,tmp[MAILTMPLEN],mbx[MAILTMPLEN];
unsigned long m,len,curlen,start,last;
int i;
int merge = NIL;
int retcode = 1;
int moreswitchp = T;
char *cmd = NIL;
char *src = NIL;
char *dst = NIL;
char *pgm = argc ? argv[0] : "mailutil";
#include "linkage.c"
for (i = 1; i < argc; i++) {
s = argv[i]; /* pick up argument */
/* parse switches */
if (moreswitchp && (*s == '-')) {
if (!strcmp (s,"-debug") || !strcmp (s,"-d")) debugp = T;
else if (!strcmp (s,"-verbose") || !strcmp (s,"-v")) verbosep = T;
else if (!strcmp (s,"-rwcopy") || !strcmp (s,"-rw")) rwcopyp = T;
else if (!strcmp (s,"-kwcopy") || !strcmp (s,"-kw")) kwcopyp = T;
else if (!strcmp (s,"-ignore") || !strcmp (s,"-ig")) ignorep = T;
else if ((!strcmp (s,"-merge") || !strcmp (s,"-m")) && (++i < argc)) {
if (!strcmp (s = argv[i],"prompt")) merge = mPROMPT;
else if (!strcmp (s,"append")) merge = mAPPEND;
else if (!strncmp (s,"suffix=",7) && s[7]) {
merge = mSUFFIX;
suffix = cpystr (s+7);
}
else {
printf ("unknown merge option: %s\n",s);
exit (retcode);
}
}
#ifdef SYSCONFIG
else if ((!strcmp (s,"-user") || !strcmp (s,"-u")) && (++i < argc)) {
struct passwd *pw = getpwnam (s = argv[i]);
if (!pw) {
printf ("unknown user id: %s\n",argv[i]);
exit (retcode);
}
else if (setuid (pw->pw_uid)) {
perror ("unable to change user id");
exit (retcode);
}
}
#endif
/* -- means no more switches, so mailbox
name can start with "-" */
else if ((s[1] == '-') && !s[2]) moreswitchp = NIL;
else {
printf ("unknown switch: %s\n",s);
exit (retcode);
}
}
else if (!cmd) cmd = s; /* first non-switch is command */
else if (!src) src = s; /* second non-switch is source */
else if (!dst) dst = s; /* third non-switch is destination */
else {
printf ("unknown argument: %s\n",s);
exit (retcode);
}
}
if (kwcopyp && ignorep) {
puts ("-kwcopy and -ignore are mutually exclusive");
exit (retcode);
}
if (!cmd) cmd = ""; /* prevent SEGV */
if (!strcmp (cmd,"check")) { /* check for new messages */
if (!src) src = "INBOX";
if (dst || merge || rwcopyp || kwcopyp || ignorep)
printf (usage2,pgm,usgchk,stdsw);
else if (mail_status (source = (*src == '{') ?
mail_open (NIL,src,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL)) : NIL,
src,SA_MESSAGES | SA_RECENT | SA_UNSEEN))
retcode = 0;
}
else if (!strcmp (cmd,"create")) {
if (!src || dst || merge || rwcopyp || kwcopyp || ignorep)
printf (usage2,pgm,usgcre,stdsw);
else if (mail_create (source = (*src == '{') ?
mail_open (NIL,src,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL)) : NIL,src))
retcode = 0;
}
else if (!strcmp (cmd,"delete")) {
if (!src || dst || merge || rwcopyp || kwcopyp || ignorep)
printf (usage2,pgm,usgdel,stdsw);
else if (mail_delete (source = (*src == '{') ?
mail_open (NIL,src,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL)) : NIL,src))
retcode = 0;
}
else if (!strcmp (cmd,"rename")) {
if (!src || !dst || merge || rwcopyp || kwcopyp || ignorep)
printf (usage2,pgm,usgren,stdsw);
else if (mail_rename (source = (*src == '{') ?
mail_open (NIL,src,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL)) : NIL,src,dst))
retcode = 0;
}
else if ((i = !strcmp (cmd,"move")) || !strcmp (cmd,"copy")) {
if (!src || !dst || merge) printf (usage3,pgm,cmd,usgcpymov,stdsw);
else if (source = mail_open (NIL,src,((i || rwcopyp) ? NIL : OP_READONLY) |
(debugp ? OP_DEBUG : NIL))) {
dest = NIL; /* open destination stream if network */
if ((*dst != '{') || (dest = mail_open (NIL,dst,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL)))) {
if (mbxcopy (source,dest,dst,T,i,merge)) retcode = 0;
}
}
}
else if ((i = !strcmp (cmd,"appenddelete")) || !strcmp (cmd,"append")) {
if (!src || !dst || merge) printf (usage3,pgm,cmd,usgappdel,stdsw);
else if (source = mail_open (NIL,src,((i || rwcopyp) ? NIL : OP_READONLY) |
(debugp ? OP_DEBUG : NIL))) {
dest = NIL; /* open destination stream if network */
if ((*dst != '{') || (dest = mail_open (NIL,dst,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL)))) {
if (mbxcopy (source,dest,dst,NIL,i,merge)) retcode = 0;
}
}
}
else if (!strcmp (cmd,"prune")) {
if (!src || !dst || merge || rwcopyp || kwcopyp || ignorep ||
!(criteria = prune_criteria (dst))) printf (usage2,pgm,usgprn,stdsw);
else if ((source = mail_open (NIL,src,(debugp ? OP_DEBUG : NIL))) &&
mail_search_full (source,NIL,criteria,SE_FREE)) {
for (m = 1, s = t = NIL, len = start = last = 0; m <= source->nmsgs; m++)
if (mail_elt (source,m)->searched) {
if (s) { /* continuing a range? */
if (m == last + 1) last = m;
else { /* no, end of previous range? */
if (last != start) sprintf (t,":%lu,%lu",last,m);
/* no, just this message */
else sprintf (t,",%lu",m);
start = last = m; /* either way, start new range */
/* running out of space? */
if ((len - (curlen = (t += strlen (t)) - s)) < 20) {
fs_resize ((void **) &s,len += MAILTMPLEN);
t = s + curlen; /* relocate current pointer */
}
}
}
else { /* first time, start new buffer */
s = (char *) fs_get (len = MAILTMPLEN);
sprintf (s,"%lu",start = last = m);
t = s + strlen (s); /* end of buffer */
}
}
/* finish last range if necessary */
if (last != start) sprintf (t,":%lu",last);
if (s) { /* delete/expunge any matching messages */
mail_flag (source,s,"\\Deleted",ST_SET);
m = source->nmsgs; /* get number of messages before purge */
mail_expunge (source);
printf ("%lu message(s) purged\n",m - source->nmsgs);
fs_give ((void **) &s); /* flush buffer */
}
else puts ("No matching messages, so nothing purged");
source = mail_close (source);
}
}
else if (!strcmp (cmd,"transfer")) {
if (!src || !dst) printf (usage2,pgm,usgxfr,stdsw);
else if ((*src == '{') && /* open source mailbox */
!(source = mail_open (NIL,src,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL))));
else if ((*dst == '{') && /* open destination server */
!(dest = mail_open (NIL,dst,OP_HALFOPEN |
(debugp ? OP_DEBUG : NIL))));
else if (!(f = tmpfile ())) puts ("can't open temporary file");
else {
if (verbosep) puts ("Listing mailboxes...");
if (dest) strcpy (strchr (strcpy (tmp,dest->mailbox),'}') + 1,
dp = strchr (dst,'}') + 1);
else {
dp = dst;
tmp[0] = '\0';
}
mail_list (dest,tmp,"");
rewind (f); /* list all mailboxes matching prefix */
if (ddelim < 0) { /* if server failed to give delimiter */
puts ("warning: unable to get destination hierarchy delimiter!");
ddelim = 0; /* default to none */
}
if (source) strcpy (strchr (strcpy (tmp,source->mailbox),'}') + 1,
strchr (src,'}') + 1);
else strcpy (tmp,src);
mail_list (source,tmp,"*");
rewind (f);
/* read back mailbox names */
for (retcode = 0; !retcode && (fgets (tmp,MAILTMPLEN-1,f)); ) {
if (t = strchr (tmp+1,'\n')) *t = '\0';
for (t = mbx,t1 = dest ? dest->mailbox : "",c = NIL; (c != '}') && *t1;
*t++ = c= *t1++);
for (t1 = dp; *t1; *t++ = *t1++);
/* point to name without delim or netspec */
t1 = source ? (strchr (tmp+1,'}') + 1) : tmp + 1;
/* src and mbx have different delimiters? */
if (ddelim && (ddelim != tmp[0]))
while (c = *t1++) { /* swap delimiters then */
if (c == ddelim) c = tmp[0] ? tmp[0] : 'x';
else if (c == tmp[0]) c = ddelim;
*t++ = c;
}
/* easy case */
else while (*t1) *t++ = *t1++;
*t++ = '\0';
if (verbosep) {
printf ("Copying %s\n => %s\n",tmp+1,mbx);
fflush (stdout);
}
if (source = mail_open (source,tmp+1,(debugp ? OP_DEBUG : NIL) |
(rwcopyp ? NIL : OP_READONLY))) {
if (!mbxcopy (source,dest,mbx,T,NIL,merge)) retcode = 1;
if (source->dtb->flags & DR_LOCAL) source = mail_close (source);
}
else printf ("can't open source mailbox %s\n",tmp+1);
}
}
}
else {
printf ("%s version %s.%s\n\n",pgm,CCLIENTVERSION,version);
printf (usage2,pgm,"command [switches] arguments",stdsw);
printf ("\nCommands:\n %s\n",usgchk);
puts (" ;; report number of messages and new messages");
printf (" %s\n",usgcre);
puts (" ;; create new mailbox");
printf (" %s\n",usgdel);
puts (" ;; delete existing mailbox");
printf (" %s\n",usgren);
puts (" ;; rename mailbox to a new name");
printf (" copy %s\n",usgcpymov);
printf (" move %s\n",usgcpymov);
puts (" ;; create new mailbox and copy/move messages");
printf (" append %s\n",usgappdel);
printf (" appenddelete %s\n",usgappdel);
puts (" ;; copy/move messages to existing mailbox");
printf (" %s\n",usgprn);
puts (" ;; prune mailbox of messages matching criteria");
printf (" %s\n",usgxfr);
puts (" ;; copy source hierarchy to destination");
puts (" ;; -merge modes are prompt, append, or suffix=xxxx");
}
/* close streams */
if (source) mail_close (source);
if (dest) mail_close (dest);
exit (retcode);
return retcode; /* stupid compilers */
}
/*----------------------------------------------------------------------
Function to control flag set/clearing
Basically, turn the flags into a fake list of features...
Returns 0 unless user has added a keyword, then 1.
----*/
int
flag_maintenance_screen(struct pine *ps, struct flag_screen *flags)
{
int i, lv, lc, maxwidth, offset, need, rv = 0;
char tmp[1200], **p, *spacer;
CONF_S *ctmpa, *first_line;
struct flag_table *fp;
OPT_SCREEN_S screen;
try_again:
maxwidth = MAX(MIN((ps->ttyo ? ps->ttyo->screen_cols : 80), 150), 30);
first_line = NULL;
ctmpa = NULL;
for(p = flags->explanation; p && *p; p++) {
new_confline(&ctmpa);
ctmpa->keymenu = &flag_keymenu;
ctmpa->help = NO_HELP;
ctmpa->tool = flag_checkbox_tool;
ctmpa->flags |= CF_NOSELECT;
ctmpa->valoffset = 0;
ctmpa->value = cpystr(_(*p));
}
/* Now wire flags checkboxes together */
for(lv = 0, lc = 0, fp = (flags->flag_table ? *flags->flag_table : NULL);
fp && fp->name; fp++) { /* longest name */
if(fp->flag != F_COMMENT) {
if(lv < (i = utf8_width(_(fp->name))))
lv = i;
if(fp->comment && lc < (i = utf8_width(fp->comment)))
lc = i;
}
}
lv = MIN(lv,100);
lc = MIN(lc,100);
if(lc > 0)
spacer = " ";
else
spacer = "";
offset = 6;
if((need = offset + 5 + lv + strlen(spacer) + lc) > maxwidth) {
offset -= (need - maxwidth);
offset = MAX(0,offset);
if((need = offset + 5 + lv + strlen(spacer) + lc) > maxwidth) {
spacer = " ";
if((need = offset + 5 + lv + strlen(spacer) + lc) > maxwidth) {
lc -= (need - maxwidth);
lc = MAX(0,lc);
if(lc == 0)
spacer = "";
}
}
}
new_confline(&ctmpa);
ctmpa->keymenu = &flag_keymenu;
ctmpa->help = NO_HELP;
ctmpa->tool = flag_checkbox_tool;
ctmpa->flags |= CF_NOSELECT;
ctmpa->valoffset = 0;
ctmpa->value = cpystr("");
new_confline(&ctmpa);
ctmpa->keymenu = &flag_keymenu;
ctmpa->help = NO_HELP;
ctmpa->tool = flag_checkbox_tool;
ctmpa->flags |= CF_NOSELECT;
ctmpa->valoffset = 0;
utf8_snprintf(tmp, sizeof(tmp), "%*.*w %s", offset+3, offset+3, _("Set"), _("Flag/Keyword Name"));
tmp[sizeof(tmp)-1] = '\0';
ctmpa->value = cpystr(tmp);
new_confline(&ctmpa);
ctmpa->keymenu = &flag_keymenu;
ctmpa->help = NO_HELP;
ctmpa->tool = flag_checkbox_tool;
ctmpa->flags |= CF_NOSELECT;
ctmpa->valoffset = 0;
snprintf(tmp, sizeof(tmp), "%*.*s--- %.*s",
offset, offset, "",
lv+lc+strlen(spacer), repeat_char(lv+lc+strlen(spacer), '-'));
tmp[sizeof(tmp)-1] = '\0';
ctmpa->value = cpystr(tmp);
for(fp = (flags->flag_table ? *flags->flag_table : NULL);
fp && fp->name; fp++) { /* build the list */
new_confline(&ctmpa);
if(!first_line && (fp->flag != F_COMMENT))
first_line = ctmpa;
ctmpa->keymenu = &flag_keymenu;
ctmpa->tool = flag_checkbox_tool;
ctmpa->valoffset = offset;
if(fp->flag == F_COMMENT) {
ctmpa->help = NO_HELP;
ctmpa->flags |= CF_NOSELECT;
ctmpa->value = cpystr(fp->name);
}
else {
ctmpa->help = fp->help;
ctmpa->d.f.ftbl = flags->flag_table;
ctmpa->d.f.fp = fp;
utf8_snprintf(tmp, sizeof(tmp), "[%c] %-*.*w%s%-*.*w",
(fp->set == 0) ? ' ' : (fp->set == 1) ? 'X' : '?',
lv, lv, _(fp->name),
spacer, lc, lc, fp->comment ? fp->comment : "");
ctmpa->value = cpystr(tmp);
}
}
memset(&screen, 0, sizeof(screen));
/*
* TRANSLATORS: FLAG MAINTENANCE is a screen title.
* Print something1 using something2. configuration is something1
*/
if(conf_scroll_screen(ps, &screen, first_line,
_("FLAG MAINTENANCE"),
_("configuration"), 0) == FLAG_ADD_RETURN) {
int flags, r;
char keyword[500];
char nickname[500];
char prompt[500];
char *error = NULL;
KEYWORD_S *kw;
HelpType help;
/*
* User is asking to add a new keyword. We will add it to the
* mailbox if necessary and add it to the keywords list from
* Setup/Config. Then we will modify the flag_table and present
* the flag modification screen again.
*/
ps->mangled_screen = 1;
keyword[0] = '\0';
flags = OE_APPEND_CURRENT;
help = NO_HELP;
do {
if(error) {
q_status_message(SM_ORDER, 3, 4, error);
fs_give((void **) &error);
}
strncpy(prompt, _("Keyword to be added : "), sizeof(prompt)-1);
prompt[sizeof(prompt)-1] = '\0';
r = optionally_enter(keyword, -FOOTER_ROWS(ps_global), 0,
sizeof(keyword), prompt, NULL, help, &flags);
if(r == 3)
help = help == NO_HELP ? h_type_keyword : NO_HELP;
else if(r == 1) {
cmd_cancelled("Add Keyword");
goto try_again;
}
removing_leading_and_trailing_white_space(keyword);
} while(r == 3 || keyword_check(keyword, &error));
for(kw = ps->keywords; kw; kw = kw->next) {
if(kw->kw && !strucmp(kw->kw, keyword)) {
q_status_message(SM_ORDER, 3, 4, _("Keyword already configured, changing nickname"));
break;
}
}
snprintf(prompt, sizeof(prompt), _("Optional nickname for \"%s\" : "), keyword);
nickname[0] = '\0';
help = NO_HELP;
do {
r = optionally_enter(nickname, -FOOTER_ROWS(ps_global), 0,
sizeof(nickname), prompt, NULL, help, &flags);
if(r == 3)
help = help == NO_HELP ? h_type_keyword_nickname : NO_HELP;
else if(r == 1) {
cmd_cancelled("Add Keyword");
goto try_again;
}
removing_leading_and_trailing_white_space(nickname);
} while(r == 3);
if(keyword[0]) {
char ***alval;
int offset = -1;
struct variable *var;
var = &ps_global->vars[V_KEYWORDS];
alval = ALVAL(var, Main);
for(kw = ps->keywords; kw; kw = kw->next) {
offset++;
if(kw->kw && !strucmp(kw->kw, keyword)) {
/* looks like it should already exist at offset */
break;
}
}
if(!kw)
offset = -1;
if(offset >= 0 && (*alval) && (*alval)[offset]) {
fs_give((void **) &(*alval)[offset]);
(*alval)[offset] = put_pair(nickname, keyword);
}
else if(!*alval) {
offset = 0;
*alval = (char **) fs_get(2*sizeof(char *));
(*alval)[offset] = put_pair(nickname, keyword);
(*alval)[offset+1] = NULL;
}
else {
for(offset=0; (*alval)[offset]; offset++);
;
fs_resize((void **) alval, (offset + 2) * sizeof(char *));
(*alval)[offset] = put_pair(nickname, keyword);
(*alval)[offset+1] = NULL;
}
set_current_val(var, TRUE, FALSE);
if(ps_global->prc)
ps_global->prc->outstanding_pinerc_changes = 1;
if(ps_global->keywords)
free_keyword_list(&ps_global->keywords);
if(var->current_val.l && var->current_val.l[0])
ps_global->keywords = init_keyword_list(var->current_val.l);
clear_index_cache(ps_global->mail_stream, 0);
rv = 1;
}
}
ps->mangled_screen = 1;
return(rv);
}