/** Return a string with all help entries that match a pattern */
static char *
list_matching_entries(char *pattern, help_file *help_dat, const char *sep)
{
static char buff[BUFFER_LEN];
int offset;
char *bp;
size_t n;
int len;
bp = buff;
if (help_dat->admin)
offset = 1; /* To skip the leading & */
else
offset = 0;
if (!wildcard(pattern)) {
/* Quick way out, use the other kind of matching */
char the_topic[LINE_SIZE + 2];
help_indx *entry = NULL;
strcpy(the_topic, normalize_entry(help_dat, pattern));
if (!help_dat->indx || help_dat->entries == 0)
return T("#-1 NO INDEX FOR FILE");
entry = help_find_entry(help_dat, the_topic);
if (!entry)
return (char *) "";
return (char *) (entry->topic + offset);
}
bp = buff;
if (sep)
len = strlen(sep);
for (n = 0; n < help_dat->entries; n++)
if (quick_wild(pattern, help_dat->indx[n].topic + offset)) {
safe_str(help_dat->indx[n].topic + offset, buff, &bp);
if (sep)
safe_strl(sep, len, buff, &bp);
}
if (bp > buff)
*(bp - len) = '\0';
else {
*bp = '\0';
}
return buff;
}
static bool
encode_base64(const char *input, int len, char *buff, char **bp)
{
BIO *bio, *b64, *bmem;
char *membuf;
b64 = BIO_new(BIO_f_base64());
if (!b64) {
safe_str(T("#-1 ALLOCATION ERROR"), buff, bp);
return false;
}
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
bmem = BIO_new(BIO_s_mem());
if (!bmem) {
safe_str(T("#-1 ALLOCATION ERROR"), buff, bp);
BIO_free(b64);
return false;
}
bio = BIO_push(b64, bmem);
if (BIO_write(bio, input, len) < 0) {
safe_str(T("#-1 CONVERSION ERROR"), buff, bp);
BIO_free_all(bio);
return false;
}
(void) BIO_flush(bio);
len = BIO_get_mem_data(bmem, &membuf);
safe_strl(membuf, len, buff, bp);
BIO_free_all(bio);
return true;
}
bool
decode_base64(char *encoded, int len, bool printonly, char *buff, char **bp)
{
BIO *bio, *b64, *bmem;
char *sbp;
b64 = BIO_new(BIO_f_base64());
if (!b64) {
safe_str(T("#-1 ALLOCATION ERROR"), buff, bp);
return false;
}
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
bmem = BIO_new_mem_buf(encoded, len);
if (!bmem) {
safe_str(T("#-1 ALLOCATION ERROR"), buff, bp);
BIO_free(b64);
return false;
}
/* len = BIO_set_close(bmem, BIO_NOCLOSE); This makes valgrind report a memory leak. */
bio = BIO_push(b64, bmem);
sbp = *bp;
while (true) {
char decoded[BUFFER_LEN];
int dlen;
dlen = BIO_read(bio, decoded, BUFFER_LEN);
if (dlen > 0) {
int n;
for (n = 0; n < dlen; n++) {
if (decoded[n] == TAG_START) {
int end;
n += 1;
for (end = n; end < dlen; end++) {
if (decoded[end] == TAG_END)
break;
}
if (end == dlen || decoded[n] != MARKUP_COLOR) {
BIO_free_all(bio);
*bp = sbp;
safe_str(T("#-1 CONVERSION ERROR"), buff, bp);
return false;
}
for (; n < end; n++) {
if (!valid_ansi_codes[decoded[n]]) {
BIO_free_all(bio);
*bp = sbp;
safe_str(T("#-1 CONVERSION ERROR"), buff, bp);
return false;
}
}
n = end;
} else if (printonly && !isprint(decoded[n]))
decoded[n] = '?';
}
safe_strl(decoded, dlen, buff, bp);
} else if (dlen == 0)
break;
else {
BIO_free_all(bio);
*bp = sbp;
safe_str(T("#-1 CONVERSION ERROR"), buff, bp);
return false;
}
}
BIO_free_all(bio);
return true;
}
