In the open request, reject capture sources that are URLs.

[libpcap] / fmtutils.c

diff --git a/fmtutils.c b/fmtutils.c
index d01dc3e2637b1b36c0ecece6e04ed194753d6a74..d89a3976159da50b7786721ac3c7981a55c01ea4 100644 (file)
--- a/fmtutils.c
+++ b/fmtutils.c
@@ -67,7 +67,7 @@ pcap_fmt_errmsg_for_errno(char *errbuf, size_t errbuflen, int errnum,
        size_t errbuflen_remaining;
 
        va_start(ap, fmt);
        size_t errbuflen_remaining;
 
        va_start(ap, fmt);

-       pcap_vsnprintf(errbuf, errbuflen, fmt, ap);
+       vsnprintf(errbuf, errbuflen, fmt, ap);

        va_end(ap);
        msglen = strlen(errbuf);
 
        va_end(ap);
        msglen = strlen(errbuf);
 


@@ -100,7 +100,7 @@ pcap_fmt_errmsg_for_errno(char *errbuf, size_t errbuflen, int errnum,
                 * It doesn't appear to be documented anywhere obvious
                 * what the error returns from strerror_s().
                 */
                 * It doesn't appear to be documented anywhere obvious
                 * what the error returns from strerror_s().
                 */

-               pcap_snprintf(p, errbuflen_remaining, "Error %d", errnum);
+               snprintf(p, errbuflen_remaining, "Error %d", errnum);

        }
 #elif defined(HAVE_GNU_STRERROR_R)
        /*
        }
 #elif defined(HAVE_GNU_STRERROR_R)
        /*


@@ -113,7 +113,7 @@ pcap_fmt_errmsg_for_errno(char *errbuf, size_t errbuflen, int errnum,
         */
        char strerror_buf[PCAP_ERRBUF_SIZE];
        char *errstring = strerror_r(errnum, strerror_buf, PCAP_ERRBUF_SIZE);
         */
        char strerror_buf[PCAP_ERRBUF_SIZE];
        char *errstring = strerror_r(errnum, strerror_buf, PCAP_ERRBUF_SIZE);

-       pcap_snprintf(p, errbuflen_remaining, "%s", errstring);
+       snprintf(p, errbuflen_remaining, "%s", errstring);

 #elif defined(HAVE_POSIX_STRERROR_R)
        /*
         * We have a POSIX-style strerror_r(), which is guaranteed to fill
 #elif defined(HAVE_POSIX_STRERROR_R)
        /*
         * We have a POSIX-style strerror_r(), which is guaranteed to fill


@@ -125,14 +125,14 @@ pcap_fmt_errmsg_for_errno(char *errbuf, size_t errbuflen, int errnum,
                 * UNIX 03 says this isn't guaranteed to produce a
                 * fallback error message.
                 */
                 * UNIX 03 says this isn't guaranteed to produce a
                 * fallback error message.
                 */

-               pcap_snprintf(p, errbuflen_remaining, "Unknown error: %d",
+               snprintf(p, errbuflen_remaining, "Unknown error: %d",

                    errnum);
        } else if (err == ERANGE) {
                /*
                 * UNIX 03 says this isn't guaranteed to produce a
                 * fallback error message.
                 */
                    errnum);
        } else if (err == ERANGE) {
                /*
                 * UNIX 03 says this isn't guaranteed to produce a
                 * fallback error message.
                 */

-               pcap_snprintf(p, errbuflen_remaining,
+               snprintf(p, errbuflen_remaining,

                    "Message for error %d is too long", errnum);
        }
 #else
                    "Message for error %d is too long", errnum);
        }
 #else


@@ -140,24 +140,50 @@ pcap_fmt_errmsg_for_errno(char *errbuf, size_t errbuflen, int errnum,
         * We have neither strerror_s() nor strerror_r(), so we're
         * stuck with using pcap_strerror().
         */
         * We have neither strerror_s() nor strerror_r(), so we're
         * stuck with using pcap_strerror().
         */

-       pcap_snprintf(p, errbuflen_remaining, "%s", pcap_strerror(errnum));
+       snprintf(p, errbuflen_remaining, "%s", pcap_strerror(errnum));

 #endif
 }
 
 #ifdef _WIN32
 /*
 #endif
 }
 
 #ifdef _WIN32
 /*

- * Generate a string for a Win32-specific error (i.e. an error generated when
- * calling a Win32 API).
- * For errors occurred during standard C calls, we still use pcap_strerror().
+ * Generate an error message based on a format, arguments, and a
+ * Win32 error, with a message for the Win32 error after the formatted output.

  */
 void
  */
 void

-pcap_win32_err_to_str(DWORD error, char *errbuf)
+pcap_fmt_errmsg_for_win32_err(char *errbuf, size_t errbuflen, DWORD errnum,
+    const char *fmt, ...)

 {
 {

-       DWORD retval;
-       size_t errlen;
+       va_list ap;
+       size_t msglen;

        char *p;
        char *p;

+       size_t errbuflen_remaining;
+       DWORD retval;
+       char win32_errbuf[PCAP_ERRBUF_SIZE+1];
+
+       va_start(ap, fmt);
+       vsnprintf(errbuf, errbuflen, fmt, ap);
+       va_end(ap);
+       msglen = strlen(errbuf);
+
+       /*
+        * Do we have enough space to append ": "?
+        * Including the terminating '\0', that's 3 bytes.
+        */
+       if (msglen + 3 > errbuflen) {
+               /* No - just give them what we've produced. */
+               return;
+       }
+       p = errbuf + msglen;
+       errbuflen_remaining = errbuflen - msglen;
+       *p++ = ':';
+       *p++ = ' ';
+       *p = '\0';
+       msglen += 2;
+       errbuflen_remaining -= 2;

 
        /*
 
        /*

+        * Now append the string for the error code.
+        *

         * XXX - what language ID to use?
         *
         * For UN*Xes, pcap_strerror() may or may not return localized
         * XXX - what language ID to use?
         *
         * For UN*Xes, pcap_strerror() may or may not return localized


@@ -172,30 +198,17 @@ pcap_win32_err_to_str(DWORD error, char *errbuf)
         * happen to understand.
         */
        retval = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_MAX_WIDTH_MASK,
         * happen to understand.
         */
        retval = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_MAX_WIDTH_MASK,

-           NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-           errbuf, PCAP_ERRBUF_SIZE, NULL);
+           NULL, errnum, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+           win32_errbuf, PCAP_ERRBUF_SIZE, NULL);

        if (retval == 0) {
                /*
                 * Failed.
                 */
        if (retval == 0) {
                /*
                 * Failed.
                 */

-               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
-                   "Couldn't get error message for error (%lu)", error);
+               snprintf(p, errbuflen_remaining,
+                   "Couldn't get error message for error (%lu)", errnum);

                return;
        }
 
                return;
        }
 

-       /*
-        * "FormatMessage()" "helpfully" sticks CR/LF at the end of the
-        * message.  Get rid of it.
-        *
-        * XXX - still true with FORMAT_MESSAGE_MAX_WIDTH_MASK?
-        */
-       errlen = strlen(errbuf);
-       if (errlen >= 2 &&
-           errbuf[errlen - 2] == '\r' && errbuf[errlen - 1] == '\n') {
-               errbuf[errlen - 2] = '\0';
-               errbuf[errlen - 1] = '\0';
-       }
-       p = strchr(errbuf, '\0');
-       pcap_snprintf(p, PCAP_ERRBUF_SIZE+1-(p-errbuf), " (%lu)", error);
+       snprintf(p, errbuflen_remaining, "%s (%lu)", win32_errbuf, errnum);

 }
 #endif
 }
 #endif