Fix a signed-vs-unsigned comparison warning.

[tcpdump] / smbutil.c

diff --git a/smbutil.c b/smbutil.c
index 92ae88ec58b1dcf6b17e64c3418b7270d788a11a..d2a08f2bb29e0258bb0afdf02230e3bbe43bb3ea 100644 (file)
--- a/smbutil.c
+++ b/smbutil.c
@@ -11,35 +11,29 @@
 #endif
 
 #ifndef lint
 #endif
 
 #ifndef lint

-static const char rcsid[] =
-     "@(#) $Header: /tcpdump/master/tcpdump/smbutil.c,v 1.16 2001-06-25 21:04:01 itojun Exp $";
+static const char rcsid[] _U_ =
+     "@(#) $Header: /tcpdump/master/tcpdump/smbutil.c,v 1.28 2003-11-16 09:36:43 guy Exp $";

 #endif
 
 #endif
 

-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/socket.h>
+#include <tcpdump-stdinc.h>

 
 

-#include <netinet/in.h>
-
-#include <ctype.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

-#include <time.h>

 
 #include "interface.h"
 
 #include "interface.h"

+#include "extract.h"

 #include "smb.h"
 
 #include "smb.h"
 

-extern const uchar *startbuf;
+extern const u_char *startbuf;

 
 /*
  * interpret a 32 bit dos packed date/time to some parameters
  */
 static void
 
 /*
  * interpret a 32 bit dos packed date/time to some parameters
  */
 static void

-interpret_dos_date(uint32 date, struct tm *tp)
+interpret_dos_date(u_int32_t date, struct tm *tp)

 {
 {

-    uint32 p0, p1, p2, p3;
+    u_int32_t p0, p1, p2, p3;

 
     p0 = date & 0xFF;
     p1 = ((date & 0xFF00) >> 8) & 0xFF;
 
     p0 = date & 0xFF;
     p1 = ((date & 0xFF00) >> 8) & 0xFF;


@@ -55,16 +49,14 @@ interpret_dos_date(uint32 date, struct tm *tp)
 }
 
 /*
 }
 
 /*

+ * common portion:

  * create a unix date from a dos date
  */
 static time_t
  * create a unix date from a dos date
  */
 static time_t

-make_unix_date(const void *date_ptr)
+int_unix_date(u_int32_t dos_date)

 {
 {

-    uint32 dos_date = 0;

     struct tm t;
 
     struct tm t;
 

-    dos_date = IVAL(date_ptr, 0);
-

     if (dos_date == 0)
        return(0);
 
     if (dos_date == 0)
        return(0);
 


@@ -78,17 +70,30 @@ make_unix_date(const void *date_ptr)
 
 /*
  * create a unix date from a dos date
 
 /*
  * create a unix date from a dos date

+ * in network byte order

  */
 static time_t
  */
 static time_t

-make_unix_date2(const void *date_ptr)
+make_unix_date(const u_char *date_ptr)

 {
 {

-    uint32 x, x2;
+    u_int32_t dos_date = 0;

 
 

-    x = IVAL(date_ptr, 0);
-    x2 = ((x & 0xFFFF) << 16) | ((x & 0xFFFF0000) >> 16);
-    SIVAL(&x, 0, x2);
+    dos_date = EXTRACT_LE_32BITS(date_ptr);

 
 

-    return(make_unix_date((void *)&x));
+    return int_unix_date(dos_date);
+}
+
+/*
+ * create a unix date from a dos date
+ * in halfword-swapped network byte order!
+ */
+static time_t
+make_unix_date2(const u_char *date_ptr)
+{
+    u_int32_t x, x2;
+
+    x = EXTRACT_LE_32BITS(date_ptr);
+    x2 = ((x & 0xFFFF) << 16) | ((x & 0xFFFF0000) >> 16);
+    return int_unix_date(x2);

 }
 
 /*
 }
 
 /*


@@ -96,13 +101,15 @@ make_unix_date2(const void *date_ptr)
  * It's originally in "100ns units since jan 1st 1601"
  */
 static time_t
  * It's originally in "100ns units since jan 1st 1601"
  */
 static time_t

-interpret_long_date(const char *p)
+interpret_long_date(const u_char *p)

 {
     double d;
     time_t ret;
 
 {
     double d;
     time_t ret;
 

+    TCHECK2(p[4], 4);
+

     /* this gives us seconds since jan 1st 1601 (approx) */
     /* this gives us seconds since jan 1st 1601 (approx) */

-    d = (IVAL(p, 4) * 256.0 + CVAL(p, 3)) * (1.0e-7 * (1 << 24));
+    d = (EXTRACT_LE_32BITS(p + 4) * 256.0 + p[3]) * (1.0e-7 * (1 << 24));

 
     /* now adjust by 369 years to make the secs since 1970 */
     d -= 369.0 * 365.25 * 24 * 60 * 60;
 
     /* now adjust by 369 years to make the secs since 1970 */
     d -= 369.0 * 365.25 * 24 * 60 * 60;


@@ -116,6 +123,8 @@ interpret_long_date(const char *p)
     ret = (time_t)d;
 
     return(ret);
     ret = (time_t)d;
 
     return(ret);

+trunc:
+    return(0);

 }
 
 /*
 }
 
 /*


@@ -123,7 +132,7 @@ interpret_long_date(const char *p)
  * we run past the end of the buffer
  */
 static int
  * we run past the end of the buffer
  */
 static int

-name_interpret(const uchar *in, const uchar *maxbuf, char *out)
+name_interpret(const u_char *in, const u_char *maxbuf, char *out)

 {
     int ret;
     int len;
 {
     int ret;
     int len;


@@ -139,9 +148,9 @@ name_interpret(const uchar *in, const uchar *maxbuf, char *out)
        return(0);
 
     while (len--) {
        return(0);
 
     while (len--) {

+       TCHECK2(*in, 2);

        if (in + 1 >= maxbuf)
            return(-1); /* name goes past the end of the buffer */
        if (in + 1 >= maxbuf)
            return(-1); /* name goes past the end of the buffer */

-       TCHECK2(*in, 2);

        if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') {
            *out = 0;
            return(0);
        if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') {
            *out = 0;
            return(0);


@@ -162,11 +171,11 @@ trunc:
 /*
  * find a pointer to a netbios name
  */
 /*
  * find a pointer to a netbios name
  */

-static const uchar *
-name_ptr(const uchar *buf, int ofs, const uchar *maxbuf)
+static const u_char *
+name_ptr(const u_char *buf, int ofs, const u_char *maxbuf)

 {
 {

-    const uchar *p;
-    uchar c;
+    const u_char *p;
+    u_char c;

 
     p = buf + ofs;
     if (p >= maxbuf)
 
     p = buf + ofs;
     if (p >= maxbuf)


@@ -177,7 +186,7 @@ name_ptr(const uchar *buf, int ofs, const uchar *maxbuf)
 
     /* XXX - this should use the same code that the DNS dissector does */
     if ((c & 0xC0) == 0xC0) {
 
     /* XXX - this should use the same code that the DNS dissector does */
     if ((c & 0xC0) == 0xC0) {

-       uint16 l = RSVAL(buf, ofs) & 0x3FFF;
+       u_int16_t l = EXTRACT_16BITS(buf + ofs) & 0x3FFF;

        if (l == 0) {
            /* We have a pointer that points to itself. */
            return(NULL);
        if (l == 0) {
            /* We have a pointer that points to itself. */
            return(NULL);


@@ -198,9 +207,9 @@ trunc:
  * extract a netbios name from a buf
  */
 static int
  * extract a netbios name from a buf
  */
 static int

-name_extract(const uchar *buf, int ofs, const uchar *maxbuf, char *name)
+name_extract(const u_char *buf, int ofs, const u_char *maxbuf, char *name)

 {
 {

-    const uchar *p = name_ptr(buf, ofs, maxbuf);
+    const u_char *p = name_ptr(buf, ofs, maxbuf);

     if (p == NULL)
        return(-1);     /* error (probably name going past end of buffer) */
     name[0] = '\0';
     if (p == NULL)
        return(-1);     /* error (probably name going past end of buffer) */
     name[0] = '\0';


@@ -243,10 +252,10 @@ print_asc(const unsigned char *buf, int len)
        safeputchar(buf[i]);
 }
 
        safeputchar(buf[i]);
 }
 

-static char *
+static const char *

 name_type_str(int name_type)
 {
 name_type_str(int name_type)
 {

-    char *f = NULL;
+    const char *f = NULL;

 
     switch (name_type) {
     case 0:    f = "Workstation"; break;
 
     switch (name_type) {
     case 0:    f = "Workstation"; break;


@@ -292,7 +301,7 @@ print_data(const unsigned char *buf, int len)
        while (n--)
            printf("   ");
 
        while (n--)
            printf("   ");
 

-       n = MIN(8, i % 16);
+       n = SMBMIN(8, i % 16);

        print_asc(&buf[i - (i % 16)], n);
        printf(" ");
        n = (i % 16) - n;
        print_asc(&buf[i - (i % 16)], n);
        printf(" ");
        n = (i % 16) - n;


@@ -304,9 +313,9 @@ print_data(const unsigned char *buf, int len)
 
 
 static void
 
 
 static void

-write_bits(unsigned int val, char *fmt)
+write_bits(unsigned int val, const char *fmt)

 {
 {

-    char *p = fmt;
+    const char *p = fmt;

     int i = 0;
 
     while ((p = strchr(fmt, '|'))) {
     int i = 0;
 
     while ((p = strchr(fmt, '|'))) {


@@ -320,7 +329,7 @@ write_bits(unsigned int val, char *fmt)
 
 /* convert a UCS2 string into iso-8859-1 string */
 static const char *
 
 /* convert a UCS2 string into iso-8859-1 string */
 static const char *

-unistr(const char *s, int *len)
+unistr(const u_char *s, int *len)

 {
     static char buf[1000];
     int l=0;
 {
     static char buf[1000];
     int l=0;


@@ -336,8 +345,8 @@ unistr(const char *s, int *len)
 
     /* maybe it isn't unicode - a cheap trick */
     if (!use_unicode || (s[0] && s[1])) {
 
     /* maybe it isn't unicode - a cheap trick */
     if (!use_unicode || (s[0] && s[1])) {

-       *len = strlen(s) + 1;
-       return s;
+       *len = strlen((const char *)s) + 1;
+       return (const char *)s;

     }
 
     *len = 0;
     }
 
     *len = 0;


@@ -347,7 +356,7 @@ unistr(const char *s, int *len)
        *len = 1;
     }
 
        *len = 1;
     }
 

-    while (l < (sizeof(buf) - 1) && s[0] && s[1] == 0) {
+    while (l < (int)(sizeof(buf) - 1) && s[0] && s[1] == 0) {

        buf[l] = s[0];
        s += 2;
        l++;
        buf[l] = s[0];
        s += 2;
        l++;


@@ -358,23 +367,23 @@ unistr(const char *s, int *len)
     return buf;
 }
 
     return buf;
 }
 

-static const uchar *
-fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
+static const u_char *
+smb_fdata1(const u_char *buf, const char *fmt, const u_char *maxbuf)

 {
     int reverse = 0;
 {
     int reverse = 0;

-    char *attrib_fmt = "READONLY|HIDDEN|SYSTEM|VOLUME|DIR|ARCHIVE|";
+    const char *attrib_fmt = "READONLY|HIDDEN|SYSTEM|VOLUME|DIR|ARCHIVE|";

     int len;
 
     while (*fmt && buf<maxbuf) {
        switch (*fmt) {
        case 'a':
     int len;
 
     while (*fmt && buf<maxbuf) {
        switch (*fmt) {
        case 'a':

-           write_bits(CVAL(buf,0), attrib_fmt);
+           write_bits(buf[0], attrib_fmt);

            buf++;
            fmt++;
            break;
 
        case 'A':
            buf++;
            fmt++;
            break;
 
        case 'A':

-           write_bits(SVAL(buf, 0), attrib_fmt);
+           write_bits(EXTRACT_LE_16BITS(buf), attrib_fmt);

            buf += 2;
            fmt++;
            break;
            buf += 2;
            fmt++;
            break;


@@ -382,12 +391,19 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
        case '{':
          {
            char bitfmt[128];
        case '{':
          {
            char bitfmt[128];

-           char *p = strchr(++fmt, '}');
-           int l = PTR_DIFF(p, fmt);
+           char *p;
+           int l;
+
+           p = strchr(++fmt, '}');
+           l = PTR_DIFF(p, fmt);
+
+           if ((unsigned int)l > sizeof(bitfmt) - 1)
+                   l = sizeof(bitfmt)-1;
+

            strncpy(bitfmt, fmt, l);
            strncpy(bitfmt, fmt, l);

-           bitfmt[l] = 0;
+           bitfmt[l] = '\0';

            fmt = p + 1;
            fmt = p + 1;

-           write_bits(CVAL(buf, 0), bitfmt);
+           write_bits(buf[0], bitfmt);

            buf++;
            break;
          }
            buf++;
            break;
          }


@@ -397,7 +413,7 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
            int l = atoi(fmt + 1);
            buf += l;
            fmt++;
            int l = atoi(fmt + 1);
            buf += l;
            fmt++;

-           while (isdigit(*fmt))
+           while (isdigit((unsigned char)*fmt))

                fmt++;
            break;
          }
                fmt++;
            break;
          }


@@ -407,7 +423,10 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
            break;
        case 'D':
          {
            break;
        case 'D':
          {

-           unsigned int x = reverse ? RIVAL(buf, 0) : IVAL(buf, 0);
+           unsigned int x;
+
+           TCHECK2(buf[0], 4);
+           x = reverse ? EXTRACT_32BITS(buf) : EXTRACT_LE_32BITS(buf);

            printf("%d (0x%x)", x, x);
            buf += 4;
            fmt++;
            printf("%d (0x%x)", x, x);
            buf += 4;
            fmt++;


@@ -415,8 +434,13 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'L':
          {
          }
        case 'L':
          {

-           unsigned int x1 = reverse ? RIVAL(buf, 0) : IVAL(buf, 0);
-           unsigned int x2 = reverse ? RIVAL(buf, 4) : IVAL(buf, 4);
+           unsigned int x1, x2;
+
+           TCHECK2(buf[4], 4);
+           x1 = reverse ? EXTRACT_32BITS(buf) :
+                          EXTRACT_LE_32BITS(buf);
+           x2 = reverse ? EXTRACT_32BITS(buf + 4) :
+                          EXTRACT_LE_32BITS(buf + 4);

            if (x2)
                printf("0x%08x:%08x", x2, x1);
            else
            if (x2)
                printf("0x%08x:%08x", x2, x1);
            else


@@ -427,7 +451,10 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'd':
          {
          }
        case 'd':
          {

-           unsigned int x = reverse ? RSVAL(buf, 0) : SVAL(buf, 0);
+           unsigned int x;
+           TCHECK2(buf[0], 2);
+           x = reverse ? EXTRACT_16BITS(buf) :
+                         EXTRACT_LE_16BITS(buf);

            printf("%d (0x%x)", x, x);
            buf += 2;
            fmt++;
            printf("%d (0x%x)", x, x);
            buf += 2;
            fmt++;


@@ -435,7 +462,10 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'W':
          {
          }
        case 'W':
          {

-           unsigned int x = reverse ? RIVAL(buf, 0) : IVAL(buf, 0);
+           unsigned int x;
+           TCHECK2(buf[0], 4);
+           x = reverse ? EXTRACT_32BITS(buf) :
+                         EXTRACT_LE_32BITS(buf);

            printf("0x%X", x);
            buf += 4;
            fmt++;
            printf("0x%X", x);
            buf += 4;
            fmt++;


@@ -443,7 +473,10 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'w':
          {
          }
        case 'w':
          {

-           unsigned int x = reverse ? RSVAL(buf, 0) : SVAL(buf, 0);
+           unsigned int x;
+           TCHECK2(buf[0], 2);
+           x = reverse ? EXTRACT_16BITS(buf) :
+                         EXTRACT_LE_16BITS(buf);

            printf("0x%X", x);
            buf += 2;
            fmt++;
            printf("0x%X", x);
            buf += 2;
            fmt++;


@@ -451,7 +484,9 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'B':
          {
          }
        case 'B':
          {

-           unsigned int x = CVAL(buf,0);
+           unsigned int x;
+           TCHECK(buf[0]);
+           x = buf[0];

            printf("0x%X", x);
            buf += 1;
            fmt++;
            printf("0x%X", x);
            buf += 1;
            fmt++;


@@ -459,7 +494,9 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'b':
          {
          }
        case 'b':
          {

-           unsigned int x = CVAL(buf, 0);
+           unsigned int x;
+           TCHECK(buf[0]);
+           x = buf[0];

            printf("%u (0x%x)", x, x);
            buf += 1;
            fmt++;
            printf("%u (0x%x)", x, x);
            buf += 1;
            fmt++;


@@ -467,6 +504,7 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
          }
        case 'S':
          {
          }
        case 'S':
          {

+           /*XXX unistr() */

            printf("%.*s", (int)PTR_DIFF(maxbuf, buf), unistr(buf, &len));
            buf += len;
            fmt++;
            printf("%.*s", (int)PTR_DIFF(maxbuf, buf), unistr(buf, &len));
            buf += len;
            fmt++;


@@ -489,7 +527,7 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
            printf("%-*.*s", l, l, buf);
            buf += l;
            fmt++;
            printf("%-*.*s", l, l, buf);
            buf += l;
            fmt++;

-           while (isdigit(*fmt))
+           while (isdigit((unsigned char)*fmt))

                fmt++;
            break;
          }
                fmt++;
            break;
          }


@@ -499,7 +537,7 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
            while (l--)
                printf("%02x", *buf++);
            fmt++;
            while (l--)
                printf("%02x", *buf++);
            fmt++;

-           while (isdigit(*fmt))
+           while (isdigit((unsigned char)*fmt))

                fmt++;
            break;
          }
                fmt++;
            break;
          }


@@ -531,25 +569,28 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
                break;
            }
            fmt++;
                break;
            }
            fmt++;

-           while (isdigit(*fmt))
+           while (isdigit((unsigned char)*fmt))

                fmt++;
            break;
          }
        case 'T':
          {
            time_t t;
                fmt++;
            break;
          }
        case 'T':
          {
            time_t t;

-           int x = IVAL(buf,0);
+           struct tm *lt;
+           const char *tstring;
+           u_int32_t x;
+           x = EXTRACT_LE_32BITS(buf);

 
            switch (atoi(fmt + 1)) {
            case 1:
 
            switch (atoi(fmt + 1)) {
            case 1:

-               if (x == 0 || x == -1 || x == 0xFFFFFFFF)
+               if (x == 0 || x == 0xFFFFFFFF)

                    t = 0;
                else
                    t = make_unix_date(buf);
                buf += 4;
                break;
            case 2:
                    t = 0;
                else
                    t = make_unix_date(buf);
                buf += 4;
                break;
            case 2:

-               if (x == 0 || x == -1 || x == 0xFFFFFFFF)
+               if (x == 0 || x == 0xFFFFFFFF)

                    t = 0;
                else
                    t = make_unix_date2(buf);
                    t = 0;
                else
                    t = make_unix_date2(buf);


@@ -560,9 +601,17 @@ fdata1(const uchar *buf, const char *fmt, const uchar *maxbuf)
                buf += 8;
                break;
            }
                buf += 8;
                break;
            }

-           printf("%s", t ? asctime(localtime(&t)) : "NULL\n");
+           if (t != 0) {
+               lt = localtime(&t);
+               if (lt != NULL)
+                   tstring = asctime(lt);
+               else
+                   tstring = "(Can't convert time)\n";
+           } else
+               tstring = "NULL\n";
+           printf("%s", tstring);

            fmt++;
            fmt++;

-           while (isdigit(*fmt))
+           while (isdigit((unsigned char)*fmt))

                fmt++;
            break;
          }
                fmt++;
            break;
          }


@@ -584,8 +633,8 @@ trunc:
     return(NULL);
 }
 
     return(NULL);
 }
 

-const uchar *
-fdata(const uchar *buf, const char *fmt, const uchar *maxbuf)
+const u_char *
+smb_fdata(const u_char *buf, const char *fmt, const u_char *maxbuf)

 {
     static int depth = 0;
     char s[128];
 {
     static int depth = 0;
     char s[128];


@@ -596,15 +645,17 @@ fdata(const uchar *buf, const char *fmt, const uchar *maxbuf)
        case '*':
            fmt++;
            while (buf < maxbuf) {
        case '*':
            fmt++;
            while (buf < maxbuf) {

-               const uchar *buf2;
+               const u_char *buf2;

                depth++;
                depth++;

-               buf2 = fdata(buf, fmt, maxbuf);
+               buf2 = smb_fdata(buf, fmt, maxbuf);

                depth--;
                depth--;

+               if (buf2 == NULL)
+                   return(NULL);

                if (buf2 == buf)
                    return(buf);
                buf = buf2;
            }
                if (buf2 == buf)
                    return(buf);
                buf = buf2;
            }

-           break;
+           return(buf);

 
        case '|':
            fmt++;
 
        case '|':
            fmt++;


@@ -628,14 +679,14 @@ fdata(const uchar *buf, const char *fmt, const uchar *maxbuf)
                return(buf);
            memset(s, 0, sizeof(s));
            p = strchr(fmt, ']');
                return(buf);
            memset(s, 0, sizeof(s));
            p = strchr(fmt, ']');

-           if (p - fmt + 1 > sizeof(s)) {
+           if ((size_t)(p - fmt + 1) > sizeof(s)) {

                /* overrun */
                return(buf);
            }
            strncpy(s, fmt, p - fmt);
            s[p - fmt] = '\0';
            fmt = p + 1;
                /* overrun */
                return(buf);
            }
            strncpy(s, fmt, p - fmt);
            s[p - fmt] = '\0';
            fmt = p + 1;

-           buf = fdata1(buf, s, maxbuf);
+           buf = smb_fdata1(buf, s, maxbuf);

            if (buf == NULL)
                return(NULL);
            break;
            if (buf == NULL)
                return(NULL);
            break;


@@ -657,9 +708,9 @@ fdata(const uchar *buf, const char *fmt, const uchar *maxbuf)
 }
 
 typedef struct {
 }
 
 typedef struct {

-    char *name;
+    const char *name;

     int code;
     int code;

-    char *message;
+    const char *message;

 } err_code_struct;
 
 /* Dos Error Messages */
 } err_code_struct;
 
 /* Dos Error Messages */


@@ -755,7 +806,7 @@ err_code_struct hard_msgs[] = {
 
 static struct {
     int code;
 
 static struct {
     int code;

-    char *class;
+    const char *class;

     err_code_struct *err_msgs;
 } err_classes[] = {
     { 0, "SUCCESS", NULL },
     err_code_struct *err_msgs;
 } err_classes[] = {
     { 0, "SUCCESS", NULL },