* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
-#ifndef lint
-static const char rcsid[] _U_ =
- "@(#) $Header: /tcpdump/master/tcpdump/util.c,v 1.103 2005-12-13 08:37:23 hannes Exp $ (LBL)";
-#endif
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
-#include <pcap.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
ret = 0;
break;
}
- if (!isascii(c)) {
- c = toascii(c);
+ if (!ND_ISASCII(c)) {
+ c = ND_TOASCII(c);
putchar('M');
putchar('-');
}
- if (!isprint(c)) {
+ if (!ND_ISPRINT(c)) {
c ^= 0x40; /* DEL to ?, others to alpha */
putchar('^');
}
while (n > 0 && (ep == NULL || s < ep)) {
n--;
c = *s++;
- if (!isascii(c)) {
- c = toascii(c);
+ if (!ND_ISASCII(c)) {
+ c = ND_TOASCII(c);
putchar('M');
putchar('-');
}
- if (!isprint(c)) {
+ if (!ND_ISPRINT(c)) {
c ^= 0x40; /* DEL to ?, others to alpha */
putchar('^');
}
ret = 0;
break;
}
- if (!isascii(c)) {
- c = toascii(c);
+ if (!ND_ISASCII(c)) {
+ c = ND_TOASCII(c);
putchar('M');
putchar('-');
}
- if (!isprint(c)) {
+ if (!ND_ISPRINT(c)) {
c ^= 0x40; /* DEL to ?, others to alpha */
putchar('^');
}
time_t Time;
static unsigned b_sec;
static unsigned b_usec;
+ int d_usec;
+ int d_sec;
switch (tflag) {
case 3: /* Microseconds since previous packet */
case 5: /* Microseconds since first packet */
- if (b_sec == 0 && tflag == 5) {
+ if (b_sec == 0) {
/* init timestamp for first packet */
b_usec = tvp->tv_usec;
- b_sec = tvp->tv_sec;
+ b_sec = tvp->tv_sec;
}
- int d_usec = tvp->tv_usec - b_usec;
- int d_sec = tvp->tv_sec - b_sec;
-
+ d_usec = tvp->tv_usec - b_usec;
+ d_sec = tvp->tv_sec - b_sec;
+
while (d_usec < 0) {
d_usec += 1000000;
d_sec--;
*/
int
-print_unknown_data(const u_char *cp,const char *ident,int len)
+print_unknown_data(netdissect_options *ndo, const u_char *cp,const char *ident,int len)
{
if (len < 0) {
- printf("%sDissector error: print_unknown_data called with negative length",
- ident);
+ ND_PRINT((ndo,"%sDissector error: print_unknown_data called with negative length",
+ ident));
return(0);
}
if (snapend - cp < len)
len = snapend - cp;
if (len < 0) {
- printf("%sDissector error: print_unknown_data called with pointer past end of packet",
- ident);
+ ND_PRINT((ndo,"%sDissector error: print_unknown_data called with pointer past end of packet",
+ ident));
return(0);
}
- hex_print(ident,cp,len);
+ hex_print(ndo, ident,cp,len);
return(1); /* everything is ok */
}
*/
const char *
tok2strbuf(register const struct tok *lp, register const char *fmt,
- register int v, char *buf, size_t bufsize)
+ register u_int v, char *buf, size_t bufsize)
{
if (lp != NULL) {
while (lp->s != NULL) {
/*
* Convert a bit token value to a string; use "fmt" if not found.
- * this is useful for parsing bitfields, the output strings are comma seperated
+ * this is useful for parsing bitfields, the output strings are seperated
+ * if the s field is positive.
*/
-char *
-bittok2str(register const struct tok *lp, register const char *fmt,
- register int v)
+static char *
+bittok2str_internal(register const struct tok *lp, register const char *fmt,
+ register int v, register int sep)
{
static char buf[256]; /* our stringbuffer */
int buflen=0;
register int rotbit; /* this is the bit we rotate through all bitpositions */
register int tokval;
- while (lp->s != NULL && lp != NULL) {
+ while (lp != NULL && lp->s != NULL) {
tokval=lp->v; /* load our first value */
rotbit=1;
while (rotbit != 0) {
*/
if (tokval == (v&rotbit)) {
/* ok we have found something */
- buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s, ",lp->s);
+ buflen+=snprintf(buf+buflen, sizeof(buf)-buflen, "%s%s",
+ lp->s, sep ? ", " : "");
break;
}
rotbit=rotbit<<1; /* no match - lets shift and try again */
lp++;
}
+ /* user didn't want string seperation - no need to cut off trailing seperators */
+ if (!sep) {
+ return (buf);
+ }
+
if (buflen != 0) { /* did we find anything */
/* yep, set the the trailing zero 2 bytes before to eliminate the last comma & whitespace */
buf[buflen-2] = '\0';
}
}
+/*
+ * Convert a bit token value to a string; use "fmt" if not found.
+ * this is useful for parsing bitfields, the output strings are not seperated.
+ */
+char *
+bittok2str_nosep(register const struct tok *lp, register const char *fmt,
+ register int v)
+{
+ return (bittok2str_internal(lp, fmt, v, 0));
+}
+
+/*
+ * Convert a bit token value to a string; use "fmt" if not found.
+ * this is useful for parsing bitfields, the output strings are comma seperated.
+ */
+char *
+bittok2str(register const struct tok *lp, register const char *fmt,
+ register int v)
+{
+ return (bittok2str_internal(lp, fmt, v, 1));
+}
+
/*
* Convert a value to a string using an array; the macro
* tok2strary() in <interface.h> is the public interface to
*/
int
-mask2plen (u_int32_t mask)
+mask2plen(u_int32_t mask)
{
u_int32_t bitmasks[33] = {
0x00000000,
return (prefix_len);
}
+#ifdef INET6
+int
+mask62plen(const u_char *mask)
+{
+ u_char bitmasks[9] = {
+ 0x00,
+ 0x80, 0xc0, 0xe0, 0xf0,
+ 0xf8, 0xfc, 0xfe, 0xff
+ };
+ int byte;
+ int cidr_len = 0;
+
+ for (byte = 0; byte < 16; byte++) {
+ u_int bits;
+
+ for (bits = 0; bits < (sizeof (bitmasks) / sizeof (bitmasks[0])); bits++) {
+ if (mask[byte] == bitmasks[bits]) {
+ cidr_len += bits;
+ break;
+ }
+ }
+
+ if (mask[byte] != 0xff)
+ break;
+ }
+ return (cidr_len);
+}
+#endif /* INET6 */
+
/* VARARGS */
void
error(const char *fmt, ...)
}
void
-safeputs(const char *s)
+safeputs(const char *s, int maxlen)
{
- while (*s) {
+ int idx = 0;
+
+ while (*s && idx < maxlen) {
safeputchar(*s);
+ idx++;
s++;
}
}
unsigned char ch;
ch = (unsigned char)(c & 0xff);
- if (ch < 0x80 && isprint(ch))
+ if (ch < 0x80 && ND_ISPRINT(ch))
printf("%c", ch);
else
- printf("\\%03o", ch);
+ printf("\\0x%02x", ch);
+}
+
+#ifdef LBL_ALIGN
+/*
+ * Some compilers try to optimize memcpy(), using the alignment constraint
+ * on the argument pointer type. by using this function, we try to avoid the
+ * optimization.
+ */
+void
+unaligned_memcpy(void *p, const void *q, size_t l)
+{
+ memcpy(p, q, l);
+}
+
+/* As with memcpy(), so with memcmp(). */
+int
+unaligned_memcmp(const void *p, const void *q, size_t l)
+{
+ return (memcmp(p, q, l));
}
+#endif
projects / tcpdump / blobdiff