int
tgetnum (const char *cap)
{
register char *ptr = find_capability (term_entry, cap);
if (!ptr || ptr[-1] != '#')
return -1;
return atoi (ptr);
}
char *
tgetstr (const char *cap, char **area)
{
register char *ptr = find_capability (term_entry, cap);
if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~'))
return NULL;
return tgetst1 (ptr, area);
}
/*! \brief CAPAB command handler
*
* \param source_p Pointer to allocated Client struct from which the message
* originally comes from. This can be a local or remote client.
* \param parc Integer holding the number of supplied arguments.
* \param parv Argument vector where parv[0] .. parv[parc-1] are non-NULL
* pointers.
* \note Valid arguments for this command are:
* - parv[0] = command
* - parv[1] = space-separated list of capabilities
*/
static int
mr_capab(struct Client *source_p, int parc, char *parv[])
{
unsigned int cap = 0;
char *p = NULL;
char *s = NULL;
for (s = strtok_r(parv[1], " ", &p); s;
s = strtok_r(NULL, " ", &p))
if ((cap = find_capability(s)))
SetCapable(source_p, cap);
return 0;
}
/*
* mr_capab - CAPAB message handler
* parv[0] = sender prefix
* parv[1] = space-separated list of capabilities
*
*/
static void
mr_capab(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
int i;
int cap;
char *p;
char *s;
#ifdef HAVE_LIBCRYPTO
struct EncCapability *ecap;
unsigned int cipher = 0;
#endif
/* ummm, this shouldn't happen. Could argue this should be logged etc. */
if (client_p->localClient == NULL)
return;
if (client_p->localClient->caps && !(IsCapable(client_p, CAP_TS6)))
{
exit_client(client_p, client_p, "CAPAB received twice");
return;
}
else
SetCapable(client_p, CAP_CAP);
for (i = 1; i < parc; i++)
{
for (s = strtoken(&p, parv[i], " "); s; s = strtoken(&p, NULL, " "))
{
#ifdef HAVE_LIBCRYPTO
if ((strncmp(s, "ENC:", 4) == 0))
{
/* Skip the "ENC:" portion */
s += 4;
/* Check the remaining portion against the list of ciphers we
* have available (CipherTable).
*/
for (ecap = CipherTable; ecap->name; ecap++)
{
if ((irccmp(ecap->name, s) == 0) && (ecap->cap & CAP_ENC_MASK))
{
cipher = ecap->cap;
break;
}
}
/* Since the name and capabilities matched, use it. */
if (cipher != 0)
{
SetCapable(client_p, CAP_ENC);
client_p->localClient->enc_caps |= cipher;
}
else
{
/* cipher is still zero; we didn't find a matching entry. */
exit_client(client_p, client_p,
"Cipher selected is not available here.");
return;
}
}
else /* normal capab */
#endif
if ((cap = find_capability(s)) != 0)
SetCapable(client_p, cap);
}
}
}
int
tgetflag (const char *cap)
{
register char *ptr = find_capability (term_entry, cap);
return ptr && ptr[-1] == ':';
}
int
tgetent (char *bp, const char *name)
{
register char *termcap_name;
register int fd;
struct termcap_buffer buf;
register char *bp1;
char *tc_search_point;
char *term;
ptrdiff_t malloc_size = 0;
register int c;
char *tcenv = NULL; /* TERMCAP value, if it contains :tc=. */
char *indirect = NULL; /* Terminal type in :tc= in TERMCAP value. */
int filep;
#ifdef INTERNAL_TERMINAL
/* For the internal terminal we don't want to read any termcap file,
so fake it. */
if (!strcmp (name, "internal"))
{
term = INTERNAL_TERMINAL;
if (!bp)
{
malloc_size = 1 + strlen (term);
bp = (char *) xmalloc (malloc_size);
}
strcpy (bp, term);
goto ret;
}
#endif /* INTERNAL_TERMINAL */
/* For compatibility with programs like `less' that want to
put data in the termcap buffer themselves as a fallback. */
if (bp)
term_entry = bp;
termcap_name = getenv ("TERMCAP");
if (termcap_name && *termcap_name == '\0')
termcap_name = NULL;
#if defined (MSDOS) && !defined (TEST)
if (termcap_name && (*termcap_name == '\\'
|| *termcap_name == '/'
|| termcap_name[1] == ':'))
dostounix_filename(termcap_name);
#endif
filep = termcap_name && valid_filename_p (termcap_name);
/* If termcap_name is non-null and starts with / (in the un*x case, that is),
it is a file name to use instead of /etc/termcap.
If it is non-null and does not start with /,
it is the entry itself, but only if
the name the caller requested matches the TERM variable. */
if (termcap_name && !filep && !strcmp (name, getenv ("TERM")))
{
indirect = tgetst1 (find_capability (termcap_name, "tc"), (char **) 0);
if (!indirect)
{
if (!bp)
bp = termcap_name;
else
strcpy (bp, termcap_name);
goto ret;
}
else
{ /* It has tc=. Need to read /etc/termcap. */
tcenv = termcap_name;
termcap_name = NULL;
}
}
if (!termcap_name || !filep)
termcap_name = TERMCAP_FILE;
/* Here we know we must search a file and termcap_name has its name. */
#ifdef MSDOS
fd = open (termcap_name, O_RDONLY|O_TEXT, 0);
#else
fd = open (termcap_name, O_RDONLY, 0);
#endif
if (fd < 0)
return -1;
buf.size = BUFSIZE;
/* Add 1 to size to ensure room for terminating null. */
buf.beg = (char *) xmalloc (buf.size + 1);
term = indirect ? indirect : (char *)name;
if (!bp)
{
malloc_size = indirect ? strlen (tcenv) + 1 : buf.size;
bp = (char *) xmalloc (malloc_size);
}
tc_search_point = bp1 = bp;
if (indirect)
/* Copy the data from the environment variable. */
{
strcpy (bp, tcenv);
bp1 += strlen (tcenv);
}
while (term)
{
/* Scan the file, reading it via buf, till find start of main entry. */
if (scan_file (term, fd, &buf) == 0)
{
close (fd);
xfree (buf.beg);
if (malloc_size)
xfree (bp);
return 0;
}
/* Free old `term' if appropriate. */
if (term != name)
xfree (term);
/* If BP is malloc'd by us, make sure it is big enough. */
if (malloc_size)
{
ptrdiff_t offset1 = bp1 - bp, offset2 = tc_search_point - bp;
malloc_size = offset1 + buf.size;
bp = termcap_name = (char *) xrealloc (bp, malloc_size);
bp1 = termcap_name + offset1;
tc_search_point = termcap_name + offset2;
}
/* Copy the line of the entry from buf into bp. */
termcap_name = buf.ptr;
while ((*bp1++ = c = *termcap_name++) && c != '\n')
/* Drop out any \ newline sequence. */
if (c == '\\' && *termcap_name == '\n')
{
bp1--;
termcap_name++;
}
*bp1 = '\0';
/* Does this entry refer to another terminal type's entry?
If something is found, copy it into heap and null-terminate it. */
tc_search_point = find_capability (tc_search_point, "tc");
term = tgetst1 (tc_search_point, (char **) 0);
}
close (fd);
xfree (buf.beg);
if (malloc_size)
bp = (char *) xrealloc (bp, bp1 - bp + 1);
ret:
term_entry = bp;
return 1;
}
Lisp_Object_Int
tgetent (char *bp, char *name)
{
register char *tem;
register int fd;
struct buffer buf;
register char *bp1;
char *bp2;
char *term;
int malloc_size = 0;
register int c;
char *tcenv; /* TERMCAP value, if it contais :tc=. */
char *indirect = 0; /* Terminal type in :tc= in TERMCAP value. */
int filep;
tem = (char *) getenv ("TERMCAP");
if (tem && *tem == 0) tem = 0;
#ifdef VMS
filep = tem && legal_filename_p (tem);
#else
filep = tem && (*tem == '/');
#endif /* VMS */
/* If tem is non-null and starts with / (in the un*x case, that is),
it is a file name to use instead of /etc/termcap.
If it is non-null and does not start with /,
it is the entry itself, but only if
the name the caller requested matches the TERM variable. */
if (tem && !filep && !strcmp (name, getenv ("TERM")))
{
indirect = tgetst1 (find_capability (tem, "tc"), 0);
if (!indirect)
{
if (!bp)
bp = tem;
else
strcpy (bp, tem);
goto ret;
}
else
{ /* we will need to read /etc/termcap */
tcenv = tem;
tem = 0;
}
}
else
indirect = (char *) 0;
if (!tem)
#ifdef VMS
tem = "emacs_library:[etc]termcap.dat";
#else
tem = "/etc/termcap";
#endif
/* Here we know we must search a file and tem has its name. */
fd = open (tem, 0, 0);
if (fd < 0)
return -1;
buf.size = BUFSIZE;
/* Add 1 to size to ensure room for terminating null. */
buf.beg = (char *) xmalloc (buf.size + 1);
term = indirect ? indirect : name;
if (!bp)
{
malloc_size = indirect ? strlen (tcenv) + 1 : buf.size;
bp = (char *) xmalloc (malloc_size);
}
bp1 = bp;
if (indirect) /* copy the data from the environment variable */
{
strcpy (bp, tcenv);
bp1 += strlen (tcenv);
}
while (term)
{
/* Scan file, reading it via buf, till find start of main entry */
if (scan_file (term, fd, &buf) == 0)
return 0;
/* Free old `term' if appropriate. */
if (term != name)
free (term);
/* If `bp' is malloc'd by us, make sure it is big enough. */
if (malloc_size)
{
malloc_size = bp1 - bp + buf.size;
tem = (char *) xrealloc (bp, malloc_size);
bp1 += tem - bp;
bp = tem;
}
bp2 = bp1;
/* Copy the line of the entry from buf into bp. */
tem = buf.ptr;
while ((*bp1++ = c = *tem++) && c != '\n')
/* Drop out any \ newline sequence. */
if (c == '\\' && *tem == '\n')
{
bp1--;
tem++;
}
*bp1 = 0;
/* Does this entry refer to another terminal type's entry? */
/* If something is found, copy it into heap and null-terminate it */
term = tgetst1 (find_capability (bp2, "tc"), 0);
}
close (fd);
free (buf.beg);
if (malloc_size)
{
bp = (char *) xrealloc (bp, bp1 - bp + 1);
}
ret:
term_entry = bp;
if (malloc_size)
return (Lisp_Object_Int) bp;
return 1;
}
