Use pcap_snprintf() instead of snprintf().

On UN*Xes with snprintf(), we just #define pcap_snprintf to snprintf.

On UN*Xes without snprintf(), we provide our own, but call it
pcap_snprintf().

On Windows, we have a routine that wraps _snprintf(), with C99 semantics
(ensuring null termination if the string won't fit), called
pcap_snprintf(), and use that.

diff --git a/bpf_image.c b/bpf_image.c
index a7beb1f4ee46b0d11a622780ab82965d62692ef9..01ec536dfd622f38fe36bde9853cb719c4199d43 100644 (file)
--- a/bpf_image.c
+++ b/bpf_image.c
@@ -306,13 +306,13 @@ bpf_image(p, n)
                fmt = "";
                break;
        }
                fmt = "";
                break;
        }

-       (void)snprintf(operand, sizeof operand, fmt, v);
+       (void)pcap_snprintf(operand, sizeof operand, fmt, v);

        if (BPF_CLASS(p->code) == BPF_JMP && BPF_OP(p->code) != BPF_JA) {
        if (BPF_CLASS(p->code) == BPF_JMP && BPF_OP(p->code) != BPF_JA) {

-               (void)snprintf(image, sizeof image,
+               (void)pcap_snprintf(image, sizeof image,

                              "(%03d) %-8s %-16s jt %d\tjf %d",
                              n, op, operand, n + 1 + p->jt, n + 1 + p->jf);
        } else {
                              "(%03d) %-8s %-16s jt %d\tjf %d",
                              n, op, operand, n + 1 + p->jt, n + 1 + p->jf);
        } else {

-               (void)snprintf(image, sizeof image,
+               (void)pcap_snprintf(image, sizeof image,

                              "(%03d) %-8s %s",
                              n, op, operand);
        }
                              "(%03d) %-8s %s",
                              n, op, operand);
        }

diff --git a/dlpisubs.c b/dlpisubs.c
index fd2d61c019428eb4d445459c2985b93a8e82ba11..053c38d8d99ee51f61041dd78df4cb407e1a2202 100644 (file)
--- a/dlpisubs.c
+++ b/dlpisubs.c
@@ -256,7 +256,7 @@ pcap_process_mactype(pcap_t *p, u_int mactype)
 #endif
 
        default:
 #endif
 
        default:

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "unknown mactype %u",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "unknown mactype %u",

                    mactype);
                retv = -1;
        }
                    mactype);
                retv = -1;
        }


@@ -362,6 +362,6 @@ strioctl(int fd, int cmd, int len, char *dp)
 static void
 pcap_stream_err(const char *func, int err, char *errbuf)
 {
 static void
 pcap_stream_err(const char *func, int err, char *errbuf)
 {

-       snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", func, pcap_strerror(err));
+       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", func, pcap_strerror(err));

 }
 #endif
 }
 #endif

diff --git a/fad-getad.c b/fad-getad.c
index 6fd3360f788f0b19e1847a65f1e81bac1f6bee26..7d631b366f1f7b7a10deebf7fcf81f7309da1c4c 100644 (file)
--- a/fad-getad.c
+++ b/fad-getad.c
@@ -168,7 +168,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
         * those.
         */
        if (getifaddrs(&ifap) != 0) {
         * those.
         */
        if (getifaddrs(&ifap) != 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "getifaddrs: %s", pcap_strerror(errno));
                return (-1);
        }
                    "getifaddrs: %s", pcap_strerror(errno));
                return (-1);
        }

diff --git a/fad-gifc.c b/fad-gifc.c
index b0a4105a838191cb1c0d15176b85163b9682db09..f9ed5e6e4d135bb75d0473e6452af91c83f33c52 100644 (file)
--- a/fad-gifc.c
+++ b/fad-gifc.c
@@ -154,7 +154,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                return (-1);
        }
                    "socket: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -170,7 +170,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
        for (;;) {
                buf = malloc(buf_size);
                if (buf == NULL) {
        for (;;) {
                buf = malloc(buf_size);
                if (buf == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        (void)close(fd);
                        return (-1);
                            "malloc: %s", pcap_strerror(errno));
                        (void)close(fd);
                        return (-1);


@@ -181,7 +181,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                memset(buf, 0, buf_size);
                if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0
                    && errno != EINVAL) {
                memset(buf, 0, buf_size);
                if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0
                    && errno != EINVAL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "SIOCGIFCONF: %s", pcap_strerror(errno));
                        (void)close(fd);
                        free(buf);
                            "SIOCGIFCONF: %s", pcap_strerror(errno));
                        (void)close(fd);
                        free(buf);


@@ -244,7 +244,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifrflags) < 0) {
                        if (errno == ENXIO)
                                continue;
                if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifrflags) < 0) {
                        if (errno == ENXIO)
                                continue;

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "SIOCGIFFLAGS: %.*s: %s",
                            (int)sizeof(ifrflags.ifr_name),
                            ifrflags.ifr_name,
                            "SIOCGIFFLAGS: %.*s: %s",
                            (int)sizeof(ifrflags.ifr_name),
                            ifrflags.ifr_name,


@@ -268,7 +268,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                                netmask = NULL;
                                netmask_size = 0;
                        } else {
                                netmask = NULL;
                                netmask_size = 0;
                        } else {

-                               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "SIOCGIFNETMASK: %.*s: %s",
                                    (int)sizeof(ifrnetmask.ifr_name),
                                    ifrnetmask.ifr_name,
                                    "SIOCGIFNETMASK: %.*s: %s",
                                    (int)sizeof(ifrnetmask.ifr_name),
                                    ifrnetmask.ifr_name,


@@ -299,7 +299,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                                        broadaddr = NULL;
                                        broadaddr_size = 0;
                                } else {
                                        broadaddr = NULL;
                                        broadaddr_size = 0;
                                } else {

-                                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                            "SIOCGIFBRDADDR: %.*s: %s",
                                            (int)sizeof(ifrbroadaddr.ifr_name),
                                            ifrbroadaddr.ifr_name,
                                            "SIOCGIFBRDADDR: %.*s: %s",
                                            (int)sizeof(ifrbroadaddr.ifr_name),
                                            ifrbroadaddr.ifr_name,


@@ -338,7 +338,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                                        dstaddr = NULL;
                                        dstaddr_size = 0;
                                } else {
                                        dstaddr = NULL;
                                        dstaddr_size = 0;
                                } else {

-                                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                            "SIOCGIFDSTADDR: %.*s: %s",
                                            (int)sizeof(ifrdstaddr.ifr_name),
                                            ifrdstaddr.ifr_name,
                                            "SIOCGIFDSTADDR: %.*s: %s",
                                            (int)sizeof(ifrdstaddr.ifr_name),
                                            ifrdstaddr.ifr_name,

diff --git a/fad-glifc.c b/fad-glifc.c
index 1a820ad90c611dbbd5454bb435bfcb5df2df8d7d..af3e1dea9558bf746b67163982d0fe613d620bff 100644 (file)
--- a/fad-glifc.c
+++ b/fad-glifc.c
@@ -97,7 +97,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
         */
        fd4 = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd4 < 0) {
         */
        fd4 = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd4 < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                return (-1);
        }
                    "socket: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -107,7 +107,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
         */
        fd6 = socket(AF_INET6, SOCK_DGRAM, 0);
        if (fd6 < 0) {
         */
        fd6 = socket(AF_INET6, SOCK_DGRAM, 0);
        if (fd6 < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                (void)close(fd4);
                return (-1);
                    "socket: %s", pcap_strerror(errno));
                (void)close(fd4);
                return (-1);


@@ -120,7 +120,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
        ifn.lifn_flags = 0;
        ifn.lifn_count = 0;
        if (ioctl(fd4, SIOCGLIFNUM, (char *)&ifn) < 0) {
        ifn.lifn_flags = 0;
        ifn.lifn_count = 0;
        if (ioctl(fd4, SIOCGLIFNUM, (char *)&ifn) < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "SIOCGLIFNUM: %s", pcap_strerror(errno));
                (void)close(fd6);
                (void)close(fd4);
                    "SIOCGLIFNUM: %s", pcap_strerror(errno));
                (void)close(fd6);
                (void)close(fd4);


@@ -133,7 +133,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
        buf_size = ifn.lifn_count * sizeof (struct lifreq);
        buf = malloc(buf_size);
        if (buf == NULL) {
        buf_size = ifn.lifn_count * sizeof (struct lifreq);
        buf = malloc(buf_size);
        if (buf == NULL) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "malloc: %s", pcap_strerror(errno));
                (void)close(fd6);
                (void)close(fd4);
                    "malloc: %s", pcap_strerror(errno));
                (void)close(fd6);
                (void)close(fd4);


@@ -149,7 +149,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
        ifc.lifc_flags = 0;
        memset(buf, 0, buf_size);
        if (ioctl(fd4, SIOCGLIFCONF, (char *)&ifc) < 0) {
        ifc.lifc_flags = 0;
        memset(buf, 0, buf_size);
        if (ioctl(fd4, SIOCGLIFCONF, (char *)&ifc) < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "SIOCGLIFCONF: %s", pcap_strerror(errno));
                (void)close(fd6);
                (void)close(fd4);
                    "SIOCGLIFCONF: %s", pcap_strerror(errno));
                (void)close(fd6);
                (void)close(fd4);


@@ -210,7 +210,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                if (ioctl(fd, SIOCGLIFFLAGS, (char *)&ifrflags) < 0) {
                        if (errno == ENXIO)
                                continue;
                if (ioctl(fd, SIOCGLIFFLAGS, (char *)&ifrflags) < 0) {
                        if (errno == ENXIO)
                                continue;

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "SIOCGLIFFLAGS: %.*s: %s",
                            (int)sizeof(ifrflags.lifr_name),
                            ifrflags.lifr_name,
                            "SIOCGLIFFLAGS: %.*s: %s",
                            (int)sizeof(ifrflags.lifr_name),
                            ifrflags.lifr_name,


@@ -233,7 +233,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                                 */
                                netmask = NULL;
                        } else {
                                 */
                                netmask = NULL;
                        } else {

-                               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "SIOCGLIFNETMASK: %.*s: %s",
                                    (int)sizeof(ifrnetmask.lifr_name),
                                    ifrnetmask.lifr_name,
                                    "SIOCGLIFNETMASK: %.*s: %s",
                                    (int)sizeof(ifrnetmask.lifr_name),
                                    ifrnetmask.lifr_name,


@@ -261,7 +261,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                                         */
                                        broadaddr = NULL;
                                } else {
                                         */
                                        broadaddr = NULL;
                                } else {

-                                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                            "SIOCGLIFBRDADDR: %.*s: %s",
                                            (int)sizeof(ifrbroadaddr.lifr_name),
                                            ifrbroadaddr.lifr_name,
                                            "SIOCGLIFBRDADDR: %.*s: %s",
                                            (int)sizeof(ifrbroadaddr.lifr_name),
                                            ifrbroadaddr.lifr_name,


@@ -296,7 +296,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                                         */
                                        dstaddr = NULL;
                                } else {
                                         */
                                        dstaddr = NULL;
                                } else {

-                                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                            "SIOCGLIFDSTADDR: %.*s: %s",
                                            (int)sizeof(ifrdstaddr.lifr_name),
                                            ifrdstaddr.lifr_name,
                                            "SIOCGLIFDSTADDR: %.*s: %s",
                                            (int)sizeof(ifrdstaddr.lifr_name),
                                            ifrdstaddr.lifr_name,

diff --git a/fad-win32.c b/fad-win32.c
index 7b050570f778f2be45fb516d67aafee34e7bd5fb..7852ef5531941a06f772f79d52e40276c0d97a3a 100755 (executable)
--- a/fad-win32.c
+++ b/fad-win32.c
@@ -155,7 +155,7 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
                if (last_error != ERROR_INSUFFICIENT_BUFFER)
                {
                        pcap_win32_err_to_str(last_error, our_errbuf);
                if (last_error != ERROR_INSUFFICIENT_BUFFER)
                {
                        pcap_win32_err_to_str(last_error, our_errbuf);

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "PacketGetAdapterNames: %s", our_errbuf);
                        return (-1);
                }
                            "PacketGetAdapterNames: %s", our_errbuf);
                        return (-1);
                }


@@ -170,13 +170,13 @@ pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
        }
        if (AdaptersName == NULL)
        {
        }
        if (AdaptersName == NULL)
        {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "Cannot allocate enough memory to list the adapters.");
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "Cannot allocate enough memory to list the adapters.");

                return (-1);
        }
 
        if (!PacketGetAdapterNames(AdaptersName, &NameLength)) {
                pcap_win32_err_to_str(GetLastError(), our_errbuf);
                return (-1);
        }
 
        if (!PacketGetAdapterNames(AdaptersName, &NameLength)) {
                pcap_win32_err_to_str(GetLastError(), our_errbuf);

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "PacketGetAdapterNames: %s",
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "PacketGetAdapterNames: %s",

                    our_errbuf);
                free(AdaptersName);
                return (-1);
                    our_errbuf);
                free(AdaptersName);
                return (-1);

diff --git a/gencode.c b/gencode.c
index 70072d3ca4523b3ad3ee8c15b78b65051d8b3e20..8c010e626be4d0f62b94fb89dc25148aa1361f70 100644 (file)
--- a/gencode.c
+++ b/gencode.c
@@ -194,7 +194,7 @@ bpf_error(const char *fmt, ...)
 
        va_start(ap, fmt);
        if (bpf_pcap != NULL)
 
        va_start(ap, fmt);
        if (bpf_pcap != NULL)

-               (void)vsnprintf(pcap_geterr(bpf_pcap), PCAP_ERRBUF_SIZE,
+               (void)pcap_vsnprintf(pcap_geterr(bpf_pcap), PCAP_ERRBUF_SIZE,

                    fmt, ap);
        va_end(ap);
        longjmp(top_ctx, 1);
                    fmt, ap);
        va_end(ap);
        longjmp(top_ctx, 1);


@@ -494,7 +494,7 @@ pcap_compile(pcap_t *p, struct bpf_program *program,
         * link-layer type, so we can't use it.
         */
        if (!p->activated) {
         * link-layer type, so we can't use it.
         */
        if (!p->activated) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "not-yet-activated pcap_t passed to pcap_compile");
                rc = -1;
                goto quit;
                    "not-yet-activated pcap_t passed to pcap_compile");
                rc = -1;
                goto quit;


@@ -522,7 +522,7 @@ pcap_compile(pcap_t *p, struct bpf_program *program,
 
        snaplen = pcap_snapshot(p);
        if (snaplen == 0) {
 
        snaplen = pcap_snapshot(p);
        if (snaplen == 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                         "snaplen of 0 rejects all packets");
                rc = -1;
                goto quit;
                         "snaplen of 0 rejects all packets");
                rc = -1;
                goto quit;

diff --git a/inet.c b/inet.c
index e1e0c98e1aa8557f015c31d07a9aae411e38a6c0..bd59a525dfd790500dffe39ff86b7b6f7be0f24f 100644 (file)
--- a/inet.c
+++ b/inet.c
@@ -239,7 +239,7 @@ add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
                        en_name_len = strlen(name) - 1;
                        en_name = malloc(en_name_len + 1);
                        if (en_name == NULL) {
                        en_name_len = strlen(name) - 1;
                        en_name = malloc(en_name_len + 1);
                        if (en_name == NULL) {

-                               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "malloc: %s", pcap_strerror(errno));
                                return (-1);
                        }
                                    "malloc: %s", pcap_strerror(errno));
                                return (-1);
                        }


@@ -315,7 +315,7 @@ add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
                 */
                curdev = malloc(sizeof(pcap_if_t));
                if (curdev == NULL) {
                 */
                curdev = malloc(sizeof(pcap_if_t));
                if (curdev == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        return (-1);
                }
                            "malloc: %s", pcap_strerror(errno));
                        return (-1);
                }


@@ -326,7 +326,7 @@ add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
                curdev->next = NULL;
                curdev->name = strdup(name);
                if (curdev->name == NULL) {
                curdev->next = NULL;
                curdev->name = strdup(name);
                if (curdev->name == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        free(curdev);
                        return (-1);
                            "malloc: %s", pcap_strerror(errno));
                        free(curdev);
                        return (-1);


@@ -337,7 +337,7 @@ add_or_find_if(pcap_if_t **curdev_ret, pcap_if_t **alldevs, const char *name,
                         */
                        curdev->description = strdup(description);
                        if (curdev->description == NULL) {
                         */
                        curdev->description = strdup(description);
                        if (curdev->description == NULL) {

-                               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "malloc: %s", pcap_strerror(errno));
                                free(curdev->name);
                                free(curdev);
                                    "malloc: %s", pcap_strerror(errno));
                                free(curdev->name);
                                free(curdev);


@@ -663,7 +663,7 @@ add_addr_to_dev(pcap_if_t *curdev,
 
        curaddr = malloc(sizeof(pcap_addr_t));
        if (curaddr == NULL) {
 
        curaddr = malloc(sizeof(pcap_addr_t));
        if (curaddr == NULL) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "malloc: %s", pcap_strerror(errno));
                return (-1);
        }
                    "malloc: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -672,7 +672,7 @@ add_addr_to_dev(pcap_if_t *curdev,
        if (addr != NULL) {
                curaddr->addr = dup_sockaddr(addr, addr_size);
                if (curaddr->addr == NULL) {
        if (addr != NULL) {
                curaddr->addr = dup_sockaddr(addr, addr_size);
                if (curaddr->addr == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        free(curaddr);
                        return (-1);
                            "malloc: %s", pcap_strerror(errno));
                        free(curaddr);
                        return (-1);


@@ -683,7 +683,7 @@ add_addr_to_dev(pcap_if_t *curdev,
        if (netmask != NULL) {
                curaddr->netmask = dup_sockaddr(netmask, netmask_size);
                if (curaddr->netmask == NULL) {
        if (netmask != NULL) {
                curaddr->netmask = dup_sockaddr(netmask, netmask_size);
                if (curaddr->netmask == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        if (curaddr->addr != NULL)
                                free(curaddr->addr);
                            "malloc: %s", pcap_strerror(errno));
                        if (curaddr->addr != NULL)
                                free(curaddr->addr);


@@ -696,7 +696,7 @@ add_addr_to_dev(pcap_if_t *curdev,
        if (broadaddr != NULL) {
                curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size);
                if (curaddr->broadaddr == NULL) {
        if (broadaddr != NULL) {
                curaddr->broadaddr = dup_sockaddr(broadaddr, broadaddr_size);
                if (curaddr->broadaddr == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        if (curaddr->netmask != NULL)
                                free(curaddr->netmask);
                            "malloc: %s", pcap_strerror(errno));
                        if (curaddr->netmask != NULL)
                                free(curaddr->netmask);


@@ -711,7 +711,7 @@ add_addr_to_dev(pcap_if_t *curdev,
        if (dstaddr != NULL) {
                curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size);
                if (curaddr->dstaddr == NULL) {
        if (dstaddr != NULL) {
                curaddr->dstaddr = dup_sockaddr(dstaddr, dstaddr_size);
                if (curaddr->dstaddr == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        if (curaddr->broadaddr != NULL)
                                free(curaddr->broadaddr);
                            "malloc: %s", pcap_strerror(errno));
                        if (curaddr->broadaddr != NULL)
                                free(curaddr->broadaddr);


@@ -915,7 +915,7 @@ pcap_lookupnet(device, netp, maskp, errbuf)
 
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {
 
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "socket: %s",
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "socket: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -927,10 +927,10 @@ pcap_lookupnet(device, netp, maskp, errbuf)
        (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
        if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0) {
                if (errno == EADDRNOTAVAIL) {
        (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
        if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0) {
                if (errno == EADDRNOTAVAIL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "%s: no IPv4 address assigned", device);
                } else {
                            "%s: no IPv4 address assigned", device);
                } else {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "SIOCGIFADDR: %s: %s",
                            device, pcap_strerror(errno));
                }
                            "SIOCGIFADDR: %s: %s",
                            device, pcap_strerror(errno));
                }


@@ -946,7 +946,7 @@ pcap_lookupnet(device, netp, maskp, errbuf)
 #endif
        (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
        if (ioctl(fd, SIOCGIFNETMASK, (char *)&ifr) < 0) {
 #endif
        (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
        if (ioctl(fd, SIOCGIFNETMASK, (char *)&ifr) < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "SIOCGIFNETMASK: %s: %s", device, pcap_strerror(errno));
                (void)close(fd);
                return (-1);
                    "SIOCGIFNETMASK: %s: %s", device, pcap_strerror(errno));
                (void)close(fd);
                return (-1);


@@ -961,7 +961,7 @@ pcap_lookupnet(device, netp, maskp, errbuf)
                else if (IN_CLASSC(*netp))
                        *maskp = IN_CLASSC_NET;
                else {
                else if (IN_CLASSC(*netp))
                        *maskp = IN_CLASSC_NET;
                else {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "inet class for 0x%x unknown", *netp);
                        return (-1);
                }
                            "inet class for 0x%x unknown", *netp);
                        return (-1);
                }


@@ -1016,14 +1016,14 @@ pcap_lookupdev(errbuf)
 
                if(TAdaptersName == NULL)
                {
 
                if(TAdaptersName == NULL)
                {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE, "memory allocation failure");
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "memory allocation failure");

                        return NULL;
                }
 
                if ( !PacketGetAdapterNames((PTSTR)TAdaptersName,&NameLength) )
                {
                        pcap_win32_err_to_str(GetLastError(), our_errbuf);
                        return NULL;
                }
 
                if ( !PacketGetAdapterNames((PTSTR)TAdaptersName,&NameLength) )
                {
                        pcap_win32_err_to_str(GetLastError(), our_errbuf);

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                "PacketGetAdapterNames: %s", our_errbuf);
                        free(TAdaptersName);
                        return NULL;
                                "PacketGetAdapterNames: %s", our_errbuf);
                        free(TAdaptersName);
                        return NULL;

diff --git a/lbl/os-osf4.h b/lbl/os-osf4.h
index f461eeaff5e61de26af17d7efd3fa3fa91c92cbe..055eb80ac623a0d1509419f4032b5970ecf43aad 100644 (file)
--- a/lbl/os-osf4.h
+++ b/lbl/os-osf4.h
@@ -20,7 +20,7 @@
  */
 
 /* Prototypes missing in Digital UNIX 4.x */
  */
 
 /* Prototypes missing in Digital UNIX 4.x */

-int    snprintf(char *, size_t, const char *, ...);
-int    vsnprintf(char *, size_t, const char *, va_list);
+int    pcap_snprintf(char *, size_t, const char *, ...);
+int    pcap_vsnprintf(char *, size_t, const char *, va_list);

 int    pfopen(char *, int);
 
 int    pfopen(char *, int);
 

diff --git a/lbl/os-osf5.h b/lbl/os-osf5.h
index 52ab1750e1fd18b349dfcd3c1b2dd9745d3c07da..5422f18f18a1f6736c634f0a74354b304d4ad420 100644 (file)
--- a/lbl/os-osf5.h
+++ b/lbl/os-osf5.h
@@ -21,10 +21,10 @@
 
 /*
  * Prototypes missing in Tru64 UNIX 5.x
 
 /*
  * Prototypes missing in Tru64 UNIX 5.x

- * XXX - "snprintf()" and "vsnprintf()" aren't missing, but you have to
+ * XXX - "pcap_snprintf()" and "pcap_vsnprintf()" aren't missing, but you have to

  * #define the right value to get them defined by <stdio.h>.
  */
  * #define the right value to get them defined by <stdio.h>.
  */

-int    snprintf(char *, size_t, const char *, ...);
-int    vsnprintf(char *, size_t, const char *, va_list);
+int    pcap_snprintf(char *, size_t, const char *, ...);
+int    pcap_vsnprintf(char *, size_t, const char *, va_list);

 int    pfopen(char *, int);
 
 int    pfopen(char *, int);
 

diff --git a/lbl/os-solaris2.h b/lbl/os-solaris2.h
index 22948b4a2695b1ea07dcb5f5916f93af1444299f..a555f5ed3147128c97c609f9e1034dfca548e497 100644 (file)
--- a/lbl/os-solaris2.h
+++ b/lbl/os-solaris2.h
@@ -21,4 +21,4 @@
 
 /* Prototypes missing in SunOS 5 */
 char    *strerror(int);
 
 /* Prototypes missing in SunOS 5 */
 char    *strerror(int);

-int    snprintf(char *, size_t, const char *, ...);
+int    pcap_snprintf(char *, size_t, const char *, ...);

diff --git a/lbl/os-sunos4.h b/lbl/os-sunos4.h
index ab032ef98dbdae495e8d3ab712845be4e8958861..6353fb09cf6e42c44cc151f72d86e3c05662c952 100644 (file)
--- a/lbl/os-sunos4.h
+++ b/lbl/os-sunos4.h
@@ -155,7 +155,7 @@ int sigsetmask(int);
 struct sigvec;
 #endif
 int    sigvec(int, struct sigvec *, struct sigvec*);
 struct sigvec;
 #endif
 int    sigvec(int, struct sigvec *, struct sigvec*);

-int    snprintf(char *, size_t, const char *, ...);
+int    pcap_snprintf(char *, size_t, const char *, ...);

 int    socket(int, int, int);
 int    socketpair(int, int, int, int *);
 int    symlink(const char *, const char *);
 int    socket(int, int, int);
 int    socketpair(int, int, int, int *);
 int    symlink(const char *, const char *);

diff --git a/missing/getopt.c b/missing/getopt.c
index 14cd6a328652d99797714936e313a5a47ebab1d4..cc798e1de84d352f15dd5a14037f890955e4b72b 100644 (file)
--- a/missing/getopt.c
+++ b/missing/getopt.c
@@ -39,6 +39,8 @@ static char sccsid[] = "@(#)getopt.c  8.3 (Berkeley) 4/27/95";
 #include <stdlib.h>
 #include <string.h>
 
 #include <stdlib.h>
 #include <string.h>
 

+#include "getopt.h"
+

 int    opterr = 1,             /* if error message should be printed */
        optind = 1,             /* index into parent argv vector */
        optopt,                 /* character checked for validity */
 int    opterr = 1,             /* if error message should be printed */
        optind = 1,             /* index into parent argv vector */
        optopt,                 /* character checked for validity */

diff --git a/missing/snprintf.c b/missing/snprintf.c
index 9b63f8b1dcd0b90cdd1f0dad9ae8085d073e9e68..99f0bdfc2a9308918ce77551dd547728a2e767b0 100644 (file)
--- a/missing/snprintf.c
+++ b/missing/snprintf.c
@@ -456,13 +456,13 @@ xyzprintf (struct state *state, const char *char_format, va_list ap)
 
 #ifndef HAVE_SNPRINTF
 int
 
 #ifndef HAVE_SNPRINTF
 int

-snprintf (char *str, size_t sz, const char *format, ...)
+pcap_snprintf (char *str, size_t sz, const char *format, ...)

 {
   va_list args;
   int ret;
 
   va_start(args, format);
 {
   va_list args;
   int ret;
 
   va_start(args, format);

-  ret = vsnprintf (str, sz, format, args);
+  ret = pcap_vsnprintf (str, sz, format, args);

 
 #ifdef PARANOIA
   {
 
 #ifdef PARANOIA
   {


@@ -473,7 +473,7 @@ snprintf (char *str, size_t sz, const char *format, ...)
     if (tmp == NULL)
       abort ();
 
     if (tmp == NULL)
       abort ();
 

-    ret2 = vsprintf (tmp, format, args);
+    ret2 = pcap_vsprintf (tmp, format, args);

     if (ret != ret2 || strcmp(str, tmp))
       abort ();
     free (tmp);
     if (ret != ret2 || strcmp(str, tmp))
       abort ();
     free (tmp);


@@ -518,13 +518,13 @@ asprintf (char **ret, const char *format, ...)
 
 #ifndef HAVE_ASNPRINTF
 int
 
 #ifndef HAVE_ASNPRINTF
 int

-asnprintf (char **ret, size_t max_sz, const char *format, ...)
+pcap_asnprintf (char **ret, size_t max_sz, const char *format, ...)

 {
   va_list args;
   int val;
 
   va_start(args, format);
 {
   va_list args;
   int val;
 
   va_start(args, format);

-  val = vasnprintf (ret, max_sz, format, args);
+  val = pcap_vasnprintf (ret, max_sz, format, args);

 
 #ifdef PARANOIA
   {
 
 #ifdef PARANOIA
   {


@@ -534,7 +534,7 @@ asnprintf (char **ret, size_t max_sz, const char *format, ...)
     if (tmp == NULL)
       abort ();
 
     if (tmp == NULL)
       abort ();
 

-    ret2 = vsprintf (tmp, format, args);
+    ret2 = pcap_vsprintf (tmp, format, args);

     if (val != ret2 || strcmp(*ret, tmp))
       abort ();
     free (tmp);
     if (val != ret2 || strcmp(*ret, tmp))
       abort ();
     free (tmp);


@@ -548,16 +548,16 @@ asnprintf (char **ret, size_t max_sz, const char *format, ...)
 
 #ifndef HAVE_VASPRINTF
 int
 
 #ifndef HAVE_VASPRINTF
 int

-vasprintf (char **ret, const char *format, va_list args)
+pcap_vasprintf (char **ret, const char *format, va_list args)

 {
 {

-  return vasnprintf (ret, 0, format, args);
+  return pcap_vasnprintf (ret, 0, format, args);

 }
 #endif
 
 
 #ifndef HAVE_VASNPRINTF
 int
 }
 #endif
 
 
 #ifndef HAVE_VASNPRINTF
 int

-vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
+pcap_vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)

 {
   int st;
   size_t len;
 {
   int st;
   size_t len;


@@ -600,7 +600,7 @@ vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
 
 #ifndef HAVE_VSNPRINTF
 int
 
 #ifndef HAVE_VSNPRINTF
 int

-vsnprintf (char *str, size_t sz, const char *format, va_list args)
+pcap_vsnprintf (char *str, size_t sz, const char *format, va_list args)

 {
   struct state state;
   int ret;
 {
   struct state state;
   int ret;

diff --git a/optimize.c b/optimize.c
index a284d413281f011a400def9c1f6c3dc6be40dce1..0a136b7a031a0ab5239beeb4e6d7e7aaadd7f847 100644 (file)
--- a/optimize.c
+++ b/optimize.c
@@ -2238,7 +2238,7 @@ install_bpf_program(pcap_t *p, struct bpf_program *fp)
         * Validate the program.
         */
        if (!bpf_validate(fp->bf_insns, fp->bf_len)) {
         * Validate the program.
         */
        if (!bpf_validate(fp->bf_insns, fp->bf_len)) {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                        "BPF program is not valid");
                return (-1);
        }
                        "BPF program is not valid");
                return (-1);
        }


@@ -2252,7 +2252,7 @@ install_bpf_program(pcap_t *p, struct bpf_program *fp)
        p->fcode.bf_len = fp->bf_len;
        p->fcode.bf_insns = (struct bpf_insn *)malloc(prog_size);
        if (p->fcode.bf_insns == NULL) {
        p->fcode.bf_len = fp->bf_len;
        p->fcode.bf_insns = (struct bpf_insn *)malloc(prog_size);
        if (p->fcode.bf_insns == NULL) {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                         "malloc: %s", pcap_strerror(errno));
                return (-1);
        }
                         "malloc: %s", pcap_strerror(errno));
                return (-1);
        }

diff --git a/pcap-bpf.c b/pcap-bpf.c
index 5b863b2ba6c82f4693f7d7644e7734cd4838f642..0af48346669f25461c431d94300b5783ec33d469 100644 (file)
--- a/pcap-bpf.c
+++ b/pcap-bpf.c
@@ -347,7 +347,7 @@ pcap_next_zbuf(pcap_t *p, int *cc)
                        if (data)
                                return (data);
                        if (ioctl(p->fd, BIOCROTZBUF, &bz) < 0) {
                        if (data)
                                return (data);
                        if (ioctl(p->fd, BIOCROTZBUF, &bz) < 0) {

-                               (void) snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               (void) pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "BIOCROTZBUF: %s", strerror(errno));
                                return (PCAP_ERROR);
                        }
                                    "BIOCROTZBUF: %s", strerror(errno));
                                return (PCAP_ERROR);
                        }


@@ -375,7 +375,7 @@ pcap_next_zbuf(pcap_t *p, int *cc)
                        }
                        return (0);
                } else if (r < 0) {
                        }
                        return (0);
                } else if (r < 0) {

-                       (void) snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       (void) pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "select: %s", strerror(errno));
                        return (PCAP_ERROR);
                }
                            "select: %s", strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -394,7 +394,7 @@ pcap_next_zbuf(pcap_t *p, int *cc)
         * data.
         */
        if (ioctl(p->fd, BIOCROTZBUF, &bz) < 0) {
         * data.
         */
        if (ioctl(p->fd, BIOCROTZBUF, &bz) < 0) {

-               (void) snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               (void) pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "BIOCROTZBUF: %s", strerror(errno));
                return (PCAP_ERROR);
        }
                    "BIOCROTZBUF: %s", strerror(errno));
                return (PCAP_ERROR);
        }


@@ -464,7 +464,7 @@ bpf_open(pcap_t *p)
                        fd = PCAP_ERROR_PERM_DENIED;
                else
                        fd = PCAP_ERROR;
                        fd = PCAP_ERROR_PERM_DENIED;
                else
                        fd = PCAP_ERROR;

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                  "(cannot open device) %s: %s", device, pcap_strerror(errno));
        }
 #else
                  "(cannot open device) %s: %s", device, pcap_strerror(errno));
        }
 #else


@@ -472,7 +472,7 @@ bpf_open(pcap_t *p)
         * Go through all the minors and find one that isn't in use.
         */
        do {
         * Go through all the minors and find one that isn't in use.
         */
        do {

-               (void)snprintf(device, sizeof(device), "/dev/bpf%d", n++);
+               (void)pcap_snprintf(device, sizeof(device), "/dev/bpf%d", n++);

                /*
                 * Initially try a read/write open (to allow the inject
                 * method to work).  If that fails due to permission
                /*
                 * Initially try a read/write open (to allow the inject
                 * method to work).  If that fails due to permission


@@ -506,7 +506,7 @@ bpf_open(pcap_t *p)
                                 * means we probably have no BPF
                                 * devices.
                                 */
                                 * means we probably have no BPF
                                 * devices.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "(there are no BPF devices)");
                        } else {
                                /*
                                    "(there are no BPF devices)");
                        } else {
                                /*


@@ -515,7 +515,7 @@ bpf_open(pcap_t *p)
                                 * devices, but all the ones
                                 * that exist are busy.
                                 */
                                 * devices, but all the ones
                                 * that exist are busy.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "(all BPF devices are busy)");
                        }
                        break;
                                    "(all BPF devices are busy)");
                        }
                        break;


@@ -527,7 +527,7 @@ bpf_open(pcap_t *p)
                         * if any.
                         */
                        fd = PCAP_ERROR_PERM_DENIED;
                         * if any.
                         */
                        fd = PCAP_ERROR_PERM_DENIED;

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "(cannot open BPF device) %s: %s", device,
                            pcap_strerror(errno));
                        break;
                            "(cannot open BPF device) %s: %s", device,
                            pcap_strerror(errno));
                        break;


@@ -537,7 +537,7 @@ bpf_open(pcap_t *p)
                         * Some other problem.
                         */
                        fd = PCAP_ERROR;
                         * Some other problem.
                         */
                        fd = PCAP_ERROR;

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "(cannot open BPF device) %s: %s", device,
                            pcap_strerror(errno));
                        break;
                            "(cannot open BPF device) %s: %s", device,
                            pcap_strerror(errno));
                        break;


@@ -559,13 +559,13 @@ get_dlt_list(int fd, int v, struct bpf_dltlist *bdlp, char *ebuf)
 
                bdlp->bfl_list = (u_int *) malloc(sizeof(u_int) * (bdlp->bfl_len + 1));
                if (bdlp->bfl_list == NULL) {
 
                bdlp->bfl_list = (u_int *) malloc(sizeof(u_int) * (bdlp->bfl_len + 1));
                if (bdlp->bfl_list == NULL) {

-                       (void)snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+                       (void)pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                            pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
 
                if (ioctl(fd, BIOCGDLTLIST, (caddr_t)bdlp) < 0) {
                            pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
 
                if (ioctl(fd, BIOCGDLTLIST, (caddr_t)bdlp) < 0) {

-                       (void)snprintf(ebuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                            "BIOCGDLTLIST: %s", pcap_strerror(errno));
                        free(bdlp->bfl_list);
                        return (PCAP_ERROR);
                            "BIOCGDLTLIST: %s", pcap_strerror(errno));
                        free(bdlp->bfl_list);
                        return (PCAP_ERROR);


@@ -620,7 +620,7 @@ get_dlt_list(int fd, int v, struct bpf_dltlist *bdlp, char *ebuf)
                 * this device"; don't treat it as an error.
                 */
                if (errno != EINVAL) {
                 * this device"; don't treat it as an error.
                 */
                if (errno != EINVAL) {

-                       (void)snprintf(ebuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                            "BIOCGDLTLIST: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            "BIOCGDLTLIST: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -687,7 +687,7 @@ pcap_can_set_rfmon_bpf(pcap_t *p)
                }
                fd = socket(AF_INET, SOCK_DGRAM, 0);
                if (fd == -1) {
                }
                fd = socket(AF_INET, SOCK_DGRAM, 0);
                if (fd == -1) {

-                       (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "socket: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            "socket: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -742,7 +742,7 @@ pcap_can_set_rfmon_bpf(pcap_t *p)
                        return (PCAP_ERROR_IFACE_NOT_UP);
 
                default:
                        return (PCAP_ERROR_IFACE_NOT_UP);
 
                default:

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "BIOCSETIF: %s: %s",
                            p->opt.source, pcap_strerror(errno));
                        close(fd);
                            "BIOCSETIF: %s: %s",
                            p->opt.source, pcap_strerror(errno));
                        close(fd);


@@ -805,7 +805,7 @@ pcap_stats_bpf(pcap_t *p, struct pcap_stat *ps)
         * by libpcap, and thus not yet seen by the application.
         */
        if (ioctl(p->fd, BIOCGSTATS, (caddr_t)&s) < 0) {
         * by libpcap, and thus not yet seen by the application.
         */
        if (ioctl(p->fd, BIOCGSTATS, (caddr_t)&s) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGSTATS: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGSTATS: %s",

                    pcap_strerror(errno));
                return (PCAP_ERROR);
        }
                    pcap_strerror(errno));
                return (PCAP_ERROR);
        }


@@ -914,7 +914,7 @@ pcap_read_bpf(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                 * pcap_dispatch() etc. aren't
                                 * defined to retur that.
                                 */
                                 * pcap_dispatch() etc. aren't
                                 * defined to retur that.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "The interface went down");
                                return (PCAP_ERROR);
 
                                    "The interface went down");
                                return (PCAP_ERROR);
 


@@ -933,7 +933,7 @@ pcap_read_bpf(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                /* fall through */
 #endif
                        }
                                /* fall through */
 #endif
                        }

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read: %s",

                            pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -1084,7 +1084,7 @@ pcap_inject_bpf(pcap_t *p, const void *buf, size_t size)
                u_int spoof_eth_src = 0;
 
                if (ioctl(p->fd, BIOCSHDRCMPLT, &spoof_eth_src) == -1) {
                u_int spoof_eth_src = 0;
 
                if (ioctl(p->fd, BIOCSHDRCMPLT, &spoof_eth_src) == -1) {

-                       (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "send: can't turn off BIOCSHDRCMPLT: %s",
                            pcap_strerror(errno));
                        return (PCAP_ERROR);
                            "send: can't turn off BIOCSHDRCMPLT: %s",
                            pcap_strerror(errno));
                        return (PCAP_ERROR);


@@ -1097,7 +1097,7 @@ pcap_inject_bpf(pcap_t *p, const void *buf, size_t size)
        }
 #endif /* __APPLE__ */
        if (ret == -1) {
        }
 #endif /* __APPLE__ */
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (PCAP_ERROR);
        }
                    pcap_strerror(errno));
                return (PCAP_ERROR);
        }


@@ -1113,7 +1113,7 @@ bpf_odminit(char *errbuf)
        if (odm_initialize() == -1) {
                if (odm_err_msg(odmerrno, &errstr) == -1)
                        errstr = "Unknown error";
        if (odm_initialize() == -1) {
                if (odm_err_msg(odmerrno, &errstr) == -1)
                        errstr = "Unknown error";

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "bpf_load: odm_initialize failed: %s",
                    errstr);
                return (PCAP_ERROR);
                    "bpf_load: odm_initialize failed: %s",
                    errstr);
                return (PCAP_ERROR);


@@ -1122,7 +1122,7 @@ bpf_odminit(char *errbuf)
        if ((odmlockid = odm_lock("/etc/objrepos/config_lock", ODM_WAIT)) == -1) {
                if (odm_err_msg(odmerrno, &errstr) == -1)
                        errstr = "Unknown error";
        if ((odmlockid = odm_lock("/etc/objrepos/config_lock", ODM_WAIT)) == -1) {
                if (odm_err_msg(odmerrno, &errstr) == -1)
                        errstr = "Unknown error";

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "bpf_load: odm_lock of /etc/objrepos/config_lock failed: %s",
                    errstr);
                (void)odm_terminate();
                    "bpf_load: odm_lock of /etc/objrepos/config_lock failed: %s",
                    errstr);
                (void)odm_terminate();


@@ -1141,7 +1141,7 @@ bpf_odmcleanup(char *errbuf)
                if (errbuf != NULL) {
                        if (odm_err_msg(odmerrno, &errstr) == -1)
                                errstr = "Unknown error";
                if (errbuf != NULL) {
                        if (odm_err_msg(odmerrno, &errstr) == -1)
                                errstr = "Unknown error";

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "bpf_load: odm_unlock failed: %s",
                            errstr);
                }
                            "bpf_load: odm_unlock failed: %s",
                            errstr);
                }


@@ -1152,7 +1152,7 @@ bpf_odmcleanup(char *errbuf)
                if (errbuf != NULL) {
                        if (odm_err_msg(odmerrno, &errstr) == -1)
                                errstr = "Unknown error";
                if (errbuf != NULL) {
                        if (odm_err_msg(odmerrno, &errstr) == -1)
                                errstr = "Unknown error";

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "bpf_load: odm_terminate failed: %s",
                            errstr);
                }
                            "bpf_load: odm_terminate failed: %s",
                            errstr);
                }


@@ -1186,7 +1186,7 @@ bpf_load(char *errbuf)
 
        major = genmajor(BPF_NAME);
        if (major == -1) {
 
        major = genmajor(BPF_NAME);
        if (major == -1) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "bpf_load: genmajor failed: %s", pcap_strerror(errno));
                (void)bpf_odmcleanup(NULL);
                return (PCAP_ERROR);
                    "bpf_load: genmajor failed: %s", pcap_strerror(errno));
                (void)bpf_odmcleanup(NULL);
                return (PCAP_ERROR);


@@ -1196,7 +1196,7 @@ bpf_load(char *errbuf)
        if (!minors) {
                minors = genminor("bpf", major, 0, BPF_MINORS, 1, 1);
                if (!minors) {
        if (!minors) {
                minors = genminor("bpf", major, 0, BPF_MINORS, 1, 1);
                if (!minors) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "bpf_load: genminor failed: %s",
                            pcap_strerror(errno));
                        (void)bpf_odmcleanup(NULL);
                            "bpf_load: genminor failed: %s",
                            pcap_strerror(errno));
                        (void)bpf_odmcleanup(NULL);


@@ -1209,7 +1209,7 @@ bpf_load(char *errbuf)
 
        rc = stat(BPF_NODE "0", &sbuf);
        if (rc == -1 && errno != ENOENT) {
 
        rc = stat(BPF_NODE "0", &sbuf);
        if (rc == -1 && errno != ENOENT) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "bpf_load: can't stat %s: %s",
                    BPF_NODE "0", pcap_strerror(errno));
                return (PCAP_ERROR);
                    "bpf_load: can't stat %s: %s",
                    BPF_NODE "0", pcap_strerror(errno));
                return (PCAP_ERROR);


@@ -1220,7 +1220,7 @@ bpf_load(char *errbuf)
                        sprintf(buf, "%s%d", BPF_NODE, i);
                        unlink(buf);
                        if (mknod(buf, S_IRUSR | S_IFCHR, domakedev(major, i)) == -1) {
                        sprintf(buf, "%s%d", BPF_NODE, i);
                        unlink(buf);
                        if (mknod(buf, S_IRUSR | S_IFCHR, domakedev(major, i)) == -1) {

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "bpf_load: can't mknod %s: %s",
                                    buf, pcap_strerror(errno));
                                return (PCAP_ERROR);
                                    "bpf_load: can't mknod %s: %s",
                                    buf, pcap_strerror(errno));
                                return (PCAP_ERROR);


@@ -1236,7 +1236,7 @@ bpf_load(char *errbuf)
            (cfg_ld.kmid == 0)) {
                /* Driver isn't loaded, load it now */
                if (sysconfig(SYS_SINGLELOAD, (void *)&cfg_ld, sizeof(cfg_ld)) == -1) {
            (cfg_ld.kmid == 0)) {
                /* Driver isn't loaded, load it now */
                if (sysconfig(SYS_SINGLELOAD, (void *)&cfg_ld, sizeof(cfg_ld)) == -1) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "bpf_load: could not load driver: %s",
                            strerror(errno));
                        return (PCAP_ERROR);
                            "bpf_load: could not load driver: %s",
                            strerror(errno));
                        return (PCAP_ERROR);


@@ -1251,7 +1251,7 @@ bpf_load(char *errbuf)
        for (i = 0; i < BPF_MINORS; i++) {
                cfg_bpf.devno = domakedev(major, i);
                if (sysconfig(SYS_CFGKMOD, (void *)&cfg_km, sizeof(cfg_km)) == -1) {
        for (i = 0; i < BPF_MINORS; i++) {
                cfg_bpf.devno = domakedev(major, i);
                if (sysconfig(SYS_CFGKMOD, (void *)&cfg_km, sizeof(cfg_km)) == -1) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "bpf_load: could not configure driver: %s",
                            strerror(errno));
                        return (PCAP_ERROR);
                            "bpf_load: could not configure driver: %s",
                            strerror(errno));
                        return (PCAP_ERROR);


@@ -1399,7 +1399,7 @@ check_setif_failure(pcap_t *p, int error)
                                         * exist.
                                         */
                                        err = PCAP_ERROR_NO_SUCH_DEVICE;
                                         * exist.
                                         */
                                        err = PCAP_ERROR_NO_SUCH_DEVICE;

-                                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                            "SIOCGIFFLAGS on %s failed: %s",
                                            ifr.ifr_name, pcap_strerror(errno));
                                } else {
                                            "SIOCGIFFLAGS on %s failed: %s",
                                            ifr.ifr_name, pcap_strerror(errno));
                                } else {


@@ -1423,7 +1423,7 @@ check_setif_failure(pcap_t *p, int error)
                                 * just report "no such device".
                                 */
                                err = PCAP_ERROR_NO_SUCH_DEVICE;
                                 * just report "no such device".
                                 */
                                err = PCAP_ERROR_NO_SUCH_DEVICE;

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "socket() failed: %s",
                                    pcap_strerror(errno));
                        }
                                    "socket() failed: %s",
                                    pcap_strerror(errno));
                        }


@@ -1433,7 +1433,7 @@ check_setif_failure(pcap_t *p, int error)
                /*
                 * No such device.
                 */
                /*
                 * No such device.
                 */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETIF failed: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETIF failed: %s",

                    pcap_strerror(errno));
                return (PCAP_ERROR_NO_SUCH_DEVICE);
        } else if (errno == ENETDOWN) {
                    pcap_strerror(errno));
                return (PCAP_ERROR_NO_SUCH_DEVICE);
        } else if (errno == ENETDOWN) {


@@ -1450,7 +1450,7 @@ check_setif_failure(pcap_t *p, int error)
                 * Some other error; fill in the error string, and
                 * return PCAP_ERROR.
                 */
                 * Some other error; fill in the error string, and
                 * return PCAP_ERROR.
                 */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETIF: %s: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETIF: %s: %s",

                    p->opt.source, pcap_strerror(errno));
                return (PCAP_ERROR);
        }
                    p->opt.source, pcap_strerror(errno));
                return (PCAP_ERROR);
        }


@@ -1523,14 +1523,14 @@ pcap_activate_bpf(pcap_t *p)
        p->fd = fd;
 
        if (ioctl(fd, BIOCVERSION, (caddr_t)&bv) < 0) {
        p->fd = fd;
 
        if (ioctl(fd, BIOCVERSION, (caddr_t)&bv) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCVERSION: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCVERSION: %s",

                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
        }
        if (bv.bv_major != BPF_MAJOR_VERSION ||
            bv.bv_minor < BPF_MINOR_VERSION) {
                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
        }
        if (bv.bv_major != BPF_MAJOR_VERSION ||
            bv.bv_minor < BPF_MINOR_VERSION) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "kernel bpf filter out of date");
                status = PCAP_ERROR;
                goto bad;
                    "kernel bpf filter out of date");
                status = PCAP_ERROR;
                goto bad;


@@ -1541,7 +1541,7 @@ pcap_activate_bpf(pcap_t *p)
         * Retrieve the zoneid of the zone we are currently executing in.
         */
        if ((ifr.lifr_zoneid = getzoneid()) == -1) {
         * Retrieve the zoneid of the zone we are currently executing in.
         */
        if ((ifr.lifr_zoneid = getzoneid()) == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "getzoneid(): %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "getzoneid(): %s",

                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -1559,7 +1559,7 @@ pcap_activate_bpf(pcap_t *p)
                char *lnamep;
 
                if (ifr.lifr_zoneid != GLOBAL_ZONEID) {
                char *lnamep;
 
                if (ifr.lifr_zoneid != GLOBAL_ZONEID) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "zonename/linkname only valid in global zone.");
                        status = PCAP_ERROR;
                        goto bad;
                            "zonename/linkname only valid in global zone.");
                        status = PCAP_ERROR;
                        goto bad;


@@ -1568,7 +1568,7 @@ pcap_activate_bpf(pcap_t *p)
                (void) strlcpy(path_zname, p->opt.source, znamelen + 1);
                ifr.lifr_zoneid = getzoneidbyname(path_zname);
                if (ifr.lifr_zoneid == -1) {
                (void) strlcpy(path_zname, p->opt.source, znamelen + 1);
                ifr.lifr_zoneid = getzoneidbyname(path_zname);
                if (ifr.lifr_zoneid == -1) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "getzoneidbyname(%s): %s", path_zname,
                        pcap_strerror(errno));
                        status = PCAP_ERROR;
                            "getzoneidbyname(%s): %s", path_zname,
                        pcap_strerror(errno));
                        status = PCAP_ERROR;


@@ -1576,7 +1576,7 @@ pcap_activate_bpf(pcap_t *p)
                }
                lnamep = strdup(zonesep + 1);
                if (lnamep == NULL) {
                }
                lnamep = strdup(zonesep + 1);
                if (lnamep == NULL) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",

                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;


@@ -1588,7 +1588,7 @@ pcap_activate_bpf(pcap_t *p)
 
        pb->device = strdup(p->opt.source);
        if (pb->device == NULL) {
 
        pb->device = strdup(p->opt.source);
        if (pb->device == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",

                     pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                     pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -1643,7 +1643,7 @@ pcap_activate_bpf(pcap_t *p)
                                                         * exist.
                                                         */
                                                        status = PCAP_ERROR_NO_SUCH_DEVICE;
                                                         * exist.
                                                         */
                                                        status = PCAP_ERROR_NO_SUCH_DEVICE;

-                                                       snprintf(p->errbuf,
+                                                       pcap_snprintf(p->errbuf,

                                                            PCAP_ERRBUF_SIZE,
                                                            "SIOCGIFFLAGS failed: %s",
                                                            pcap_strerror(errno));
                                                            PCAP_ERRBUF_SIZE,
                                                            "SIOCGIFFLAGS failed: %s",
                                                            pcap_strerror(errno));


@@ -1657,7 +1657,7 @@ pcap_activate_bpf(pcap_t *p)
                                                 * report "no such device".
                                                 */
                                                status = PCAP_ERROR_NO_SUCH_DEVICE;
                                                 * report "no such device".
                                                 */
                                                status = PCAP_ERROR_NO_SUCH_DEVICE;

-                                               snprintf(p->errbuf,
+                                               pcap_snprintf(p->errbuf,

                                                    PCAP_ERRBUF_SIZE,
                                                    "socket() failed: %s",
                                                    pcap_strerror(errno));
                                                    PCAP_ERRBUF_SIZE,
                                                    "socket() failed: %s",
                                                    pcap_strerror(errno));


@@ -1666,7 +1666,7 @@ pcap_activate_bpf(pcap_t *p)
                                }
                                wltdev = malloc(strlen(p->opt.source) + 2);
                                if (wltdev == NULL) {
                                }
                                wltdev = malloc(strlen(p->opt.source) + 2);
                                if (wltdev == NULL) {

-                                       (void)snprintf(p->errbuf,
+                                       (void)pcap_snprintf(p->errbuf,

                                            PCAP_ERRBUF_SIZE, "malloc: %s",
                                            pcap_strerror(errno));
                                        status = PCAP_ERROR;
                                            PCAP_ERRBUF_SIZE, "malloc: %s",
                                            pcap_strerror(errno));
                                        status = PCAP_ERROR;


@@ -1707,7 +1707,7 @@ pcap_activate_bpf(pcap_t *p)
                 * size.
                 */
                if (ioctl(fd, BIOCGETZMAX, (caddr_t)&zbufmax) < 0) {
                 * size.
                 */
                if (ioctl(fd, BIOCGETZMAX, (caddr_t)&zbufmax) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGETZMAX: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGETZMAX: %s",

                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;


@@ -1734,7 +1734,7 @@ pcap_activate_bpf(pcap_t *p)
                pb->zbuf2 = mmap(NULL, pb->zbufsize, PROT_READ | PROT_WRITE,
                    MAP_ANON, -1, 0);
                if (pb->zbuf1 == MAP_FAILED || pb->zbuf2 == MAP_FAILED) {
                pb->zbuf2 = mmap(NULL, pb->zbufsize, PROT_READ | PROT_WRITE,
                    MAP_ANON, -1, 0);
                if (pb->zbuf1 == MAP_FAILED || pb->zbuf2 == MAP_FAILED) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "mmap: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "mmap: %s",

                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;


@@ -1744,14 +1744,14 @@ pcap_activate_bpf(pcap_t *p)
                bz.bz_bufb = pb->zbuf2;
                bz.bz_buflen = pb->zbufsize;
                if (ioctl(fd, BIOCSETZBUF, (caddr_t)&bz) < 0) {
                bz.bz_bufb = pb->zbuf2;
                bz.bz_buflen = pb->zbufsize;
                if (ioctl(fd, BIOCSETZBUF, (caddr_t)&bz) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETZBUF: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETZBUF: %s",

                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                }
                (void)strncpy(ifrname, p->opt.source, ifnamsiz);
                if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) < 0) {
                            pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                }
                (void)strncpy(ifrname, p->opt.source, ifnamsiz);
                if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETIF: %s: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETIF: %s: %s",

                            p->opt.source, pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                            p->opt.source, pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;


@@ -1770,7 +1770,7 @@ pcap_activate_bpf(pcap_t *p)
                         */
                        if (ioctl(fd, BIOCSBLEN,
                            (caddr_t)&p->opt.buffer_size) < 0) {
                         */
                        if (ioctl(fd, BIOCSBLEN,
                            (caddr_t)&p->opt.buffer_size) < 0) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "BIOCSBLEN: %s: %s", p->opt.source,
                                    pcap_strerror(errno));
                                status = PCAP_ERROR;
                                    "BIOCSBLEN: %s: %s", p->opt.source,
                                    pcap_strerror(errno));
                                status = PCAP_ERROR;


@@ -1828,7 +1828,7 @@ pcap_activate_bpf(pcap_t *p)
                        }
 
                        if (v == 0) {
                        }
 
                        if (v == 0) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "BIOCSBLEN: %s: No buffer size worked",
                                    p->opt.source);
                                status = PCAP_ERROR;
                                    "BIOCSBLEN: %s: No buffer size worked",
                                    p->opt.source);
                                status = PCAP_ERROR;


@@ -1839,7 +1839,7 @@ pcap_activate_bpf(pcap_t *p)
 
        /* Get the data link layer type. */
        if (ioctl(fd, BIOCGDLT, (caddr_t)&v) < 0) {
 
        /* Get the data link layer type. */
        if (ioctl(fd, BIOCGDLT, (caddr_t)&v) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGDLT: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGDLT: %s",

                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -1872,7 +1872,7 @@ pcap_activate_bpf(pcap_t *p)
                /*
                 * We don't know what to map this to yet.
                 */
                /*
                 * We don't know what to map this to yet.
                 */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "unknown interface type %u",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "unknown interface type %u",

                    v);
                status = PCAP_ERROR;
                goto bad;
                    v);
                status = PCAP_ERROR;
                goto bad;


@@ -2084,7 +2084,7 @@ pcap_activate_bpf(pcap_t *p)
         * BSDs - check CVS log for "bpf.c"?
         */
        if (ioctl(fd, BIOCSHDRCMPLT, &spoof_eth_src) == -1) {
         * BSDs - check CVS log for "bpf.c"?
         */
        if (ioctl(fd, BIOCSHDRCMPLT, &spoof_eth_src) == -1) {

-               (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "BIOCSHDRCMPLT: %s", pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                    "BIOCSHDRCMPLT: %s", pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -2126,7 +2126,7 @@ pcap_activate_bpf(pcap_t *p)
                        bpf_to.tv_sec = p->opt.timeout / 1000;
                        bpf_to.tv_usec = (p->opt.timeout * 1000) % 1000000;
                        if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&bpf_to) < 0) {
                        bpf_to.tv_sec = p->opt.timeout / 1000;
                        bpf_to.tv_usec = (p->opt.timeout * 1000) % 1000000;
                        if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&bpf_to) < 0) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "BIOCSRTIMEOUT: %s", pcap_strerror(errno));
                                status = PCAP_ERROR;
                                goto bad;
                                    "BIOCSRTIMEOUT: %s", pcap_strerror(errno));
                                status = PCAP_ERROR;
                                goto bad;


@@ -2136,7 +2136,7 @@ pcap_activate_bpf(pcap_t *p)
                        to.tv_sec = p->opt.timeout / 1000;
                        to.tv_usec = (p->opt.timeout * 1000) % 1000000;
                        if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&to) < 0) {
                        to.tv_sec = p->opt.timeout / 1000;
                        to.tv_usec = (p->opt.timeout * 1000) % 1000000;
                        if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&to) < 0) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "BIOCSRTIMEOUT: %s", pcap_strerror(errno));
                                status = PCAP_ERROR;
                                goto bad;
                                    "BIOCSRTIMEOUT: %s", pcap_strerror(errno));
                                status = PCAP_ERROR;
                                goto bad;


@@ -2171,7 +2171,7 @@ pcap_activate_bpf(pcap_t *p)
 #endif /* _AIX */
                v = 1;
                if (ioctl(p->fd, BIOCIMMEDIATE, &v) < 0) {
 #endif /* _AIX */
                v = 1;
                if (ioctl(p->fd, BIOCIMMEDIATE, &v) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "BIOCIMMEDIATE: %s", pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;
                            "BIOCIMMEDIATE: %s", pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto bad;


@@ -2184,7 +2184,7 @@ pcap_activate_bpf(pcap_t *p)
                /*
                 * We don't support immediate mode.  Fail.
                 */
                /*
                 * We don't support immediate mode.  Fail.
                 */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Immediate mode not supported");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Immediate mode not supported");

                status = PCAP_ERROR;
                goto bad;
        }
                status = PCAP_ERROR;
                goto bad;
        }


@@ -2193,14 +2193,14 @@ pcap_activate_bpf(pcap_t *p)
        if (p->opt.promisc) {
                /* set promiscuous mode, just warn if it fails */
                if (ioctl(p->fd, BIOCPROMISC, NULL) < 0) {
        if (p->opt.promisc) {
                /* set promiscuous mode, just warn if it fails */
                if (ioctl(p->fd, BIOCPROMISC, NULL) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCPROMISC: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCPROMISC: %s",

                            pcap_strerror(errno));
                        status = PCAP_WARNING_PROMISC_NOTSUP;
                }
        }
 
        if (ioctl(fd, BIOCGBLEN, (caddr_t)&v) < 0) {
                            pcap_strerror(errno));
                        status = PCAP_WARNING_PROMISC_NOTSUP;
                }
        }
 
        if (ioctl(fd, BIOCGBLEN, (caddr_t)&v) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGBLEN: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGBLEN: %s",

                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -2211,7 +2211,7 @@ pcap_activate_bpf(pcap_t *p)
 #endif
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {
 #endif
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -2242,7 +2242,7 @@ pcap_activate_bpf(pcap_t *p)
        total_prog.bf_len = 1;
        total_prog.bf_insns = &total_insn;
        if (ioctl(p->fd, BIOCSETF, (caddr_t)&total_prog) < 0) {
        total_prog.bf_len = 1;
        total_prog.bf_insns = &total_insn;
        if (ioctl(p->fd, BIOCSETF, (caddr_t)&total_prog) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETF: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETF: %s",

                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;
                    pcap_strerror(errno));
                status = PCAP_ERROR;
                goto bad;


@@ -2332,7 +2332,7 @@ monitor_mode(pcap_t *p, int set)
 
        sock = socket(AF_INET, SOCK_DGRAM, 0);
        if (sock == -1) {
 
        sock = socket(AF_INET, SOCK_DGRAM, 0);
        if (sock == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "can't open socket: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "can't open socket: %s",

                    pcap_strerror(errno));
                return (PCAP_ERROR);
        }
                    pcap_strerror(errno));
                return (PCAP_ERROR);
        }


@@ -2364,7 +2364,7 @@ monitor_mode(pcap_t *p, int set)
                        return (PCAP_ERROR_RFMON_NOTSUP);
 
                default:
                        return (PCAP_ERROR_RFMON_NOTSUP);
 
                default:

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "SIOCGIFMEDIA 1: %s", pcap_strerror(errno));
                        close(sock);
                        return (PCAP_ERROR);
                            "SIOCGIFMEDIA 1: %s", pcap_strerror(errno));
                        close(sock);
                        return (PCAP_ERROR);


@@ -2384,14 +2384,14 @@ monitor_mode(pcap_t *p, int set)
         */
        media_list = malloc(req.ifm_count * sizeof(int));
        if (media_list == NULL) {
         */
        media_list = malloc(req.ifm_count * sizeof(int));
        if (media_list == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                close(sock);
                return (PCAP_ERROR);
        }
        req.ifm_ulist = media_list;
        if (ioctl(sock, SIOCGIFMEDIA, &req) < 0) {
                    pcap_strerror(errno));
                close(sock);
                return (PCAP_ERROR);
        }
        req.ifm_ulist = media_list;
        if (ioctl(sock, SIOCGIFMEDIA, &req) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCGIFMEDIA: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCGIFMEDIA: %s",

                    pcap_strerror(errno));
                free(media_list);
                close(sock);
                    pcap_strerror(errno));
                free(media_list);
                close(sock);


@@ -2444,7 +2444,7 @@ monitor_mode(pcap_t *p, int set)
                                 * "atexit()" failed; don't put the interface
                                 * in monitor mode, just give up.
                                 */
                                 * "atexit()" failed; don't put the interface
                                 * in monitor mode, just give up.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                     "atexit failed");
                                close(sock);
                                return (PCAP_ERROR);
                                     "atexit failed");
                                close(sock);
                                return (PCAP_ERROR);


@@ -2454,7 +2454,7 @@ monitor_mode(pcap_t *p, int set)
                            sizeof(ifr.ifr_name));
                        ifr.ifr_media = req.ifm_current | IFM_IEEE80211_MONITOR;
                        if (ioctl(sock, SIOCSIFMEDIA, &ifr) == -1) {
                            sizeof(ifr.ifr_name));
                        ifr.ifr_media = req.ifm_current | IFM_IEEE80211_MONITOR;
                        if (ioctl(sock, SIOCSIFMEDIA, &ifr) == -1) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                     "SIOCSIFMEDIA: %s", pcap_strerror(errno));
                                close(sock);
                                return (PCAP_ERROR);
                                     "SIOCSIFMEDIA: %s", pcap_strerror(errno));
                                close(sock);
                                return (PCAP_ERROR);


@@ -2679,7 +2679,7 @@ pcap_setfilter_bpf(pcap_t *p, struct bpf_program *fp)
         * some kernels.
         */
        if (errno != EINVAL) {
         * some kernels.
         */
        if (errno != EINVAL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETF: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETF: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -2708,7 +2708,7 @@ pcap_setdirection_bpf(pcap_t *p, pcap_direction_t d)
        direction = (d == PCAP_D_IN) ? BPF_D_IN :
            ((d == PCAP_D_OUT) ? BPF_D_OUT : BPF_D_INOUT);
        if (ioctl(p->fd, BIOCSDIRECTION, &direction) == -1) {
        direction = (d == PCAP_D_IN) ? BPF_D_IN :
            ((d == PCAP_D_OUT) ? BPF_D_OUT : BPF_D_INOUT);
        if (ioctl(p->fd, BIOCSDIRECTION, &direction) == -1) {

-               (void) snprintf(p->errbuf, sizeof(p->errbuf),
+               (void) pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "Cannot set direction to %s: %s",
                        (d == PCAP_D_IN) ? "PCAP_D_IN" :
                        ((d == PCAP_D_OUT) ? "PCAP_D_OUT" : "PCAP_D_INOUT"),
                    "Cannot set direction to %s: %s",
                        (d == PCAP_D_IN) ? "PCAP_D_IN" :
                        ((d == PCAP_D_OUT) ? "PCAP_D_OUT" : "PCAP_D_INOUT"),


@@ -2723,14 +2723,14 @@ pcap_setdirection_bpf(pcap_t *p, pcap_direction_t d)
         * We don't support PCAP_D_OUT.
         */
        if (d == PCAP_D_OUT) {
         * We don't support PCAP_D_OUT.
         */
        if (d == PCAP_D_OUT) {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "Setting direction to PCAP_D_OUT is not supported on BPF");
                return -1;
        }
 
        seesent = (d == PCAP_D_INOUT);
        if (ioctl(p->fd, BIOCSSEESENT, &seesent) == -1) {
                    "Setting direction to PCAP_D_OUT is not supported on BPF");
                return -1;
        }
 
        seesent = (d == PCAP_D_INOUT);
        if (ioctl(p->fd, BIOCSSEESENT, &seesent) == -1) {

-               (void) snprintf(p->errbuf, sizeof(p->errbuf),
+               (void) pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "Cannot set direction to %s: %s",
                        (d == PCAP_D_INOUT) ? "PCAP_D_INOUT" : "PCAP_D_IN",
                        strerror(errno));
                    "Cannot set direction to %s: %s",
                        (d == PCAP_D_INOUT) ? "PCAP_D_INOUT" : "PCAP_D_IN",
                        strerror(errno));


@@ -2738,7 +2738,7 @@ pcap_setdirection_bpf(pcap_t *p, pcap_direction_t d)
        }
        return (0);
 #else
        }
        return (0);
 #else

-       (void) snprintf(p->errbuf, sizeof(p->errbuf),
+       (void) pcap_snprintf(p->errbuf, sizeof(p->errbuf),

            "This system doesn't support BIOCSSEESENT, so the direction can't be set");
        return (-1);
 #endif
            "This system doesn't support BIOCSSEESENT, so the direction can't be set");
        return (-1);
 #endif


@@ -2749,7 +2749,7 @@ pcap_set_datalink_bpf(pcap_t *p, int dlt)
 {
 #ifdef BIOCSDLT
        if (ioctl(p->fd, BIOCSDLT, &dlt) == -1) {
 {
 #ifdef BIOCSDLT
        if (ioctl(p->fd, BIOCSDLT, &dlt) == -1) {

-               (void) snprintf(p->errbuf, sizeof(p->errbuf),
+               (void) pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "Cannot set DLT %d: %s", dlt, strerror(errno));
                return (-1);
        }
                    "Cannot set DLT %d: %s", dlt, strerror(errno));
                return (-1);
        }

diff --git a/pcap-bt-linux.c b/pcap-bt-linux.c
index b7e01f914d5ef7593c18877604aaeab07c5cc78d..a398b267d4f0e4ddb6c32407d8fa119c63e91c2e 100644 (file)
--- a/pcap-bt-linux.c
+++ b/pcap-bt-linux.c
@@ -87,7 +87,7 @@ bt_findalldevs(pcap_if_t **alldevsp, char *err_str)
                /* if bluetooth is not supported this this is not fatal*/
                if (errno == EAFNOSUPPORT)
                        return 0;
                /* if bluetooth is not supported this this is not fatal*/
                if (errno == EAFNOSUPPORT)
                        return 0;

-               snprintf(err_str, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(err_str, PCAP_ERRBUF_SIZE,

                    "Can't open raw Bluetooth socket: %s", strerror(errno));
                return -1;
        }
                    "Can't open raw Bluetooth socket: %s", strerror(errno));
                return -1;
        }


@@ -95,7 +95,7 @@ bt_findalldevs(pcap_if_t **alldevsp, char *err_str)
        dev_list = malloc(HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
        if (!dev_list)
        {
        dev_list = malloc(HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
        if (!dev_list)
        {

-               snprintf(err_str, PCAP_ERRBUF_SIZE, "Can't allocate %zu bytes for Bluetooth device list",
+               pcap_snprintf(err_str, PCAP_ERRBUF_SIZE, "Can't allocate %zu bytes for Bluetooth device list",

                        HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
                ret = -1;
                goto done;
                        HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
                ret = -1;
                goto done;


@@ -105,7 +105,7 @@ bt_findalldevs(pcap_if_t **alldevsp, char *err_str)
 
        if (ioctl(sock, HCIGETDEVLIST, (void *) dev_list) < 0)
        {
 
        if (ioctl(sock, HCIGETDEVLIST, (void *) dev_list) < 0)
        {

-               snprintf(err_str, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(err_str, PCAP_ERRBUF_SIZE,

                    "Can't get Bluetooth device list via ioctl: %s",
                    strerror(errno));
                ret = -1;
                    "Can't get Bluetooth device list via ioctl: %s",
                    strerror(errno));
                ret = -1;


@@ -116,8 +116,8 @@ bt_findalldevs(pcap_if_t **alldevsp, char *err_str)
        for (i = 0; i < dev_list->dev_num; i++, dev_req++) {
                char dev_name[20], dev_descr[30];
 
        for (i = 0; i < dev_list->dev_num; i++, dev_req++) {
                char dev_name[20], dev_descr[30];
 

-               snprintf(dev_name, 20, BT_IFACE"%d", dev_req->dev_id);
-               snprintf(dev_descr, 30, "Bluetooth adapter number %d", i);
+               pcap_snprintf(dev_name, 20, BT_IFACE"%d", dev_req->dev_id);
+               pcap_snprintf(dev_descr, 30, "Bluetooth adapter number %d", i);

 
                if (pcap_add_if(alldevsp, dev_name, 0,
                       dev_descr, err_str) < 0)
 
                if (pcap_add_if(alldevsp, dev_name, 0,
                       dev_descr, err_str) < 0)


@@ -192,7 +192,7 @@ bt_activate(pcap_t* handle)
        /* get bt interface id */
        if (sscanf(handle->opt.source, BT_IFACE"%d", &dev_id) != 1)
        {
        /* get bt interface id */
        if (sscanf(handle->opt.source, BT_IFACE"%d", &dev_id) != 1)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "Can't get Bluetooth device index from %s",
                         handle->opt.source);
                return PCAP_ERROR;
                        "Can't get Bluetooth device index from %s",
                         handle->opt.source);
                return PCAP_ERROR;


@@ -215,28 +215,28 @@ bt_activate(pcap_t* handle)
        /* Create HCI socket */
        handle->fd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
        if (handle->fd < 0) {
        /* Create HCI socket */
        handle->fd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
        if (handle->fd < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't create raw socket: %s", strerror(errno));
                return PCAP_ERROR;
        }
 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {
                    "Can't create raw socket: %s", strerror(errno));
                return PCAP_ERROR;
        }
 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s",

                        pcap_strerror(errno));
                goto close_fail;
        }
 
        opt = 1;
        if (setsockopt(handle->fd, SOL_HCI, HCI_DATA_DIR, &opt, sizeof(opt)) < 0) {
                        pcap_strerror(errno));
                goto close_fail;
        }
 
        opt = 1;
        if (setsockopt(handle->fd, SOL_HCI, HCI_DATA_DIR, &opt, sizeof(opt)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't enable data direction info: %s", strerror(errno));
                goto close_fail;
        }
 
        opt = 1;
        if (setsockopt(handle->fd, SOL_HCI, HCI_TIME_STAMP, &opt, sizeof(opt)) < 0) {
                    "Can't enable data direction info: %s", strerror(errno));
                goto close_fail;
        }
 
        opt = 1;
        if (setsockopt(handle->fd, SOL_HCI, HCI_TIME_STAMP, &opt, sizeof(opt)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't enable time stamp: %s", strerror(errno));
                goto close_fail;
        }
                    "Can't enable time stamp: %s", strerror(errno));
                goto close_fail;
        }


@@ -247,7 +247,7 @@ bt_activate(pcap_t* handle)
        memset((void *) &flt.type_mask, 0xff, sizeof(flt.type_mask));
        memset((void *) &flt.event_mask, 0xff, sizeof(flt.event_mask));
        if (setsockopt(handle->fd, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {
        memset((void *) &flt.type_mask, 0xff, sizeof(flt.type_mask));
        memset((void *) &flt.event_mask, 0xff, sizeof(flt.event_mask));
        if (setsockopt(handle->fd, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't set filter: %s", strerror(errno));
                goto close_fail;
        }
                    "Can't set filter: %s", strerror(errno));
                goto close_fail;
        }


@@ -260,7 +260,7 @@ bt_activate(pcap_t* handle)
        addr.hci_channel = HCI_CHANNEL_RAW;
 #endif
        if (bind(handle->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        addr.hci_channel = HCI_CHANNEL_RAW;
 #endif
        if (bind(handle->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't attach to device %d: %s", handlep->dev_id,
                    strerror(errno));
                goto close_fail;
                    "Can't attach to device %d: %s", handlep->dev_id,
                    strerror(errno));
                goto close_fail;


@@ -281,7 +281,7 @@ bt_activate(pcap_t* handle)
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF,
                    &handle->opt.buffer_size,
                    sizeof(handle->opt.buffer_size)) == -1) {
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF,
                    &handle->opt.buffer_size,
                    sizeof(handle->opt.buffer_size)) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                 "SO_RCVBUF: %s", pcap_strerror(errno));
                        goto close_fail;
                }
                                 "SO_RCVBUF: %s", pcap_strerror(errno));
                        goto close_fail;
                }


@@ -329,7 +329,7 @@ bt_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *us
        } while ((ret == -1) && (errno == EINTR));
 
        if (ret < 0) {
        } while ((ret == -1) && (errno == EINTR));
 
        if (ret < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't receive packet: %s", strerror(errno));
                return -1;
        }
                    "Can't receive packet: %s", strerror(errno));
                return -1;
        }


@@ -368,7 +368,7 @@ bt_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *us
 static int
 bt_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
 static int
 bt_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on "
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on "

                "bluetooth devices");
        return (-1);
 }
                "bluetooth devices");
        return (-1);
 }


@@ -389,7 +389,7 @@ bt_stats_linux(pcap_t *handle, struct pcap_stat *stats)
        } while ((ret == -1) && (errno == EINTR));
 
        if (ret < 0) {
        } while ((ret == -1) && (errno == EINTR));
 
        if (ret < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't get stats via ioctl: %s", strerror(errno));
                return (-1);
 
                    "Can't get stats via ioctl: %s", strerror(errno));
                return (-1);
 

diff --git a/pcap-bt-monitor-linux.c b/pcap-bt-monitor-linux.c
index b73d08b82c5726175ca7ea35feb6dcf1488c8e7a..1afbf5345cbb00a41169bf29b2710cc3cccc135f 100644 (file)
--- a/pcap-bt-monitor-linux.c
+++ b/pcap-bt-monitor-linux.c
@@ -110,7 +110,7 @@ bt_monitor_read(pcap_t *handle, int max_packets _U_, pcap_handler callback, u_ch
     } while ((ret == -1) && (errno == EINTR));
 
     if (ret < 0) {
     } while ((ret == -1) && (errno == EINTR));
 
     if (ret < 0) {

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

             "Can't receive packet: %s", strerror(errno));
         return -1;
     }
             "Can't receive packet: %s", strerror(errno));
         return -1;
     }


@@ -140,7 +140,7 @@ bt_monitor_read(pcap_t *handle, int max_packets _U_, pcap_handler callback, u_ch
 static int
 bt_monitor_inject(pcap_t *handle, const void *buf _U_, size_t size _U_)
 {
 static int
 bt_monitor_inject(pcap_t *handle, const void *buf _U_, size_t size _U_)
 {

-    snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported yet");
+    pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported yet");

     return -1;
 }
 
     return -1;
 }
 


@@ -187,14 +187,14 @@ bt_monitor_activate(pcap_t* handle)
 
     handle->fd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
     if (handle->fd < 0) {
 
     handle->fd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
     if (handle->fd < 0) {

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

             "Can't create raw socket: %s", strerror(errno));
         return PCAP_ERROR;
     }
 
     handle->buffer = malloc(handle->bufsize);
     if (!handle->buffer) {
             "Can't create raw socket: %s", strerror(errno));
         return PCAP_ERROR;
     }
 
     handle->buffer = malloc(handle->bufsize);
     if (!handle->buffer) {

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s",
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s",

             pcap_strerror(errno));
         goto close_fail;
     }
             pcap_strerror(errno));
         goto close_fail;
     }


@@ -205,14 +205,14 @@ bt_monitor_activate(pcap_t* handle)
     addr.hci_channel = HCI_CHANNEL_MONITOR;
 
     if (bind(handle->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
     addr.hci_channel = HCI_CHANNEL_MONITOR;
 
     if (bind(handle->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

             "Can't attach to interface: %s", strerror(errno));
         goto close_fail;
     }
 
     opt = 1;
     if (setsockopt(handle->fd, SOL_SOCKET, SO_TIMESTAMP, &opt, sizeof(opt)) < 0) {
             "Can't attach to interface: %s", strerror(errno));
         goto close_fail;
     }
 
     opt = 1;
     if (setsockopt(handle->fd, SOL_SOCKET, SO_TIMESTAMP, &opt, sizeof(opt)) < 0) {

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

             "Can't enable time stamp: %s", strerror(errno));
         goto close_fail;
     }
             "Can't enable time stamp: %s", strerror(errno));
         goto close_fail;
     }

diff --git a/pcap-can-linux.c b/pcap-can-linux.c
index 4db8ecdb51509d82e892d6b7090c176c9063f370..b4e2a0083541566592968bd9384ba9c805904d87 100644 (file)
--- a/pcap-can-linux.c
+++ b/pcap-can-linux.c
@@ -165,7 +165,7 @@ can_activate(pcap_t* handle)
        handle->fd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
        if (handle->fd < 0)
        {
        handle->fd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
        if (handle->fd < 0)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't create raw socket %d:%s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't create raw socket %d:%s",

                        errno, strerror(errno));
                return PCAP_ERROR;
        }
                        errno, strerror(errno));
                return PCAP_ERROR;
        }


@@ -175,7 +175,7 @@ can_activate(pcap_t* handle)
        strlcpy(ifr.ifr_name, handle->opt.source, sizeof(ifr.ifr_name));
        if (ioctl(handle->fd, SIOCGIFINDEX, &ifr) < 0)
        {
        strlcpy(ifr.ifr_name, handle->opt.source, sizeof(ifr.ifr_name));
        if (ioctl(handle->fd, SIOCGIFINDEX, &ifr) < 0)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "Unable to get interface index: %s",
                        pcap_strerror(errno));
                pcap_cleanup_live_common(handle);
                                "Unable to get interface index: %s",
                        pcap_strerror(errno));
                pcap_cleanup_live_common(handle);


@@ -187,7 +187,7 @@ can_activate(pcap_t* handle)
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer)
        {
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s",

                        pcap_strerror(errno));
                pcap_cleanup_live_common(handle);
                return PCAP_ERROR;
                        pcap_strerror(errno));
                pcap_cleanup_live_common(handle);
                return PCAP_ERROR;


@@ -198,7 +198,7 @@ can_activate(pcap_t* handle)
        addr.can_ifindex = handlep->ifindex;
        if( bind( handle->fd, (struct sockaddr*)&addr, sizeof(addr) ) < 0  )
        {
        addr.can_ifindex = handlep->ifindex;
        if( bind( handle->fd, (struct sockaddr*)&addr, sizeof(addr) ) < 0  )
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't attach to device %d %d:%s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't attach to device %d %d:%s",

                        handlep->ifindex, errno, strerror(errno));
                pcap_cleanup_live_common(handle);
                return PCAP_ERROR;
                        handlep->ifindex, errno, strerror(errno));
                pcap_cleanup_live_common(handle);
                return PCAP_ERROR;


@@ -248,7 +248,7 @@ can_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
 
        if (pkth.caplen == -1)
        {
 
        if (pkth.caplen == -1)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't receive packet %d:%s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't receive packet %d:%s",

                        errno, strerror(errno));
                return -1;
        }
                        errno, strerror(errno));
                return -1;
        }


@@ -262,7 +262,7 @@ can_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
 
        if( -1 == gettimeofday(&pkth.ts, NULL) )
        {
 
        if( -1 == gettimeofday(&pkth.ts, NULL) )
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't get time of day %d:%s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't get time of day %d:%s",

                        errno, strerror(errno));
                return -1;
        }
                        errno, strerror(errno));
                return -1;
        }


@@ -277,7 +277,7 @@ static int
 can_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
        /* not yet implemented */
 can_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
        /* not yet implemented */

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on "
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on "

                "can devices");
        return (-1);
 }
                "can devices");
        return (-1);
 }


@@ -308,7 +308,7 @@ can_setdirection_linux(pcap_t *p, pcap_direction_t d)
        /* no support for PCAP_D_OUT */
        if (d == PCAP_D_OUT)
        {
        /* no support for PCAP_D_OUT */
        if (d == PCAP_D_OUT)
        {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                        "Setting direction to PCAP_D_OUT is not supported on can");
                return -1;
        }
                        "Setting direction to PCAP_D_OUT is not supported on can");
                return -1;
        }

diff --git a/pcap-canusb-linux.c b/pcap-canusb-linux.c
index 4c51d63dfdf7859f74c372670f854a2efa7b7051..fb5b669fd2137ae2be70c9730564ccec7fb08666 100644 (file)
--- a/pcap-canusb-linux.c
+++ b/pcap-canusb-linux.c
@@ -127,8 +127,8 @@ int canusb_findalldevs(pcap_if_t **alldevsp, char *err_str)
             int n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,sernum,64);
             sernum[n] = 0;
 
             int n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,sernum,64);
             sernum[n] = 0;
 

-            snprintf(dev_name, 30, CANUSB_IFACE"%s", sernum);
-            snprintf(dev_descr, 50, "CanUSB [%s]", sernum);
+            pcap_snprintf(dev_name, 30, CANUSB_IFACE"%s", sernum);
+            pcap_snprintf(dev_descr, 50, "CanUSB [%s]", sernum);

 
             libusb_close(dh);
 
 
             libusb_close(dh);
 


@@ -351,7 +351,7 @@ static int canusb_activate(pcap_t* handle)
         /*
          * XXX - what causes this to fail?
          */
         /*
          * XXX - what causes this to fail?
          */

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "libusb_init() failed");
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "libusb_init() failed");

         return PCAP_ERROR;
     }
 
         return PCAP_ERROR;
     }
 


@@ -377,7 +377,7 @@ static int canusb_activate(pcap_t* handle)
     if (!canusb->dev)
     {
         libusb_exit(canusb->ctx);
     if (!canusb->dev)
     {
         libusb_exit(canusb->ctx);

-        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't open USB Device");
+        pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't open USB Device");

         return PCAP_ERROR;
     }
 
         return PCAP_ERROR;
     }
 


@@ -434,7 +434,7 @@ static int
 canusb_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
     /* not yet implemented */
 canusb_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
     /* not yet implemented */

-    snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on canusb devices");
+    pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on canusb devices");

     return (-1);
 }
 
     return (-1);
 }
 


@@ -464,7 +464,7 @@ canusb_setdirection_linux(pcap_t *p, pcap_direction_t d)
     /* no support for PCAP_D_OUT */
     if (d == PCAP_D_OUT)
     {
     /* no support for PCAP_D_OUT */
     if (d == PCAP_D_OUT)
     {

-        snprintf(p->errbuf, sizeof(p->errbuf),
+        pcap_snprintf(p->errbuf, sizeof(p->errbuf),

             "Setting direction to PCAP_D_OUT is not supported on this interface");
         return -1;
     }
             "Setting direction to PCAP_D_OUT is not supported on this interface");
         return -1;
     }

diff --git a/pcap-dag.c b/pcap-dag.c
index a363c4ccefefd656c7bfc5e969fbf2dae3049173..6a53ed86e2a837469747c43e4901bd7a4cfa9a8c 100644 (file)
--- a/pcap-dag.c
+++ b/pcap-dag.c
@@ -642,7 +642,7 @@ static int dag_activate(pcap_t* handle)
 #endif
 
        if (device == NULL) {
 #endif
 
        if (device == NULL) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));

                return -1;
        }
 
                return -1;
        }
 


@@ -651,26 +651,26 @@ static int dag_activate(pcap_t* handle)
 #ifdef HAVE_DAG_STREAMS_API
        newDev = (char *)malloc(strlen(device) + 16);
        if (newDev == NULL) {
 #ifdef HAVE_DAG_STREAMS_API
        newDev = (char *)malloc(strlen(device) + 16);
        if (newDev == NULL) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s\n", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s\n", pcap_strerror(errno));

                goto fail;
        }
 
        /* Parse input name to get dag device and stream number if provided */
        if (dag_parse_name(device, newDev, strlen(device) + 16, &handlep->dag_stream) < 0) {
                goto fail;
        }
 
        /* Parse input name to get dag device and stream number if provided */
        if (dag_parse_name(device, newDev, strlen(device) + 16, &handlep->dag_stream) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: %s\n", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: %s\n", pcap_strerror(errno));

                goto fail;
        }
        device = newDev;
 
        if (handlep->dag_stream%2) {
                goto fail;
        }
        device = newDev;
 
        if (handlep->dag_stream%2) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: tx (even numbered) streams not supported for capture\n");
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: tx (even numbered) streams not supported for capture\n");

                goto fail;
        }
 #else
        if (strncmp(device, "/dev/", 5) != 0) {
                newDev = (char *)malloc(strlen(device) + 5);
                if (newDev == NULL) {
                goto fail;
        }
 #else
        if (strncmp(device, "/dev/", 5) != 0) {
                newDev = (char *)malloc(strlen(device) + 5);
                if (newDev == NULL) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s\n", pcap_strerror(errno));
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s\n", pcap_strerror(errno));

                        goto fail;
                }
                strcpy(newDev, "/dev/");
                        goto fail;
                }
                strcpy(newDev, "/dev/");


@@ -681,14 +681,14 @@ static int dag_activate(pcap_t* handle)
 
        /* setup device parameters */
        if((handle->fd = dag_open((char *)device)) < 0) {
 
        /* setup device parameters */
        if((handle->fd = dag_open((char *)device)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_open %s: %s", device, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_open %s: %s", device, pcap_strerror(errno));

                goto fail;
        }
 
 #ifdef HAVE_DAG_STREAMS_API
        /* Open requested stream. Can fail if already locked or on error */
        if (dag_attach_stream(handle->fd, handlep->dag_stream, 0, 0) < 0) {
                goto fail;
        }
 
 #ifdef HAVE_DAG_STREAMS_API
        /* Open requested stream. Can fail if already locked or on error */
        if (dag_attach_stream(handle->fd, handlep->dag_stream, 0, 0) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s\n", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s\n", pcap_strerror(errno));

                goto failclose;
        }
 
                goto failclose;
        }
 


@@ -697,7 +697,7 @@ static int dag_activate(pcap_t* handle)
         */
        if (dag_get_stream_poll(handle->fd, handlep->dag_stream,
                                &mindata, &maxwait, &poll) < 0) {
         */
        if (dag_get_stream_poll(handle->fd, handlep->dag_stream,
                                &mindata, &maxwait, &poll) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s\n", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s\n", pcap_strerror(errno));

                goto faildetach;
        }
 
                goto faildetach;
        }
 


@@ -722,13 +722,13 @@ static int dag_activate(pcap_t* handle)
 
        if (dag_set_stream_poll(handle->fd, handlep->dag_stream,
                                mindata, &maxwait, &poll) < 0) {
 
        if (dag_set_stream_poll(handle->fd, handlep->dag_stream,
                                mindata, &maxwait, &poll) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s\n", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s\n", pcap_strerror(errno));

                goto faildetach;
        }
 
 #else
        if((handlep->dag_mem_base = dag_mmap(handle->fd)) == MAP_FAILED) {
                goto faildetach;
        }
 
 #else
        if((handlep->dag_mem_base = dag_mmap(handle->fd)) == MAP_FAILED) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_mmap %s: %s\n", device, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_mmap %s: %s\n", device, pcap_strerror(errno));

                goto failclose;
        }
 
                goto failclose;
        }
 


@@ -748,22 +748,22 @@ static int dag_activate(pcap_t* handle)
                handle->snapshot = MIN_DAG_SNAPLEN;
        }
        /* snap len has to be a multiple of 4 */
                handle->snapshot = MIN_DAG_SNAPLEN;
        }
        /* snap len has to be a multiple of 4 */

-       snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3);
+       pcap_snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3);

 
        if(dag_configure(handle->fd, conf) < 0) {
 
        if(dag_configure(handle->fd, conf) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_configure %s: %s\n", device, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_configure %s: %s\n", device, pcap_strerror(errno));

                goto faildetach;
        }
 #endif
 
 #ifdef HAVE_DAG_STREAMS_API
        if(dag_start_stream(handle->fd, handlep->dag_stream) < 0) {
                goto faildetach;
        }
 #endif
 
 #ifdef HAVE_DAG_STREAMS_API
        if(dag_start_stream(handle->fd, handlep->dag_stream) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start_stream %s: %s\n", device, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start_stream %s: %s\n", device, pcap_strerror(errno));

                goto faildetach;
        }
 #else
        if(dag_start(handle->fd) < 0) {
                goto faildetach;
        }
 #else
        if(dag_start(handle->fd) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s\n", device, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s\n", device, pcap_strerror(errno));

                goto failclose;
        }
 #endif /* HAVE_DAG_STREAMS_API */
                goto failclose;
        }
 #endif /* HAVE_DAG_STREAMS_API */


@@ -798,7 +798,7 @@ static int dag_activate(pcap_t* handle)
                        if ((n = atoi(s)) == 0 || n == 16 || n == 32) {
                                handlep->dag_fcs_bits = n;
                        } else {
                        if ((n = atoi(s)) == 0 || n == 16 || n == 32) {
                                handlep->dag_fcs_bits = n;
                        } else {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "pcap_activate %s: bad ERF_FCS_BITS value (%d) in environment\n", device, n);
                                goto failstop;
                        }
                                        "pcap_activate %s: bad ERF_FCS_BITS value (%d) in environment\n", device, n);
                                goto failstop;
                        }


@@ -826,7 +826,7 @@ static int dag_activate(pcap_t* handle)
        handle->bufsize = 0;
 
        if (new_pcap_dag(handle) < 0) {
        handle->bufsize = 0;
 
        if (new_pcap_dag(handle) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "new_pcap_dag %s: %s\n", device, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "new_pcap_dag %s: %s\n", device, pcap_strerror(errno));

                goto failstop;
        }
 
                goto failstop;
        }
 


@@ -948,7 +948,7 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
        p->tstamp_precision_count = 2;
        p->tstamp_precision_list = malloc(2 * sizeof(u_int));
        if (p->tstamp_precision_list == NULL) {
        p->tstamp_precision_count = 2;
        p->tstamp_precision_list = malloc(2 * sizeof(u_int));
        if (p->tstamp_precision_list == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                pcap_close(p);
                return NULL;
                    pcap_strerror(errno));
                pcap_close(p);
                return NULL;


@@ -996,7 +996,7 @@ dag_findalldevs(pcap_if_t **devlistp, char *errbuf)
 
        /* Try all the DAGs 0-DAG_MAX_BOARDS */
        for (c = 0; c < DAG_MAX_BOARDS; c++) {
 
        /* Try all the DAGs 0-DAG_MAX_BOARDS */
        for (c = 0; c < DAG_MAX_BOARDS; c++) {

-               snprintf(name, 12, "dag%d", c);
+               pcap_snprintf(name, 12, "dag%d", c);

                if (-1 == dag_parse_name(name, dagname, DAGNAME_BUFSIZE, &dagstream))
                {
                        return -1;
                if (-1 == dag_parse_name(name, dagname, DAGNAME_BUFSIZE, &dagstream))
                {
                        return -1;


@@ -1019,7 +1019,7 @@ dag_findalldevs(pcap_if_t **devlistp, char *errbuf)
                                        if (0 == dag_attach_stream(dagfd, stream, 0, 0)) {
                                                dag_detach_stream(dagfd, stream);
 
                                        if (0 == dag_attach_stream(dagfd, stream, 0, 0)) {
                                                dag_detach_stream(dagfd, stream);
 

-                                               snprintf(name,  10, "dag%d:%d", c, stream);
+                                               pcap_snprintf(name,  10, "dag%d:%d", c, stream);

                                                if (pcap_add_if(devlistp, name, 0, description, errbuf) == -1) {
                                                        /*
                                                         * Failure.
                                                if (pcap_add_if(devlistp, name, 0, description, errbuf) == -1) {
                                                        /*
                                                         * Failure.


@@ -1095,7 +1095,7 @@ dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 
                if (dag_get_stream_poll(p->fd, pd->dag_stream,
                                        &mindata, &maxwait, &poll) < 0) {
 
                if (dag_get_stream_poll(p->fd, pd->dag_stream,
                                        &mindata, &maxwait, &poll) < 0) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s\n", pcap_strerror(errno));
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s\n", pcap_strerror(errno));

                        return -1;
                }
 
                        return -1;
                }
 


@@ -1110,7 +1110,7 @@ dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 
                if (dag_set_stream_poll(p->fd, pd->dag_stream,
                                        mindata, &maxwait, &poll) < 0) {
 
                if (dag_set_stream_poll(p->fd, pd->dag_stream,
                                        mindata, &maxwait, &poll) < 0) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s\n", pcap_strerror(errno));
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s\n", pcap_strerror(errno));

                        return -1;
                }
        }
                        return -1;
                }
        }


@@ -1133,7 +1133,7 @@ dag_get_datalink(pcap_t *p)
        memset(types, 0, 255);
 
        if (p->dlt_list == NULL && (p->dlt_list = malloc(255*sizeof(*(p->dlt_list)))) == NULL) {
        memset(types, 0, 255);
 
        if (p->dlt_list == NULL && (p->dlt_list = malloc(255*sizeof(*(p->dlt_list)))) == NULL) {

-               (void)snprintf(p->errbuf, sizeof(p->errbuf), "malloc: %s", pcap_strerror(errno));
+               (void)pcap_snprintf(p->errbuf, sizeof(p->errbuf), "malloc: %s", pcap_strerror(errno));

                return (-1);
        }
 
                return (-1);
        }
 


@@ -1142,7 +1142,7 @@ dag_get_datalink(pcap_t *p)
 #ifdef HAVE_DAG_GET_STREAM_ERF_TYPES
        /* Get list of possible ERF types for this card */
        if (dag_get_stream_erf_types(p->fd, pd->dag_stream, types, 255) < 0) {
 #ifdef HAVE_DAG_GET_STREAM_ERF_TYPES
        /* Get list of possible ERF types for this card */
        if (dag_get_stream_erf_types(p->fd, pd->dag_stream, types, 255) < 0) {

-               snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_stream_erf_types: %s", pcap_strerror(errno));
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_stream_erf_types: %s", pcap_strerror(errno));

                return (-1);
        }
 
                return (-1);
        }
 


@@ -1151,7 +1151,7 @@ dag_get_datalink(pcap_t *p)
 #elif defined HAVE_DAG_GET_ERF_TYPES
        /* Get list of possible ERF types for this card */
        if (dag_get_erf_types(p->fd, types, 255) < 0) {
 #elif defined HAVE_DAG_GET_ERF_TYPES
        /* Get list of possible ERF types for this card */
        if (dag_get_erf_types(p->fd, types, 255) < 0) {

-               snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_erf_types: %s", pcap_strerror(errno));
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_erf_types: %s", pcap_strerror(errno));

                return (-1);
        }
 
                return (-1);
        }
 

diff --git a/pcap-dbus.c b/pcap-dbus.c
index 09672f249bd5e4aa28ed7f4555468eeb0f1e38d0..0974f82b1e4f5f4fcb4023fdf3cf2c14b7d8ecf1 100644 (file)
--- a/pcap-dbus.c
+++ b/pcap-dbus.c
@@ -68,7 +68,7 @@ dbus_read(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
        while (!message) {
                /* XXX handle->opt.timeout = timeout_ms; */
                if (!dbus_connection_read_write(handlep->conn, 100)) {
        while (!message) {
                /* XXX handle->opt.timeout = timeout_ms; */
                if (!dbus_connection_read_write(handlep->conn, 100)) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Connection closed");
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Connection closed");

                        return -1;
                }
 
                        return -1;
                }
 


@@ -81,7 +81,7 @@ dbus_read(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
        }
 
        if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
        }
 
        if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Disconnected");
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Disconnected");

                return -1;
        }
 
                return -1;
        }
 


@@ -112,7 +112,7 @@ dbus_write(pcap_t *handle, const void *buf, size_t size)
        DBusMessage *msg;
 
        if (!(msg = dbus_message_demarshal(buf, size, &error))) {
        DBusMessage *msg;
 
        if (!(msg = dbus_message_demarshal(buf, size, &error))) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dbus_message_demarshal() failed: %s", error.message);
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dbus_message_demarshal() failed: %s", error.message);

                dbus_error_free(&error);
                return -1;
        }
                dbus_error_free(&error);
                return -1;
        }


@@ -167,14 +167,14 @@ dbus_activate(pcap_t *handle)
 
        if (strcmp(dev, "dbus-system") == 0) {
                if (!(handlep->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
 
        if (strcmp(dev, "dbus-system") == 0) {
                if (!(handlep->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get system bus: %s", error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get system bus: %s", error.message);

                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
        } else if (strcmp(dev, "dbus-session") == 0) {
                if (!(handlep->conn = dbus_bus_get(DBUS_BUS_SESSION, &error))) {
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
        } else if (strcmp(dev, "dbus-session") == 0) {
                if (!(handlep->conn = dbus_bus_get(DBUS_BUS_SESSION, &error))) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get session bus: %s", error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get session bus: %s", error.message);

                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }


@@ -183,19 +183,19 @@ dbus_activate(pcap_t *handle)
                const char *addr = dev + 7;
 
                if (!(handlep->conn = dbus_connection_open(addr, &error))) {
                const char *addr = dev + 7;
 
                if (!(handlep->conn = dbus_connection_open(addr, &error))) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to open connection to: %s: %s", addr, error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to open connection to: %s: %s", addr, error.message);

                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
                if (!dbus_bus_register(handlep->conn, &error)) {
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
                if (!dbus_bus_register(handlep->conn, &error)) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to register bus %s: %s\n", addr, error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to register bus %s: %s\n", addr, error.message);

                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
        } else {
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
        } else {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't get bus address from %s", handle->opt.source);
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't get bus address from %s", handle->opt.source);

                return PCAP_ERROR;
        }
 
                return PCAP_ERROR;
        }
 


@@ -234,7 +234,7 @@ dbus_activate(pcap_t *handle)
                        /* try without eavesdrop */
                        dbus_bus_add_match(handlep->conn, rules[i] + strlen(EAVESDROPPING_RULE), &error);
                        if (dbus_error_is_set(&error)) {
                        /* try without eavesdrop */
                        dbus_bus_add_match(handlep->conn, rules[i] + strlen(EAVESDROPPING_RULE), &error);
                        if (dbus_error_is_set(&error)) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to add bus match: %s\n", error.message);
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to add bus match: %s\n", error.message);

                                dbus_error_free(&error);
                                dbus_cleanup(handle);
                                return PCAP_ERROR;
                                dbus_error_free(&error);
                                dbus_cleanup(handle);
                                return PCAP_ERROR;

diff --git a/pcap-dlpi.c b/pcap-dlpi.c
index 254ca43bac8cdde8f91860c4467c6c05fe349d5d..c7abdb65d10c614f7b8a882f2c14fdfb99975db3 100644 (file)
--- a/pcap-dlpi.c
+++ b/pcap-dlpi.c
@@ -248,19 +248,19 @@ pcap_inject_dlpi(pcap_t *p, const void *buf, size_t size)
 #if defined(DLIOCRAW)
        ret = write(p->fd, buf, size);
        if (ret == -1) {
 #if defined(DLIOCRAW)
        ret = write(p->fd, buf, size);
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
 #elif defined(DL_HP_RAWDLS)
        if (pd->send_fd < 0) {
                    pcap_strerror(errno));
                return (-1);
        }
 #elif defined(DL_HP_RAWDLS)
        if (pd->send_fd < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "send: Output FD couldn't be opened");
                return (-1);
        }
        ret = dlrawdatareq(pd->send_fd, buf, size);
        if (ret == -1) {
                    "send: Output FD couldn't be opened");
                return (-1);
        }
        ret = dlrawdatareq(pd->send_fd, buf, size);
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -395,7 +395,7 @@ pcap_activate_dlpi(pcap_t *p)
                        status = PCAP_ERROR_PERM_DENIED;
                else
                        status = PCAP_ERROR;
                        status = PCAP_ERROR_PERM_DENIED;
                else
                        status = PCAP_ERROR;

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: %s", cp, pcap_strerror(errno));
                goto bad;
        }
                    "%s: %s", cp, pcap_strerror(errno));
                goto bad;
        }


@@ -434,7 +434,7 @@ pcap_activate_dlpi(pcap_t *p)
        if (*p->opt.source == '/')
                strlcpy(dname, p->opt.source, sizeof(dname));
        else
        if (*p->opt.source == '/')
                strlcpy(dname, p->opt.source, sizeof(dname));
        else

-               snprintf(dname, sizeof(dname), "%s/%s", PCAP_DEV_PREFIX,
+               pcap_snprintf(dname, sizeof(dname), "%s/%s", PCAP_DEV_PREFIX,

                    p->opt.source);
 
        /*
                    p->opt.source);
 
        /*


@@ -461,7 +461,7 @@ pcap_activate_dlpi(pcap_t *p)
                                status = PCAP_ERROR_PERM_DENIED;
                        else
                                status = PCAP_ERROR;
                                status = PCAP_ERROR_PERM_DENIED;
                        else
                                status = PCAP_ERROR;

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s", dname,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s", dname,

                            pcap_strerror(errno));
                        goto bad;
                }
                            pcap_strerror(errno));
                        goto bad;
                }


@@ -492,14 +492,14 @@ pcap_activate_dlpi(pcap_t *p)
                                 * for the loopback interface is just a
                                 * symptom of that inability.
                                 */
                                 * for the loopback interface is just a
                                 * symptom of that inability.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "%s: No DLPI device found", p->opt.source);
                        } else {
                                if (errno == EPERM || errno == EACCES)
                                        status = PCAP_ERROR_PERM_DENIED;
                                else
                                        status = PCAP_ERROR;
                                    "%s: No DLPI device found", p->opt.source);
                        } else {
                                if (errno == EPERM || errno == EACCES)
                                        status = PCAP_ERROR_PERM_DENIED;
                                else
                                        status = PCAP_ERROR;

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",

                                    dname2, pcap_strerror(errno));
                        }
                        goto bad;
                                    dname2, pcap_strerror(errno));
                        }
                        goto bad;


@@ -627,7 +627,7 @@ pcap_activate_dlpi(pcap_t *p)
                */
                if (strioctl(p->fd, A_PROMISCON_REQ, 0, NULL) < 0) {
                        status = PCAP_ERROR;
                */
                if (strioctl(p->fd, A_PROMISCON_REQ, 0, NULL) < 0) {
                        status = PCAP_ERROR;

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "A_PROMISCON_REQ: %s", pcap_strerror(errno));
                        goto bad;
                }
                            "A_PROMISCON_REQ: %s", pcap_strerror(errno));
                        goto bad;
                }


@@ -745,7 +745,7 @@ pcap_activate_dlpi(pcap_t *p)
        */
        if (strioctl(p->fd, DLIOCRAW, 0, NULL) < 0) {
                status = PCAP_ERROR;
        */
        if (strioctl(p->fd, DLIOCRAW, 0, NULL) < 0) {
                status = PCAP_ERROR;

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "DLIOCRAW: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "DLIOCRAW: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -766,7 +766,7 @@ pcap_activate_dlpi(pcap_t *p)
        release = get_release(&osmajor, &osminor, &osmicro);
        if (osmajor == 5 && (osminor <= 2 || (osminor == 3 && osmicro < 2)) &&
            getenv("BUFMOD_FIXED") == NULL) {
        release = get_release(&osmajor, &osminor, &osmicro);
        if (osmajor == 5 && (osminor <= 2 || (osminor == 3 && osmicro < 2)) &&
            getenv("BUFMOD_FIXED") == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                "WARNING: bufmod is broken in SunOS %s; ignoring snaplen.",
                    release);
                ss = 0;
                "WARNING: bufmod is broken in SunOS %s; ignoring snaplen.",
                    release);
                ss = 0;


@@ -786,7 +786,7 @@ pcap_activate_dlpi(pcap_t *p)
        */
        if (ioctl(p->fd, I_FLUSH, FLUSHR) != 0) {
                status = PCAP_ERROR;
        */
        if (ioctl(p->fd, I_FLUSH, FLUSHR) != 0) {
                status = PCAP_ERROR;

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "FLUSHR: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "FLUSHR: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -841,7 +841,7 @@ split_dname(char *device, int *unitp, char *ebuf)
         */
        cp = device + strlen(device) - 1;
        if (*cp < '0' || *cp > '9') {
         */
        cp = device + strlen(device) - 1;
        if (*cp < '0' || *cp > '9') {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s missing unit number",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s missing unit number",

                    device);
                return (NULL);
        }
                    device);
                return (NULL);
        }


@@ -853,16 +853,16 @@ split_dname(char *device, int *unitp, char *ebuf)
        errno = 0;
        unit = strtol(cp, &eos, 10);
        if (*eos != '\0') {
        errno = 0;
        unit = strtol(cp, &eos, 10);
        if (*eos != '\0') {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s bad unit number", device);
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s bad unit number", device);

                return (NULL);
        }
        if (errno == ERANGE || unit > INT_MAX) {
                return (NULL);
        }
        if (errno == ERANGE || unit > INT_MAX) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s unit number too large",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s unit number too large",

                    device);
                return (NULL);
        }
        if (unit < 0) {
                    device);
                return (NULL);
        }
        if (unit < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s unit number is negative",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "%s unit number is negative",

                    device);
                return (NULL);
        }
                    device);
                return (NULL);
        }


@@ -989,12 +989,12 @@ pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf)
        }
 
        if (strioctl(fd, A_GET_UNITS, sizeof(buf), (char *)&buf) < 0) {
        }
 
        if (strioctl(fd, A_GET_UNITS, sizeof(buf), (char *)&buf) < 0) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "A_GET_UNITS: %s",
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "A_GET_UNITS: %s",

                    pcap_strerror(errno));
                return (-1);
        }
        for (i = 0; i < buf.nunits; i++) {
                    pcap_strerror(errno));
                return (-1);
        }
        for (i = 0; i < buf.nunits; i++) {

-               snprintf(baname, sizeof baname, "ba%u", i);
+               pcap_snprintf(baname, sizeof baname, "ba%u", i);

                if (pcap_add_if(alldevsp, baname, 0, NULL, errbuf) < 0)
                        return (-1);
        }
                if (pcap_add_if(alldevsp, baname, 0, NULL, errbuf) < 0)
                        return (-1);
        }


@@ -1015,7 +1015,7 @@ send_request(int fd, char *ptr, int len, char *what, char *ebuf)
 
        flags = 0;
        if (putmsg(fd, &ctl, (struct strbuf *) NULL, flags) < 0) {
 
        flags = 0;
        if (putmsg(fd, &ctl, (struct strbuf *) NULL, flags) < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "send_request: putmsg \"%s\": %s",
                    what, pcap_strerror(errno));
                return (-1);
                    "send_request: putmsg \"%s\": %s",
                    what, pcap_strerror(errno));
                return (-1);


@@ -1043,7 +1043,7 @@ recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf, int *uerror
 
        flags = 0;
        if (getmsg(fd, &ctl, (struct strbuf*)NULL, &flags) < 0) {
 
        flags = 0;
        if (getmsg(fd, &ctl, (struct strbuf*)NULL, &flags) < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "recv_ack: %s getmsg: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "recv_ack: %s getmsg: %s",

                    what, pcap_strerror(errno));
                return (PCAP_ERROR);
        }
                    what, pcap_strerror(errno));
                return (PCAP_ERROR);
        }


@@ -1066,7 +1066,7 @@ recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf, int *uerror
                case DL_SYSERR:
                        if (uerror != NULL)
                                *uerror = dlp->error_ack.dl_unix_errno;
                case DL_SYSERR:
                        if (uerror != NULL)
                                *uerror = dlp->error_ack.dl_unix_errno;

-                       snprintf(ebuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                            "recv_ack: %s: UNIX error - %s",
                            what, pcap_strerror(dlp->error_ack.dl_unix_errno));
                        if (dlp->error_ack.dl_unix_errno == EPERM ||
                            "recv_ack: %s: UNIX error - %s",
                            what, pcap_strerror(dlp->error_ack.dl_unix_errno));
                        if (dlp->error_ack.dl_unix_errno == EPERM ||


@@ -1075,7 +1075,7 @@ recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf, int *uerror
                        break;
 
                default:
                        break;
 
                default:

-                       snprintf(ebuf, PCAP_ERRBUF_SIZE, "recv_ack: %s: %s",
+                       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "recv_ack: %s: %s",

                            what, dlstrerror(dlp->error_ack.dl_errno));
                        if (dlp->error_ack.dl_errno == DL_BADPPA)
                                return (PCAP_ERROR_NO_SUCH_DEVICE);
                            what, dlstrerror(dlp->error_ack.dl_errno));
                        if (dlp->error_ack.dl_errno == DL_BADPPA)
                                return (PCAP_ERROR_NO_SUCH_DEVICE);


@@ -1086,14 +1086,14 @@ recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf, int *uerror
                return (PCAP_ERROR);
 
        default:
                return (PCAP_ERROR);
 
        default:

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "recv_ack: %s: Unexpected primitive ack %s",
                    what, dlprim(dlp->dl_primitive));
                return (PCAP_ERROR);
        }
 
        if (ctl.len < size) {
                    "recv_ack: %s: Unexpected primitive ack %s",
                    what, dlprim(dlp->dl_primitive));
                return (PCAP_ERROR);
        }
 
        if (ctl.len < size) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "recv_ack: %s: Ack too small (%d < %d)",
                    what, ctl.len, size);
                return (PCAP_ERROR);
                    "recv_ack: %s: Ack too small (%d < %d)",
                    what, ctl.len, size);
                return (PCAP_ERROR);


@@ -1521,21 +1521,21 @@ get_dlpi_ppa(register int fd, register const char *device, register int unit,
         */
        /* get the head first */
        if (getmsg(fd, &ctl, (struct strbuf *)NULL, &flags) < 0) {
         */
        /* get the head first */
        if (getmsg(fd, &ctl, (struct strbuf *)NULL, &flags) < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "get_dlpi_ppa: hpppa getmsg: %s", pcap_strerror(errno));
                return (PCAP_ERROR);
        }
 
        dlp = (dl_hp_ppa_ack_t *)ctl.buf;
        if (dlp->dl_primitive != DL_HP_PPA_ACK) {
                    "get_dlpi_ppa: hpppa getmsg: %s", pcap_strerror(errno));
                return (PCAP_ERROR);
        }
 
        dlp = (dl_hp_ppa_ack_t *)ctl.buf;
        if (dlp->dl_primitive != DL_HP_PPA_ACK) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "get_dlpi_ppa: hpppa unexpected primitive ack 0x%x",
                    (bpf_u_int32)dlp->dl_primitive);
                return (PCAP_ERROR);
        }
 
        if (ctl.len < DL_HP_PPA_ACK_SIZE) {
                    "get_dlpi_ppa: hpppa unexpected primitive ack 0x%x",
                    (bpf_u_int32)dlp->dl_primitive);
                return (PCAP_ERROR);
        }
 
        if (ctl.len < DL_HP_PPA_ACK_SIZE) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "get_dlpi_ppa: hpppa ack too small (%d < %lu)",
                     ctl.len, (unsigned long)DL_HP_PPA_ACK_SIZE);
                return (PCAP_ERROR);
                    "get_dlpi_ppa: hpppa ack too small (%d < %lu)",
                     ctl.len, (unsigned long)DL_HP_PPA_ACK_SIZE);
                return (PCAP_ERROR);


@@ -1543,7 +1543,7 @@ get_dlpi_ppa(register int fd, register const char *device, register int unit,
 
        /* allocate buffer */
        if ((ppa_data_buf = (char *)malloc(dlp->dl_length)) == NULL) {
 
        /* allocate buffer */
        if ((ppa_data_buf = (char *)malloc(dlp->dl_length)) == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "get_dlpi_ppa: hpppa malloc: %s", pcap_strerror(errno));
                return (PCAP_ERROR);
        }
                    "get_dlpi_ppa: hpppa malloc: %s", pcap_strerror(errno));
                return (PCAP_ERROR);
        }


@@ -1552,13 +1552,13 @@ get_dlpi_ppa(register int fd, register const char *device, register int unit,
        ctl.buf = (char *)ppa_data_buf;
        /* get the data */
        if (getmsg(fd, &ctl, (struct strbuf *)NULL, &flags) < 0) {
        ctl.buf = (char *)ppa_data_buf;
        /* get the data */
        if (getmsg(fd, &ctl, (struct strbuf *)NULL, &flags) < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "get_dlpi_ppa: hpppa getmsg: %s", pcap_strerror(errno));
                free(ppa_data_buf);
                return (PCAP_ERROR);
        }
        if (ctl.len < dlp->dl_length) {
                    "get_dlpi_ppa: hpppa getmsg: %s", pcap_strerror(errno));
                free(ppa_data_buf);
                return (PCAP_ERROR);
        }
        if (ctl.len < dlp->dl_length) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "get_dlpi_ppa: hpppa ack too small (%d < %lu)",
                    ctl.len, (unsigned long)dlp->dl_length);
                free(ppa_data_buf);
                    "get_dlpi_ppa: hpppa ack too small (%d < %lu)",
                    ctl.len, (unsigned long)dlp->dl_length);
                free(ppa_data_buf);


@@ -1615,9 +1615,9 @@ get_dlpi_ppa(register int fd, register const char *device, register int unit,
                 * device number of a device with the name "/dev/<dev><unit>",
                 * if such a device exists, as the old code did.
                 */
                 * device number of a device with the name "/dev/<dev><unit>",
                 * if such a device exists, as the old code did.
                 */

-               snprintf(dname, sizeof(dname), "/dev/%s%d", device, unit);
+               pcap_snprintf(dname, sizeof(dname), "/dev/%s%d", device, unit);

                if (stat(dname, &statbuf) < 0) {
                if (stat(dname, &statbuf) < 0) {

-                       snprintf(ebuf, PCAP_ERRBUF_SIZE, "stat: %s: %s",
+                       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "stat: %s: %s",

                            dname, pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            dname, pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -1634,12 +1634,12 @@ get_dlpi_ppa(register int fd, register const char *device, register int unit,
                }
        }
        if (i == ap->dl_count) {
                }
        }
        if (i == ap->dl_count) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "can't find /dev/dlpi PPA for %s%d", device, unit);
                return (PCAP_ERROR_NO_SUCH_DEVICE);
        }
        if (ip->dl_hdw_state == HDW_DEAD) {
                    "can't find /dev/dlpi PPA for %s%d", device, unit);
                return (PCAP_ERROR_NO_SUCH_DEVICE);
        }
        if (ip->dl_hdw_state == HDW_DEAD) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "%s%d: hardware state: DOWN\n", device, unit);
                free(ppa_data_buf);
                return (PCAP_ERROR);
                    "%s%d: hardware state: DOWN\n", device, unit);
                free(ppa_data_buf);
                return (PCAP_ERROR);


@@ -1678,19 +1678,19 @@ get_dlpi_ppa(register int fd, register const char *ifname, register int unit,
        if (cp != NULL)
                ifname = cp + 1;
        if (nlist(path_vmunix, &nl) < 0) {
        if (cp != NULL)
                ifname = cp + 1;
        if (nlist(path_vmunix, &nl) < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "nlist %s failed",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "nlist %s failed",

                    path_vmunix);
                return (-1);
        }
        if (nl[NL_IFNET].n_value == 0) {
                    path_vmunix);
                return (-1);
        }
        if (nl[NL_IFNET].n_value == 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "could't find %s kernel symbol",
                    nl[NL_IFNET].n_name);
                return (-1);
        }
        kd = open("/dev/kmem", O_RDONLY);
        if (kd < 0) {
                    "could't find %s kernel symbol",
                    nl[NL_IFNET].n_name);
                return (-1);
        }
        kd = open("/dev/kmem", O_RDONLY);
        if (kd < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "kmem open: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "kmem open: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -1712,7 +1712,7 @@ get_dlpi_ppa(register int fd, register const char *ifname, register int unit,
                        return (ifnet.if_index);
        }
 
                        return (ifnet.if_index);
        }
 

-       snprintf(ebuf, PCAP_ERRBUF_SIZE, "Can't find %s", ifname);
+       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "Can't find %s", ifname);

        return (-1);
 }
 
        return (-1);
 }
 


@@ -1723,17 +1723,17 @@ dlpi_kread(register int fd, register off_t addr,
        register int cc;
 
        if (lseek(fd, addr, SEEK_SET) < 0) {
        register int cc;
 
        if (lseek(fd, addr, SEEK_SET) < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "lseek: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "lseek: %s",

                    pcap_strerror(errno));
                return (-1);
        }
        cc = read(fd, buf, len);
        if (cc < 0) {
                    pcap_strerror(errno));
                return (-1);
        }
        cc = read(fd, buf, len);
        if (cc < 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "read: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "read: %s",

                    pcap_strerror(errno));
                return (-1);
        } else if (cc != len) {
                    pcap_strerror(errno));
                return (-1);
        } else if (cc != len) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "short read (%d != %d)", cc,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "short read (%d != %d)", cc,

                    len);
                return (-1);
        }
                    len);
                return (-1);
        }

diff --git a/pcap-dos.c b/pcap-dos.c
index 8632cee66b03a6621c24f8ca2541bfc3ee4ebcf7..563755fc87e88c5e48b8b09ec9d062edb84c16c4 100644 (file)
--- a/pcap-dos.c
+++ b/pcap-dos.c
@@ -202,7 +202,7 @@ static int pcap_activate_dos (pcap_t *pcap)
   }
   else if (stricmp(active_dev->name,pcap->opt.source))
   {
   }
   else if (stricmp(active_dev->name,pcap->opt.source))
   {

-    snprintf (pcap->errbuf, PCAP_ERRBUF_SIZE,
+    pcap_snprintf (pcap->errbuf, PCAP_ERRBUF_SIZE,

               "Cannot use different devices simultaneously "
               "(`%s' vs. `%s')", active_dev->name, pcap->opt.source);
     return (PCAP_ERROR);
               "Cannot use different devices simultaneously "
               "(`%s' vs. `%s')", active_dev->name, pcap->opt.source);
     return (PCAP_ERROR);

diff --git a/pcap-int.h b/pcap-int.h
index dff1900cb0d4f5e858416cd34e83fb0fb2838942..091b041938d2b2e37d6defa8d00948894f99abd1 100644 (file)
--- a/pcap-int.h
+++ b/pcap-int.h
@@ -380,14 +380,52 @@ int       pcap_read(pcap_t *, int cnt, pcap_handler, u_char *);
 
 #include <stdarg.h>
 
 
 #include <stdarg.h>
 

-#if !defined(HAVE_SNPRINTF)
-#define snprintf pcap_snprintf
-extern int snprintf (char *, size_t, const char *, ...);
+/*
+ * For flagging arguments as format strings in MSVC.
+ */
+#if _MSC_VER >= 1400
+ #include <sal.h>
+ #if _MSC_VER > 1400
+  #define FORMAT_STRING(p) _Printf_format_string_ p
+ #else
+  #define FORMAT_STRING(p) __format_string p
+ #endif
+#else
+ #define FORMAT_STRING(p) p
+#endif
+
+/*
+ * On Windows, snprintf(), with that name and with C99 behavior - i.e.,
+ * guaranteeing that the formatted string is null-terminated - didn't
+ * appear until Visual Studio 2015.  Prior to that, the C runtime had
+ * only _snprintf(), which *doesn't* guarantee that the string is
+ * null-terminated if it is truncated due to the buffer being too
+ * small.  We therefore can't just define snprintf to be _snprintf
+ * and define vsnprintf to be _vsnprintf, as we're relying on null-
+ * termination of strings in all cases.
+ *
+ * We also want to allow this to be built with versions of Visual Studio
+ * prior to VS 2015, so we can't rely on snprintf() being present.
+ *
+ * And we want to make sure that, if we support plugins in the future,
+ * a routine with C99 snprintf() behavior will be available to them.
+ * We also don't want it to collide with the C library snprintf() if
+ * there is one.
+ *
+ * So we make pcap_snprintf() and pcap_vsnprintf() available, either by
+ * #defining them to be snprintf or vsnprintf, respectively, or by
+ * defining our own versions and exporting them.
+ */
+#ifdef HAVE_SNPRINTF
+#define pcap_snprintf snprintf
+#else
+extern int pcap_snprintf(char *, size_t, FORMAT_STRING(const char *), ...);

 #endif
 
 #endif
 

-#if !defined(HAVE_VSNPRINTF)
-#define vsnprintf pcap_vsnprintf
-extern int vsnprintf (char *, size_t, const char *, va_list ap);
+#ifdef HAVE_VSNPRINTF
+#define pcap_vsnprintf vsnprintf
+#else
+extern int pcap_vsnprintf(char *, size_t, const char *, va_list ap);

 #endif
 
 /*
 #endif
 
 /*

diff --git a/pcap-libdlpi.c b/pcap-libdlpi.c
index 899b07bf960dccf35aed84d24b6ba221ed3be2f8..e197b2d87982a6182f1d8b421e00755036b8d2e0 100644 (file)
--- a/pcap-libdlpi.c
+++ b/pcap-libdlpi.c
@@ -209,7 +209,7 @@ pcap_activate_libdlpi(pcap_t *p)
         */
        if (ioctl(p->fd, I_FLUSH, FLUSHR) != 0) {
                status = PCAP_ERROR;
         */
        if (ioctl(p->fd, I_FLUSH, FLUSHR) != 0) {
                status = PCAP_ERROR;

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "FLUSHR: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "FLUSHR: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -284,7 +284,7 @@ pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf)
        dlpi_walk(list_interfaces, &lw, 0);
 
        if (lw.lw_err != 0) {
        dlpi_walk(list_interfaces, &lw, 0);
 
        if (lw.lw_err != 0) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "dlpi_walk: %s", pcap_strerror(lw.lw_err));
                retv = -1;
                goto done;
                    "dlpi_walk: %s", pcap_strerror(lw.lw_err));
                retv = -1;
                goto done;


@@ -404,7 +404,7 @@ pcap_cleanup_libdlpi(pcap_t *p)
 static void
 pcap_libdlpi_err(const char *linkname, const char *func, int err, char *errbuf)
 {
 static void
 pcap_libdlpi_err(const char *linkname, const char *func, int err, char *errbuf)
 {

-       snprintf(errbuf, PCAP_ERRBUF_SIZE, "libpcap: %s failed on %s: %s",
+       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "libpcap: %s failed on %s: %s",

            func, linkname, dlpi_strerror(err));
 }
 
            func, linkname, dlpi_strerror(err));
 }
 

diff --git a/pcap-linux.c b/pcap-linux.c
index 13d79ff056c4e04f71ffb5d662bc4c5ad4d59698..912847ab51c96d1ba0dad779aedc0982fa4ca949 100644 (file)
--- a/pcap-linux.c
+++ b/pcap-linux.c
@@ -478,7 +478,7 @@ pcap_create_interface(const char *device, char *ebuf)
        handle->tstamp_precision_count = 2;
        handle->tstamp_precision_list = malloc(2 * sizeof(u_int));
        if (handle->tstamp_precision_list == NULL) {
        handle->tstamp_precision_count = 2;
        handle->tstamp_precision_list = malloc(2 * sizeof(u_int));
        if (handle->tstamp_precision_list == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                pcap_close(handle);
                return NULL;
                    pcap_strerror(errno));
                pcap_close(handle);
                return NULL;


@@ -550,7 +550,7 @@ get_mac80211_phydev(pcap_t *handle, const char *device, char *phydev_path,
         * Generate the path string for the symlink to the physical device.
         */
        if (asprintf(&pathstr, "/sys/class/net/%s/phy80211", device) == -1) {
         * Generate the path string for the symlink to the physical device.
         */
        if (asprintf(&pathstr, "/sys/class/net/%s/phy80211", device) == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: Can't generate path name string for /sys/class/net device",
                    device);
                return PCAP_ERROR;
                    "%s: Can't generate path name string for /sys/class/net device",
                    device);
                return PCAP_ERROR;


@@ -565,7 +565,7 @@ get_mac80211_phydev(pcap_t *handle, const char *device, char *phydev_path,
                        free(pathstr);
                        return 0;
                }
                        free(pathstr);
                        return 0;
                }

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: Can't readlink %s: %s", device, pathstr,
                    strerror(errno));
                free(pathstr);
                    "%s: Can't readlink %s: %s", device, pathstr,
                    strerror(errno));
                free(pathstr);


@@ -622,20 +622,20 @@ nl80211_init(pcap_t *handle, struct nl80211_state *state, const char *device)
 
        state->nl_sock = nl_socket_alloc();
        if (!state->nl_sock) {
 
        state->nl_sock = nl_socket_alloc();
        if (!state->nl_sock) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: failed to allocate netlink handle", device);
                return PCAP_ERROR;
        }
 
        if (genl_connect(state->nl_sock)) {
                    "%s: failed to allocate netlink handle", device);
                return PCAP_ERROR;
        }
 
        if (genl_connect(state->nl_sock)) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: failed to connect to generic netlink", device);
                goto out_handle_destroy;
        }
 
        err = genl_ctrl_alloc_cache(state->nl_sock, &state->nl_cache);
        if (err < 0) {
                    "%s: failed to connect to generic netlink", device);
                goto out_handle_destroy;
        }
 
        err = genl_ctrl_alloc_cache(state->nl_sock, &state->nl_cache);
        if (err < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: failed to allocate generic netlink cache: %s",
                    device, get_nl_errmsg(-err));
                goto out_handle_destroy;
                    "%s: failed to allocate generic netlink cache: %s",
                    device, get_nl_errmsg(-err));
                goto out_handle_destroy;


@@ -643,7 +643,7 @@ nl80211_init(pcap_t *handle, struct nl80211_state *state, const char *device)
 
        state->nl80211 = genl_ctrl_search_by_name(state->nl_cache, "nl80211");
        if (!state->nl80211) {
 
        state->nl80211 = genl_ctrl_search_by_name(state->nl_cache, "nl80211");
        if (!state->nl80211) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: nl80211 not found", device);
                goto out_cache_free;
        }
                    "%s: nl80211 not found", device);
                goto out_cache_free;
        }


@@ -684,7 +684,7 @@ add_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
 
        msg = nlmsg_alloc();
        if (!msg) {
 
        msg = nlmsg_alloc();
        if (!msg) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: failed to allocate netlink msg", device);
                return PCAP_ERROR;
        }
                    "%s: failed to allocate netlink msg", device);
                return PCAP_ERROR;
        }


@@ -716,7 +716,7 @@ add_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
                         * Real failure, not just "that device is not
                         * available.
                         */
                         * Real failure, not just "that device is not
                         * available.
                         */

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: nl_send_auto_complete failed adding %s interface: %s",
                            device, mondevice, get_nl_errmsg(-err));
                        nlmsg_free(msg);
                            "%s: nl_send_auto_complete failed adding %s interface: %s",
                            device, mondevice, get_nl_errmsg(-err));
                        nlmsg_free(msg);


@@ -744,7 +744,7 @@ add_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
                         * Real failure, not just "that device is not
                         * available.
                         */
                         * Real failure, not just "that device is not
                         * available.
                         */

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: nl_wait_for_ack failed adding %s interface: %s",
                            device, mondevice, get_nl_errmsg(-err));
                        nlmsg_free(msg);
                            "%s: nl_wait_for_ack failed adding %s interface: %s",
                            device, mondevice, get_nl_errmsg(-err));
                        nlmsg_free(msg);


@@ -762,7 +762,7 @@ add_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
         */
        handlep->mondevice = strdup(mondevice);
        if (handlep->mondevice == NULL) {
         */
        handlep->mondevice = strdup(mondevice);
        if (handlep->mondevice == NULL) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",

                         pcap_strerror(errno));
                /*
                 * Get rid of the monitor device.
                         pcap_strerror(errno));
                /*
                 * Get rid of the monitor device.


@@ -773,7 +773,7 @@ add_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
        return 1;
 
 nla_put_failure:
        return 1;
 
 nla_put_failure:

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

            "%s: nl_put failed adding %s interface",
            device, mondevice);
        nlmsg_free(msg);
            "%s: nl_put failed adding %s interface",
            device, mondevice);
        nlmsg_free(msg);


@@ -794,7 +794,7 @@ del_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
 
        msg = nlmsg_alloc();
        if (!msg) {
 
        msg = nlmsg_alloc();
        if (!msg) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: failed to allocate netlink msg", device);
                return PCAP_ERROR;
        }
                    "%s: failed to allocate netlink msg", device);
                return PCAP_ERROR;
        }


@@ -805,7 +805,7 @@ del_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
 
        err = nl_send_auto_complete(state->nl_sock, msg);
        if (err < 0) {
 
        err = nl_send_auto_complete(state->nl_sock, msg);
        if (err < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: nl_send_auto_complete failed deleting %s interface: %s",
                    device, mondevice, get_nl_errmsg(-err));
                nlmsg_free(msg);
                    "%s: nl_send_auto_complete failed deleting %s interface: %s",
                    device, mondevice, get_nl_errmsg(-err));
                nlmsg_free(msg);


@@ -813,7 +813,7 @@ del_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
        }
        err = nl_wait_for_ack(state->nl_sock);
        if (err < 0) {
        }
        err = nl_wait_for_ack(state->nl_sock);
        if (err < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: nl_wait_for_ack failed adding %s interface: %s",
                    device, mondevice, get_nl_errmsg(-err));
                nlmsg_free(msg);
                    "%s: nl_wait_for_ack failed adding %s interface: %s",
                    device, mondevice, get_nl_errmsg(-err));
                nlmsg_free(msg);


@@ -827,7 +827,7 @@ del_mon_if(pcap_t *handle, int sock_fd, struct nl80211_state *state,
        return 1;
 
 nla_put_failure:
        return 1;
 
 nla_put_failure:

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

            "%s: nl_put failed deleting %s interface",
            device, mondevice);
        nlmsg_free(msg);
            "%s: nl_put failed deleting %s interface",
            device, mondevice);
        nlmsg_free(msg);


@@ -872,7 +872,7 @@ enter_rfmon_mode_mac80211(pcap_t *handle, int sock_fd, const char *device)
                 */
                char mondevice[3+10+1]; /* mon{UINT_MAX}\0 */
 
                 */
                char mondevice[3+10+1]; /* mon{UINT_MAX}\0 */
 

-               snprintf(mondevice, sizeof mondevice, "mon%u", n);
+               pcap_snprintf(mondevice, sizeof mondevice, "mon%u", n);

                ret = add_mon_if(handle, sock_fd, &nlstate, device, mondevice);
                if (ret == 1) {
                        /*
                ret = add_mon_if(handle, sock_fd, &nlstate, device, mondevice);
                if (ret == 1) {
                        /*


@@ -891,7 +891,7 @@ enter_rfmon_mode_mac80211(pcap_t *handle, int sock_fd, const char *device)
                }
        }
 
                }
        }
 

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

            "%s: No free monN interfaces", device);
        nl80211_cleanup(&nlstate);
        return PCAP_ERROR;
            "%s: No free monN interfaces", device);
        nl80211_cleanup(&nlstate);
        return PCAP_ERROR;


@@ -916,7 +916,7 @@ added:
                 * "atexit()" failed; don't put the interface
                 * in rfmon mode, just give up.
                 */
                 * "atexit()" failed; don't put the interface
                 * in rfmon mode, just give up.
                 */

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: atexit failed", device);
                del_mon_if(handle, sock_fd, &nlstate, device,
                    handlep->mondevice);
                    "%s: atexit failed", device);
                del_mon_if(handle, sock_fd, &nlstate, device,
                    handlep->mondevice);


@@ -930,7 +930,7 @@ added:
        memset(&ifr, 0, sizeof(ifr));
        strlcpy(ifr.ifr_name, handlep->mondevice, sizeof(ifr.ifr_name));
        if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) == -1) {
        memset(&ifr, 0, sizeof(ifr));
        strlcpy(ifr.ifr_name, handlep->mondevice, sizeof(ifr.ifr_name));
        if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: Can't get flags for %s: %s", device,
                    handlep->mondevice, strerror(errno));
                del_mon_if(handle, sock_fd, &nlstate, device,
                    "%s: Can't get flags for %s: %s", device,
                    handlep->mondevice, strerror(errno));
                del_mon_if(handle, sock_fd, &nlstate, device,


@@ -940,7 +940,7 @@ added:
        }
        ifr.ifr_flags |= IFF_UP|IFF_RUNNING;
        if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {
        }
        ifr.ifr_flags |= IFF_UP|IFF_RUNNING;
        if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: Can't set flags for %s: %s", device,
                    handlep->mondevice, strerror(errno));
                del_mon_if(handle, sock_fd, &nlstate, device,
                    "%s: Can't set flags for %s: %s", device,
                    handlep->mondevice, strerror(errno));
                del_mon_if(handle, sock_fd, &nlstate, device,


@@ -1059,7 +1059,7 @@ pcap_can_set_rfmon_linux(pcap_t *handle)
         */
        sock_fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
        if (sock_fd == -1) {
         */
        sock_fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
        if (sock_fd == -1) {

-               (void)snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                return PCAP_ERROR;
        }
                    "socket: %s", pcap_strerror(errno));
                return PCAP_ERROR;
        }


@@ -1084,7 +1084,7 @@ pcap_can_set_rfmon_linux(pcap_t *handle)
        }
        if (errno == ENODEV) {
                /* The device doesn't even exist. */
        }
        if (errno == ENODEV) {
                /* The device doesn't even exist. */

-               (void)snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "SIOCGIWMODE failed: %s", pcap_strerror(errno));
                close(sock_fd);
                return PCAP_ERROR_NO_SUCH_DEVICE;
                    "SIOCGIWMODE failed: %s", pcap_strerror(errno));
                close(sock_fd);
                return PCAP_ERROR_NO_SUCH_DEVICE;


@@ -1463,7 +1463,7 @@ pcap_activate_linux(pcap_t *handle)
                if (handle->opt.promisc) {
                        handle->opt.promisc = 0;
                        /* Just a warning. */
                if (handle->opt.promisc) {
                        handle->opt.promisc = 0;
                        /* Just a warning. */

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "Promiscuous mode not supported on the \"any\" device");
                        status = PCAP_WARNING_PROMISC_NOTSUP;
                }
                            "Promiscuous mode not supported on the \"any\" device");
                        status = PCAP_WARNING_PROMISC_NOTSUP;
                }


@@ -1471,7 +1471,7 @@ pcap_activate_linux(pcap_t *handle)
 
        handlep->device = strdup(device);
        if (handlep->device == NULL) {
 
        handlep->device = strdup(device);
        if (handlep->device == NULL) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s",

                         pcap_strerror(errno) );
                return PCAP_ERROR;
        }
                         pcap_strerror(errno) );
                return PCAP_ERROR;
        }


@@ -1568,7 +1568,7 @@ pcap_activate_linux(pcap_t *handle)
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF,
                    &handle->opt.buffer_size,
                    sizeof(handle->opt.buffer_size)) == -1) {
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF,
                    &handle->opt.buffer_size,
                    sizeof(handle->opt.buffer_size)) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                 "SO_RCVBUF: %s", pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto fail;
                                 "SO_RCVBUF: %s", pcap_strerror(errno));
                        status = PCAP_ERROR;
                        goto fail;


@@ -1579,7 +1579,7 @@ pcap_activate_linux(pcap_t *handle)
 
        handle->buffer   = malloc(handle->bufsize + handle->offset);
        if (!handle->buffer) {
 
        handle->buffer   = malloc(handle->bufsize + handle->offset);
        if (!handle->buffer) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "malloc: %s", pcap_strerror(errno));
                status = PCAP_ERROR;
                goto fail;
                         "malloc: %s", pcap_strerror(errno));
                status = PCAP_ERROR;
                goto fail;


@@ -1776,12 +1776,12 @@ pcap_read_packet(pcap_t *handle, pcap_handler callback, u_char *userdata)
                         * PCAP_ERROR_IFACE_NOT_UP, but pcap_dispatch()
                         * etc. aren't defined to return that.
                         */
                         * PCAP_ERROR_IFACE_NOT_UP, but pcap_dispatch()
                         * etc. aren't defined to return that.
                         */

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "The interface went down");
                        return PCAP_ERROR;
 
                default:
                                "The interface went down");
                        return PCAP_ERROR;
 
                default:

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                 "recvfrom: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                                 "recvfrom: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }


@@ -1933,7 +1933,7 @@ pcap_read_packet(pcap_t *handle, pcap_handler callback, u_char *userdata)
 #if defined(SIOCGSTAMPNS) && defined(SO_TIMESTAMPNS)
        if (handle->opt.tstamp_precision == PCAP_TSTAMP_PRECISION_NANO) {
                if (ioctl(handle->fd, SIOCGSTAMPNS, &pcap_header.ts) == -1) {
 #if defined(SIOCGSTAMPNS) && defined(SO_TIMESTAMPNS)
        if (handle->opt.tstamp_precision == PCAP_TSTAMP_PRECISION_NANO) {
                if (ioctl(handle->fd, SIOCGSTAMPNS, &pcap_header.ts) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "SIOCGSTAMPNS: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                                        "SIOCGSTAMPNS: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }


@@ -1941,7 +1941,7 @@ pcap_read_packet(pcap_t *handle, pcap_handler callback, u_char *userdata)
 #endif
        {
                if (ioctl(handle->fd, SIOCGSTAMP, &pcap_header.ts) == -1) {
 #endif
        {
                if (ioctl(handle->fd, SIOCGSTAMP, &pcap_header.ts) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "SIOCGSTAMP: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                                        "SIOCGSTAMP: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }


@@ -2039,7 +2039,7 @@ pcap_inject_linux(pcap_t *handle, const void *buf, size_t size)
 
        ret = send(handle->fd, buf, size, 0);
        if (ret == -1) {
 
        ret = send(handle->fd, buf, size, 0);
        if (ret == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -2161,7 +2161,7 @@ pcap_stats_linux(pcap_t *handle, struct pcap_stat *stats)
                 * is built on a system without "struct tpacket_stats".
                 */
                if (errno != EOPNOTSUPP) {
                 * is built on a system without "struct tpacket_stats".
                 */
                if (errno != EOPNOTSUPP) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "pcap_stats: %s", pcap_strerror(errno));
                        return -1;
                }
                            "pcap_stats: %s", pcap_strerror(errno));
                        return -1;
                }


@@ -2247,7 +2247,7 @@ add_linux_if(pcap_if_t **devlistp, const char *ifname, int fd, char *errbuf)
        if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifrflags) < 0) {
                if (errno == ENXIO || errno == ENODEV)
                        return (0);     /* device doesn't actually exist - ignore it */
        if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifrflags) < 0) {
                if (errno == ENXIO || errno == ENODEV)
                        return (0);     /* device doesn't actually exist - ignore it */

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "SIOCGIFFLAGS: %.*s: %s",
                    (int)sizeof(ifrflags.ifr_name),
                    ifrflags.ifr_name,
                    "SIOCGIFFLAGS: %.*s: %s",
                    (int)sizeof(ifrflags.ifr_name),
                    ifrflags.ifr_name,


@@ -2306,7 +2306,7 @@ scan_sys_class_net(pcap_if_t **devlistp, char *errbuf)
                /*
                 * Fail if we got some other error.
                 */
                /*
                 * Fail if we got some other error.
                 */

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "Can't open /sys/class/net: %s", pcap_strerror(errno));
                return (-1);
        }
                    "Can't open /sys/class/net: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -2316,7 +2316,7 @@ scan_sys_class_net(pcap_if_t **devlistp, char *errbuf)
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                (void)closedir(sys_class_net_d);
                return (-1);
                    "socket: %s", pcap_strerror(errno));
                (void)closedir(sys_class_net_d);
                return (-1);


@@ -2353,7 +2353,7 @@ scan_sys_class_net(pcap_if_t **devlistp, char *errbuf)
                 * for devices, newer kernels have symlinks to
                 * directories.)
                 */
                 * for devices, newer kernels have symlinks to
                 * directories.)
                 */

-               snprintf(subsystem_path, sizeof subsystem_path,
+               pcap_snprintf(subsystem_path, sizeof subsystem_path,

                    "/sys/class/net/%s/ifindex", ent->d_name);
                if (lstat(subsystem_path, &statb) != 0) {
                        /*
                    "/sys/class/net/%s/ifindex", ent->d_name);
                if (lstat(subsystem_path, &statb) != 0) {
                        /*


@@ -2384,7 +2384,7 @@ scan_sys_class_net(pcap_if_t **devlistp, char *errbuf)
                 * fail due to an error reading the directory?
                 */
                if (errno != 0) {
                 * fail due to an error reading the directory?
                 */
                if (errno != 0) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "Error reading /sys/class/net: %s",
                            pcap_strerror(errno));
                        ret = -1;
                            "Error reading /sys/class/net: %s",
                            pcap_strerror(errno));
                        ret = -1;


@@ -2424,7 +2424,7 @@ scan_proc_net_dev(pcap_if_t **devlistp, char *errbuf)
                /*
                 * Fail if we got some other error.
                 */
                /*
                 * Fail if we got some other error.
                 */

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "Can't open /proc/net/dev: %s", pcap_strerror(errno));
                return (-1);
        }
                    "Can't open /proc/net/dev: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -2434,7 +2434,7 @@ scan_proc_net_dev(pcap_if_t **devlistp, char *errbuf)
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                (void)fclose(proc_net_f);
                return (-1);
                    "socket: %s", pcap_strerror(errno));
                (void)fclose(proc_net_f);
                return (-1);


@@ -2473,7 +2473,7 @@ scan_proc_net_dev(pcap_if_t **devlistp, char *errbuf)
                 * fail due to an error reading the file?
                 */
                if (ferror(proc_net_f)) {
                 * fail due to an error reading the file?
                 */
                if (ferror(proc_net_f)) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "Error reading /proc/net/dev: %s",
                            pcap_strerror(errno));
                        ret = -1;
                            "Error reading /proc/net/dev: %s",
                            pcap_strerror(errno));
                        ret = -1;


@@ -2678,7 +2678,7 @@ pcap_setfilter_linux_common(pcap_t *handle, struct bpf_program *filter,
         */
        if (handlep->filter_in_userland) {
                if (reset_kernel_filter(handle) == -1) {
         */
        if (handlep->filter_in_userland) {
                if (reset_kernel_filter(handle) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "can't remove kernel filter: %s",
                            pcap_strerror(errno));
                        err = -2;       /* fatal error */
                            "can't remove kernel filter: %s",
                            pcap_strerror(errno));
                        err = -2;       /* fatal error */


@@ -2725,7 +2725,7 @@ pcap_setdirection_linux(pcap_t *handle, pcap_direction_t d)
         * We're not using PF_PACKET sockets, so we can't determine
         * the direction of the packet.
         */
         * We're not using PF_PACKET sockets, so we can't determine
         * the direction of the packet.
         */

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

            "Setting direction is not supported on SOCK_PACKET sockets");
        return -1;
 }
            "Setting direction is not supported on SOCK_PACKET sockets");
        return -1;
 }


@@ -3293,7 +3293,7 @@ activate_new(pcap_t *handle)
                        return 0;
                }
 
                        return 0;
                }
 

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "socket: %s",
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "socket: %s",

                         pcap_strerror(errno) );
                if (errno == EPERM || errno == EACCES) {
                        /*
                         pcap_strerror(errno) );
                if (errno == EPERM || errno == EACCES) {
                        /*


@@ -3395,14 +3395,14 @@ activate_new(pcap_t *handle)
                         * kernels) - reopen in cooked mode.
                         */
                        if (close(sock_fd) == -1) {
                         * kernels) - reopen in cooked mode.
                         */
                        if (close(sock_fd) == -1) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                         "close: %s", pcap_strerror(errno));
                                return PCAP_ERROR;
                        }
                        sock_fd = socket(PF_PACKET, SOCK_DGRAM,
                            htons(ETH_P_ALL));
                        if (sock_fd == -1) {
                                         "close: %s", pcap_strerror(errno));
                                return PCAP_ERROR;
                        }
                        sock_fd = socket(PF_PACKET, SOCK_DGRAM,
                            htons(ETH_P_ALL));
                        if (sock_fd == -1) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                    "socket: %s", pcap_strerror(errno));
                                if (errno == EPERM || errno == EACCES) {
                                        /*
                                    "socket: %s", pcap_strerror(errno));
                                if (errno == EPERM || errno == EACCES) {
                                        /*


@@ -3437,7 +3437,7 @@ activate_new(pcap_t *handle)
                                 * update "map_arphrd_to_dlt()"
                                 * to handle the new type.
                                 */
                                 * update "map_arphrd_to_dlt()"
                                 * to handle the new type.
                                 */

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "arptype %d not "
                                        "supported by libpcap - "
                                        "falling back to cooked "
                                        "arptype %d not "
                                        "supported by libpcap - "
                                        "falling back to cooked "


@@ -3527,7 +3527,7 @@ activate_new(pcap_t *handle)
                mr.mr_type    = PACKET_MR_PROMISC;
                if (setsockopt(sock_fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP,
                    &mr, sizeof(mr)) == -1) {
                mr.mr_type    = PACKET_MR_PROMISC;
                if (setsockopt(sock_fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP,
                    &mr, sizeof(mr)) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "setsockopt: %s", pcap_strerror(errno));
                        close(sock_fd);
                        return PCAP_ERROR;
                                "setsockopt: %s", pcap_strerror(errno));
                        close(sock_fd);
                        return PCAP_ERROR;


@@ -3540,7 +3540,7 @@ activate_new(pcap_t *handle)
        val = 1;
        if (setsockopt(sock_fd, SOL_PACKET, PACKET_AUXDATA, &val,
                       sizeof(val)) == -1 && errno != ENOPROTOOPT) {
        val = 1;
        if (setsockopt(sock_fd, SOL_PACKET, PACKET_AUXDATA, &val,
                       sizeof(val)) == -1 && errno != ENOPROTOOPT) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "setsockopt: %s", pcap_strerror(errno));
                close(sock_fd);
                return PCAP_ERROR;
                         "setsockopt: %s", pcap_strerror(errno));
                close(sock_fd);
                return PCAP_ERROR;


@@ -3591,7 +3591,7 @@ activate_new(pcap_t *handle)
                int nsec_tstamps = 1;
 
                if (setsockopt(sock_fd, SOL_SOCKET, SO_TIMESTAMPNS, &nsec_tstamps, sizeof(nsec_tstamps)) < 0) {
                int nsec_tstamps = 1;
 
                if (setsockopt(sock_fd, SOL_SOCKET, SO_TIMESTAMPNS, &nsec_tstamps, sizeof(nsec_tstamps)) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "setsockopt: unable to set SO_TIMESTAMPNS");
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "setsockopt: unable to set SO_TIMESTAMPNS");

                        close(sock_fd);
                        return PCAP_ERROR;
                }
                        close(sock_fd);
                        return PCAP_ERROR;
                }


@@ -3654,7 +3654,7 @@ activate_mmap(pcap_t *handle, int *status)
         */
        handlep->oneshot_buffer = malloc(handle->snapshot);
        if (handlep->oneshot_buffer == NULL) {
         */
        handlep->oneshot_buffer = malloc(handle->snapshot);
        if (handlep->oneshot_buffer == NULL) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "can't allocate oneshot buffer: %s",
                         pcap_strerror(errno));
                *status = PCAP_ERROR;
                         "can't allocate oneshot buffer: %s",
                         pcap_strerror(errno));
                *status = PCAP_ERROR;


@@ -3759,7 +3759,7 @@ init_tpacket(pcap_t *handle, int version, const char *version_str)
                        return 1;       /* no */
 
                /* Failed to even find out; this is a fatal error. */
                        return 1;       /* no */
 
                /* Failed to even find out; this is a fatal error. */

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "can't get %s header len on packet socket: %s",
                        version_str,
                        pcap_strerror(errno));
                        "can't get %s header len on packet socket: %s",
                        version_str,
                        pcap_strerror(errno));


@@ -3770,7 +3770,7 @@ init_tpacket(pcap_t *handle, int version, const char *version_str)
        val = version;
        if (setsockopt(handle->fd, SOL_PACKET, PACKET_VERSION, &val,
                           sizeof(val)) < 0) {
        val = version;
        if (setsockopt(handle->fd, SOL_PACKET, PACKET_VERSION, &val,
                           sizeof(val)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "can't activate %s on packet socket: %s",
                        version_str,
                        pcap_strerror(errno));
                        "can't activate %s on packet socket: %s",
                        version_str,
                        pcap_strerror(errno));


@@ -3782,7 +3782,7 @@ init_tpacket(pcap_t *handle, int version, const char *version_str)
        val = VLAN_TAG_LEN;
        if (setsockopt(handle->fd, SOL_PACKET, PACKET_RESERVE, &val,
                           sizeof(val)) < 0) {
        val = VLAN_TAG_LEN;
        if (setsockopt(handle->fd, SOL_PACKET, PACKET_RESERVE, &val,
                           sizeof(val)) < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "can't set up reserve on packet socket: %s",
                        pcap_strerror(errno));
                return -1;
                        "can't set up reserve on packet socket: %s",
                        pcap_strerror(errno));
                return -1;


@@ -3914,7 +3914,7 @@ prepare_tpacket_socket(pcap_t *handle)
                        /*
                         * Failed.
                         */
                        /*
                         * Failed.
                         */

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "uname failed: %s", pcap_strerror(errno));
                        return -1;
                }
                            "uname failed: %s", pcap_strerror(errno));
                        return -1;
                }


@@ -4037,7 +4037,7 @@ create_ring(pcap_t *handle, int *status)
                len = sizeof(sk_type);
                if (getsockopt(handle->fd, SOL_SOCKET, SO_TYPE, &sk_type,
                    &len) < 0) {
                len = sizeof(sk_type);
                if (getsockopt(handle->fd, SOL_SOCKET, SO_TYPE, &sk_type,
                    &len) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "getsockopt: %s", pcap_strerror(errno));
                        *status = PCAP_ERROR;
                        return -1;
                            "getsockopt: %s", pcap_strerror(errno));
                        *status = PCAP_ERROR;
                        return -1;


@@ -4052,7 +4052,7 @@ create_ring(pcap_t *handle, int *status)
                                 * PACKET_RESERVE", in which case we fall back
                                 * as best we can.
                                 */
                                 * PACKET_RESERVE", in which case we fall back
                                 * as best we can.
                                 */

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                    "getsockopt: %s", pcap_strerror(errno));
                                *status = PCAP_ERROR;
                                return -1;
                                    "getsockopt: %s", pcap_strerror(errno));
                                *status = PCAP_ERROR;
                                return -1;


@@ -4108,7 +4108,7 @@ create_ring(pcap_t *handle, int *status)
                break;
 #endif
        default:
                break;
 #endif
        default:

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Internal error: unknown TPACKET_ value %u",
                    handlep->tp_version);
                *status = PCAP_ERROR;
                    "Internal error: unknown TPACKET_ value %u",
                    handlep->tp_version);
                *status = PCAP_ERROR;


@@ -4190,7 +4190,7 @@ create_ring(pcap_t *handle, int *status)
                                break;
 
                        default:
                                break;
 
                        default:

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "SIOCSHWTSTAMP failed: %s",
                                        pcap_strerror(errno));
                                *status = PCAP_ERROR;
                                        "SIOCSHWTSTAMP failed: %s",
                                        pcap_strerror(errno));
                                *status = PCAP_ERROR;


@@ -4218,7 +4218,7 @@ create_ring(pcap_t *handle, int *status)
                        }
                        if (setsockopt(handle->fd, SOL_PACKET, PACKET_TIMESTAMP,
                                (void *)&timesource, sizeof(timesource))) {
                        }
                        if (setsockopt(handle->fd, SOL_PACKET, PACKET_TIMESTAMP,
                                (void *)&timesource, sizeof(timesource))) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "can't set PACKET_TIMESTAMP: %s",
                                        pcap_strerror(errno));
                                *status = PCAP_ERROR;
                                        "can't set PACKET_TIMESTAMP: %s",
                                        pcap_strerror(errno));
                                *status = PCAP_ERROR;


@@ -4268,7 +4268,7 @@ retry:
                         */
                        return 0;
                }
                         */
                        return 0;
                }

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "can't create rx ring on packet socket: %s",
                    pcap_strerror(errno));
                *status = PCAP_ERROR;
                    "can't create rx ring on packet socket: %s",
                    pcap_strerror(errno));
                *status = PCAP_ERROR;


@@ -4280,7 +4280,7 @@ retry:
        handlep->mmapbuf = mmap(0, handlep->mmapbuflen,
            PROT_READ|PROT_WRITE, MAP_SHARED, handle->fd, 0);
        if (handlep->mmapbuf == MAP_FAILED) {
        handlep->mmapbuf = mmap(0, handlep->mmapbuflen,
            PROT_READ|PROT_WRITE, MAP_SHARED, handle->fd, 0);
        if (handlep->mmapbuf == MAP_FAILED) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "can't mmap rx ring: %s", pcap_strerror(errno));
 
                /* clear the allocated ring on error*/
                    "can't mmap rx ring: %s", pcap_strerror(errno));
 
                /* clear the allocated ring on error*/


@@ -4293,7 +4293,7 @@ retry:
        handle->cc = req.tp_frame_nr;
        handle->buffer = malloc(handle->cc * sizeof(union thdr *));
        if (!handle->buffer) {
        handle->cc = req.tp_frame_nr;
        handle->buffer = malloc(handle->cc * sizeof(union thdr *));
        if (!handle->buffer) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "can't allocate ring of frame headers: %s",
                    pcap_strerror(errno));
 
                    "can't allocate ring of frame headers: %s",
                    pcap_strerror(errno));
 


@@ -4485,7 +4485,7 @@ static int pcap_wait_for_frames_mmap(pcap_t *handle)
                 */
                ret = poll(&pollinfo, 1, handlep->poll_timeout);
                if (ret < 0 && errno != EINTR) {
                 */
                ret = poll(&pollinfo, 1, handlep->poll_timeout);
                if (ret < 0 && errno != EINTR) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "can't poll on packet socket: %s",
                                pcap_strerror(errno));
                        return PCAP_ERROR;
                                "can't poll on packet socket: %s",
                                pcap_strerror(errno));
                        return PCAP_ERROR;


@@ -4497,7 +4497,7 @@ static int pcap_wait_for_frames_mmap(pcap_t *handle)
                         * the descriptor.
                         */
                        if (pollinfo.revents & (POLLHUP | POLLRDHUP)) {
                         * the descriptor.
                         */
                        if (pollinfo.revents & (POLLHUP | POLLRDHUP)) {

-                               snprintf(handle->errbuf,
+                               pcap_snprintf(handle->errbuf,

                                        PCAP_ERRBUF_SIZE,
                                        "Hangup on packet socket");
                                return PCAP_ERROR;
                                        PCAP_ERRBUF_SIZE,
                                        "Hangup on packet socket");
                                return PCAP_ERROR;


@@ -4521,11 +4521,11 @@ static int pcap_wait_for_frames_mmap(pcap_t *handle)
                                         * pcap_dispatch() etc. aren't
                                         * defined to return that.
                                         */
                                         * pcap_dispatch() etc. aren't
                                         * defined to return that.
                                         */

-                                       snprintf(handle->errbuf,
+                                       pcap_snprintf(handle->errbuf,

                                                PCAP_ERRBUF_SIZE,
                                                "The interface went down");
                                } else {
                                                PCAP_ERRBUF_SIZE,
                                                "The interface went down");
                                } else {

-                                       snprintf(handle->errbuf,
+                                       pcap_snprintf(handle->errbuf,

                                                PCAP_ERRBUF_SIZE,
                                                "Error condition on packet socket: %s",
                                                strerror(errno));
                                                PCAP_ERRBUF_SIZE,
                                                "Error condition on packet socket: %s",
                                                strerror(errno));


@@ -4533,7 +4533,7 @@ static int pcap_wait_for_frames_mmap(pcap_t *handle)
                                return PCAP_ERROR;
                        }
                        if (pollinfo.revents & POLLNVAL) {
                                return PCAP_ERROR;
                        }
                        if (pollinfo.revents & POLLNVAL) {

-                               snprintf(handle->errbuf,
+                               pcap_snprintf(handle->errbuf,

                                        PCAP_ERRBUF_SIZE,
                                        "Invalid polling request on packet socket");
                                return PCAP_ERROR;
                                        PCAP_ERRBUF_SIZE,
                                        "Invalid polling request on packet socket");
                                return PCAP_ERROR;


@@ -4570,7 +4570,7 @@ static int pcap_handle_packet_mmap(
 
        /* perform sanity check on internal offset. */
        if (tp_mac + tp_snaplen > handle->bufsize) {
 
        /* perform sanity check on internal offset. */
        if (tp_mac + tp_snaplen > handle->bufsize) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "corrupted frame on kernel ring mac "
                        "offset %u + caplen %u > frame len %d",
                        tp_mac, tp_snaplen, handle->bufsize);
                        "corrupted frame on kernel ring mac "
                        "offset %u + caplen %u > frame len %d",
                        tp_mac, tp_snaplen, handle->bufsize);


@@ -4612,7 +4612,7 @@ static int pcap_handle_packet_mmap(
                if (bp < (u_char *)frame +
                                   TPACKET_ALIGN(handlep->tp_hdrlen) +
                                   sizeof(struct sockaddr_ll)) {
                if (bp < (u_char *)frame +
                                   TPACKET_ALIGN(handlep->tp_hdrlen) +
                                   sizeof(struct sockaddr_ll)) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "cooked-mode frame doesn't have room for sll header");
                        return -1;
                }
                                "cooked-mode frame doesn't have room for sll header");
                        return -1;
                }


@@ -5168,7 +5168,7 @@ iface_get_id(int fd, const char *device, char *ebuf)
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 
        if (ioctl(fd, SIOCGIFINDEX, &ifr) == -1) {
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 
        if (ioctl(fd, SIOCGIFINDEX, &ifr) == -1) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                         "SIOCGIFINDEX: %s", pcap_strerror(errno));
                return -1;
        }
                         "SIOCGIFINDEX: %s", pcap_strerror(errno));
                return -1;
        }


@@ -5204,7 +5204,7 @@ iface_bind(int fd, int ifindex, char *ebuf)
                         */
                        return PCAP_ERROR_IFACE_NOT_UP;
                } else {
                         */
                        return PCAP_ERROR_IFACE_NOT_UP;
                } else {

-                       snprintf(ebuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                                 "bind: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                                 "bind: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }


@@ -5213,7 +5213,7 @@ iface_bind(int fd, int ifindex, char *ebuf)
        /* Any pending errors, e.g., network is down? */
 
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
        /* Any pending errors, e.g., network is down? */
 
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                        "getsockopt: %s", pcap_strerror(errno));
                return 0;
        }
                        "getsockopt: %s", pcap_strerror(errno));
                return 0;
        }


@@ -5228,7 +5228,7 @@ iface_bind(int fd, int ifindex, char *ebuf)
                 */
                return PCAP_ERROR_IFACE_NOT_UP;
        } else if (err > 0) {
                 */
                return PCAP_ERROR_IFACE_NOT_UP;
        } else if (err > 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                        "bind: %s", pcap_strerror(err));
                return 0;
        }
                        "bind: %s", pcap_strerror(err));
                return 0;
        }


@@ -5254,7 +5254,7 @@ has_wext(int sock_fd, const char *device, char *ebuf)
            sizeof ireq.ifr_ifrn.ifrn_name);
        if (ioctl(sock_fd, SIOCGIWNAME, &ireq) >= 0)
                return 1;       /* yes */
            sizeof ireq.ifr_ifrn.ifrn_name);
        if (ioctl(sock_fd, SIOCGIWNAME, &ireq) >= 0)
                return 1;       /* yes */

-       snprintf(ebuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

            "%s: SIOCGIWNAME: %s", device, pcap_strerror(errno));
        if (errno == ENODEV)
                return PCAP_ERROR_NO_SUCH_DEVICE;
            "%s: SIOCGIWNAME: %s", device, pcap_strerror(errno));
        if (errno == ENODEV)
                return PCAP_ERROR_NO_SUCH_DEVICE;


@@ -5393,7 +5393,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
        ireq.u.data.length = 0;
        ireq.u.data.flags = 0;
        if (ioctl(sock_fd, SIOCGIWPRIV, &ireq) != -1) {
        ireq.u.data.length = 0;
        ireq.u.data.flags = 0;
        if (ioctl(sock_fd, SIOCGIWPRIV, &ireq) != -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: SIOCGIWPRIV with a zero-length buffer didn't fail!",
                    device);
                return PCAP_ERROR;
                    "%s: SIOCGIWPRIV with a zero-length buffer didn't fail!",
                    device);
                return PCAP_ERROR;


@@ -5406,7 +5406,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
                        /*
                         * Failed.
                         */
                        /*
                         * Failed.
                         */

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: SIOCGIWPRIV: %s", device,
                            pcap_strerror(errno));
                        return PCAP_ERROR;
                            "%s: SIOCGIWPRIV: %s", device,
                            pcap_strerror(errno));
                        return PCAP_ERROR;


@@ -5417,13 +5417,13 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
                 */
                priv = malloc(ireq.u.data.length * sizeof (struct iw_priv_args));
                if (priv == NULL) {
                 */
                priv = malloc(ireq.u.data.length * sizeof (struct iw_priv_args));
                if (priv == NULL) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "malloc: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                ireq.u.data.pointer = (void *)priv;
                if (ioctl(sock_fd, SIOCGIWPRIV, &ireq) == -1) {
                            "malloc: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                ireq.u.data.pointer = (void *)priv;
                if (ioctl(sock_fd, SIOCGIWPRIV, &ireq) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: SIOCGIWPRIV: %s", device,
                            pcap_strerror(errno));
                        free(priv);
                            "%s: SIOCGIWPRIV: %s", device,
                            pcap_strerror(errno));
                        free(priv);


@@ -5679,7 +5679,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
        memset(&ifr, 0, sizeof(ifr));
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
        if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) == -1) {
        memset(&ifr, 0, sizeof(ifr));
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
        if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: Can't get flags: %s", device, strerror(errno));
                return PCAP_ERROR;
        }
                    "%s: Can't get flags: %s", device, strerror(errno));
                return PCAP_ERROR;
        }


@@ -5688,7 +5688,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
                oldflags = ifr.ifr_flags;
                ifr.ifr_flags &= ~IFF_UP;
                if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {
                oldflags = ifr.ifr_flags;
                ifr.ifr_flags &= ~IFF_UP;
                if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: Can't set flags: %s", device, strerror(errno));
                        return PCAP_ERROR;
                }
                            "%s: Can't set flags: %s", device, strerror(errno));
                        return PCAP_ERROR;
                }


@@ -5707,7 +5707,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
                 */
                ifr.ifr_flags = oldflags;
                if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {
                 */
                ifr.ifr_flags = oldflags;
                if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: Can't set flags: %s", device, strerror(errno));
                        return PCAP_ERROR;
                }
                            "%s: Can't set flags: %s", device, strerror(errno));
                        return PCAP_ERROR;
                }


@@ -5791,7 +5791,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
                strlcpy(ireq.ifr_ifrn.ifrn_name, device,
                    sizeof ireq.ifr_ifrn.ifrn_name);
                if (ioctl(sock_fd, SIOCGIWFREQ, &ireq) == -1) {
                strlcpy(ireq.ifr_ifrn.ifrn_name, device,
                    sizeof ireq.ifr_ifrn.ifrn_name);
                if (ioctl(sock_fd, SIOCGIWFREQ, &ireq) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: SIOCGIWFREQ: %s", device,
                            pcap_strerror(errno));
                        return PCAP_ERROR;
                            "%s: SIOCGIWFREQ: %s", device,
                            pcap_strerror(errno));
                        return PCAP_ERROR;


@@ -5868,7 +5868,7 @@ enter_rfmon_mode_wext(pcap_t *handle, int sock_fd, const char *device)
        if (oldflags != 0) {
                ifr.ifr_flags = oldflags;
                if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {
        if (oldflags != 0) {
                ifr.ifr_flags = oldflags;
                if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: Can't set flags: %s", device, strerror(errno));
 
                        /*
                            "%s: Can't set flags: %s", device, strerror(errno));
 
                        /*


@@ -5990,7 +5990,7 @@ iface_ethtool_get_ts_info(pcap_t *handle, char *ebuf)
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {
         */
        fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (fd < 0) {

-               (void)snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "socket for SIOCETHTOOL(ETHTOOL_GET_TS_INFO): %s", pcap_strerror(errno));
                return -1;
        }
                    "socket for SIOCETHTOOL(ETHTOOL_GET_TS_INFO): %s", pcap_strerror(errno));
                return -1;
        }


@@ -6010,7 +6010,7 @@ iface_ethtool_get_ts_info(pcap_t *handle, char *ebuf)
                        iface_set_default_ts_types(handle);
                        return 0;
                }
                        iface_set_default_ts_types(handle);
                        return 0;
                }

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                    "%s: SIOCETHTOOL(ETHTOOL_GET_TS_INFO) ioctl failed: %s", handle->opt.source,
                    strerror(errno));
                return -1;
                    "%s: SIOCETHTOOL(ETHTOOL_GET_TS_INFO) ioctl failed: %s", handle->opt.source,
                    strerror(errno));
                return -1;


@@ -6082,7 +6082,7 @@ iface_ethtool_flag_ioctl(pcap_t *handle, int cmd, const char *cmdname)
                         */
                        return 0;
                }
                         */
                        return 0;
                }

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: SIOCETHTOOL(%s) ioctl failed: %s", handle->opt.source,
                    cmdname, strerror(errno));
                return -1;
                    "%s: SIOCETHTOOL(%s) ioctl failed: %s", handle->opt.source,
                    cmdname, strerror(errno));
                return -1;


@@ -6183,7 +6183,7 @@ activate_old(pcap_t *handle)
 
        handle->fd = socket(PF_INET, SOCK_PACKET, htons(ETH_P_ALL));
        if (handle->fd == -1) {
 
        handle->fd = socket(PF_INET, SOCK_PACKET, htons(ETH_P_ALL));
        if (handle->fd == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "socket: %s", pcap_strerror(errno));
                if (errno == EPERM || errno == EACCES) {
                        /*
                         "socket: %s", pcap_strerror(errno));
                if (errno == EPERM || errno == EACCES) {
                        /*


@@ -6228,7 +6228,7 @@ activate_old(pcap_t *handle)
         */
        map_arphrd_to_dlt(handle, handle->fd, arptype, device, 0);
        if (handle->linktype == -1) {
         */
        map_arphrd_to_dlt(handle, handle->fd, arptype, device, 0);
        if (handle->linktype == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "unknown arptype %d", arptype);
                return PCAP_ERROR;
        }
                         "unknown arptype %d", arptype);
                return PCAP_ERROR;
        }


@@ -6239,7 +6239,7 @@ activate_old(pcap_t *handle)
                memset(&ifr, 0, sizeof(ifr));
                strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
                if (ioctl(handle->fd, SIOCGIFFLAGS, &ifr) == -1) {
                memset(&ifr, 0, sizeof(ifr));
                strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
                if (ioctl(handle->fd, SIOCGIFFLAGS, &ifr) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                 "SIOCGIFFLAGS: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }
                                 "SIOCGIFFLAGS: %s", pcap_strerror(errno));
                        return PCAP_ERROR;
                }


@@ -6267,7 +6267,7 @@ activate_old(pcap_t *handle)
 
                        ifr.ifr_flags |= IFF_PROMISC;
                        if (ioctl(handle->fd, SIOCSIFFLAGS, &ifr) == -1) {
 
                        ifr.ifr_flags |= IFF_PROMISC;
                        if (ioctl(handle->fd, SIOCSIFFLAGS, &ifr) == -1) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                         "SIOCSIFFLAGS: %s",
                                         pcap_strerror(errno));
                                return PCAP_ERROR;
                                         "SIOCSIFFLAGS: %s",
                                         pcap_strerror(errno));
                                return PCAP_ERROR;


@@ -6377,7 +6377,7 @@ iface_bind_old(int fd, const char *device, char *ebuf)
        memset(&saddr, 0, sizeof(saddr));
        strlcpy(saddr.sa_data, device, sizeof(saddr.sa_data));
        if (bind(fd, &saddr, sizeof(saddr)) == -1) {
        memset(&saddr, 0, sizeof(saddr));
        strlcpy(saddr.sa_data, device, sizeof(saddr.sa_data));
        if (bind(fd, &saddr, sizeof(saddr)) == -1) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                         "bind: %s", pcap_strerror(errno));
                return -1;
        }
                         "bind: %s", pcap_strerror(errno));
                return -1;
        }


@@ -6385,13 +6385,13 @@ iface_bind_old(int fd, const char *device, char *ebuf)
        /* Any pending errors, e.g., network is down? */
 
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
        /* Any pending errors, e.g., network is down? */
 
        if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                        "getsockopt: %s", pcap_strerror(errno));
                return -1;
        }
 
        if (err > 0) {
                        "getsockopt: %s", pcap_strerror(errno));
                return -1;
        }
 
        if (err > 0) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                        "bind: %s", pcap_strerror(err));
                return -1;
        }
                        "bind: %s", pcap_strerror(err));
                return -1;
        }


@@ -6417,7 +6417,7 @@ iface_get_mtu(int fd, const char *device, char *ebuf)
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 
        if (ioctl(fd, SIOCGIFMTU, &ifr) == -1) {
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 
        if (ioctl(fd, SIOCGIFMTU, &ifr) == -1) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                         "SIOCGIFMTU: %s", pcap_strerror(errno));
                return -1;
        }
                         "SIOCGIFMTU: %s", pcap_strerror(errno));
                return -1;
        }


@@ -6437,7 +6437,7 @@ iface_get_arptype(int fd, const char *device, char *ebuf)
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 
        if (ioctl(fd, SIOCGIFHWADDR, &ifr) == -1) {
        strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 
        if (ioctl(fd, SIOCGIFHWADDR, &ifr) == -1) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE,

                         "SIOCGIFHWADDR: %s", pcap_strerror(errno));
                if (errno == ENODEV) {
                        /*
                         "SIOCGIFHWADDR: %s", pcap_strerror(errno));
                if (errno == ENODEV) {
                        /*


@@ -6470,7 +6470,7 @@ fix_program(pcap_t *handle, struct sock_fprog *fcode, int is_mmapped)
        len = handle->fcode.bf_len;
        f = (struct bpf_insn *)malloc(prog_size);
        if (f == NULL) {
        len = handle->fcode.bf_len;
        f = (struct bpf_insn *)malloc(prog_size);
        if (f == NULL) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "malloc: %s", pcap_strerror(errno));
                return -1;
        }
                         "malloc: %s", pcap_strerror(errno));
                return -1;
        }


@@ -6647,13 +6647,13 @@ set_kernel_filter(pcap_t *handle, struct sock_fprog *fcode)
                 */
                save_mode = fcntl(handle->fd, F_GETFL, 0);
                if (save_mode == -1) {
                 */
                save_mode = fcntl(handle->fd, F_GETFL, 0);
                if (save_mode == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "can't get FD flags when changing filter: %s",
                            pcap_strerror(errno));
                        return -2;
                }
                if (fcntl(handle->fd, F_SETFL, save_mode | O_NONBLOCK) < 0) {
                            "can't get FD flags when changing filter: %s",
                            pcap_strerror(errno));
                        return -2;
                }
                if (fcntl(handle->fd, F_SETFL, save_mode | O_NONBLOCK) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "can't set nonblocking mode when changing filter: %s",
                            pcap_strerror(errno));
                        return -2;
                            "can't set nonblocking mode when changing filter: %s",
                            pcap_strerror(errno));
                        return -2;


@@ -6670,13 +6670,13 @@ set_kernel_filter(pcap_t *handle, struct sock_fprog *fcode)
                         */
                        (void)fcntl(handle->fd, F_SETFL, save_mode);
                        (void)reset_kernel_filter(handle);
                         */
                        (void)fcntl(handle->fd, F_SETFL, save_mode);
                        (void)reset_kernel_filter(handle);

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "recv failed when changing filter: %s",
                            pcap_strerror(save_errno));
                        return -2;
                }
                if (fcntl(handle->fd, F_SETFL, save_mode) == -1) {
                            "recv failed when changing filter: %s",
                            pcap_strerror(save_errno));
                        return -2;
                }
                if (fcntl(handle->fd, F_SETFL, save_mode) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "can't restore FD flags when changing filter: %s",
                            pcap_strerror(save_errno));
                        return -2;
                            "can't restore FD flags when changing filter: %s",
                            pcap_strerror(save_errno));
                        return -2;


@@ -6707,7 +6707,7 @@ set_kernel_filter(pcap_t *handle, struct sock_fprog *fcode)
                 * Report it as a fatal error.
                 */
                if (reset_kernel_filter(handle) == -1) {
                 * Report it as a fatal error.
                 */
                if (reset_kernel_filter(handle) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "can't remove kernel total filter: %s",
                            pcap_strerror(errno));
                        return -2;      /* fatal error */
                            "can't remove kernel total filter: %s",
                            pcap_strerror(errno));
                        return -2;      /* fatal error */

diff --git a/pcap-netfilter-linux.c b/pcap-netfilter-linux.c
index 4dda9a7932e948504e7a7c3dd097ace1fe8a3ec0..8ec054feea721496885b723761962581241db8eb 100644 (file)
--- a/pcap-netfilter-linux.c
+++ b/pcap-netfilter-linux.c
@@ -101,7 +101,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
        } while ((len == -1) && (errno == EINTR));
 
        if (len < 0) {
        } while ((len == -1) && (errno == EINTR));
 
        if (len < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't receive packet %d:%s", errno, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't receive packet %d:%s", errno, pcap_strerror(errno));

                return -1;
        }
 
                return -1;
        }
 


@@ -112,7 +112,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                nftype_t type = OTHER;
 
                if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || len < nlh->nlmsg_len) {
                nftype_t type = OTHER;
 
                if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || len < nlh->nlmsg_len) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %d) (nlmsg_len: %u)", len, nlh->nlmsg_len);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %d) (nlmsg_len: %u)", len, nlh->nlmsg_len);

                        return -1;
                }
 
                        return -1;
                }
 


@@ -134,7 +134,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                                const struct nfattr *payload_attr = NULL;
 
                                if (nlh->nlmsg_len < HDR_LENGTH) {
                                const struct nfattr *payload_attr = NULL;
 
                                if (nlh->nlmsg_len < HDR_LENGTH) {

-                                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Malformed message: (nlmsg_len: %u)", nlh->nlmsg_len);
+                                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Malformed message: (nlmsg_len: %u)", nlh->nlmsg_len);

                                        return -1;
                                }
 
                                        return -1;
                                }
 


@@ -232,7 +232,7 @@ netfilter_stats_linux(pcap_t *handle, struct pcap_stat *stats)
 static int
 netfilter_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
 static int
 netfilter_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on netfilter devices");
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on netfilter devices");

        return (-1);
 }
 
        return (-1);
 }
 


@@ -439,7 +439,7 @@ netfilter_activate(pcap_t* handle)
                        char *end_dev;
 
                        if (group_count == 32) {
                        char *end_dev;
 
                        if (group_count == 32) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                                "Maximum 32 netfilter groups! dev: %s",
                                                handle->opt.source);
                                return PCAP_ERROR;
                                                "Maximum 32 netfilter groups! dev: %s",
                                                handle->opt.source);
                                return PCAP_ERROR;


@@ -448,7 +448,7 @@ netfilter_activate(pcap_t* handle)
                        group_id = strtol(dev, &end_dev, 0);
                        if (end_dev != dev) {
                                if (group_id < 0 || group_id > 65535) {
                        group_id = strtol(dev, &end_dev, 0);
                        if (end_dev != dev) {
                                if (group_id < 0 || group_id > 65535) {

-                                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                                        "Netfilter group range from 0 to 65535 (got %ld)",
                                                        group_id);
                                        return PCAP_ERROR;
                                                        "Netfilter group range from 0 to 65535 (got %ld)",
                                                        group_id);
                                        return PCAP_ERROR;


@@ -464,7 +464,7 @@ netfilter_activate(pcap_t* handle)
        }
 
        if (type == OTHER || *dev) {
        }
 
        if (type == OTHER || *dev) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "Can't get netfilter group(s) index from %s",
                                handle->opt.source);
                return PCAP_ERROR;
                                "Can't get netfilter group(s) index from %s",
                                handle->opt.source);
                return PCAP_ERROR;


@@ -491,7 +491,7 @@ netfilter_activate(pcap_t* handle)
        /* Create netlink socket */
        handle->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER);
        if (handle->fd < 0) {
        /* Create netlink socket */
        handle->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER);
        if (handle->fd < 0) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't create raw socket %d:%s", errno, pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't create raw socket %d:%s", errno, pcap_strerror(errno));

                return PCAP_ERROR;
        }
 
                return PCAP_ERROR;
        }
 


@@ -509,54 +509,54 @@ netfilter_activate(pcap_t* handle)
 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {
 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s", pcap_strerror(errno));
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate dump buffer: %s", pcap_strerror(errno));

                goto close_fail;
        }
 
        if (type == NFLOG) {
                if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
                goto close_fail;
        }
 
        if (type == NFLOG) {
                if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));

                        goto close_fail;
                }
 
                if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
                        goto close_fail;
                }
 
                if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_BIND, AF_INET) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));

                        goto close_fail;
                }
 
                /* Bind socket to the nflog groups */
                for (i = 0; i < group_count; i++) {
                        if (nflog_send_config_cmd(handle, groups[i], NFULNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
                        goto close_fail;
                }
 
                /* Bind socket to the nflog groups */
                for (i = 0; i < group_count; i++) {
                        if (nflog_send_config_cmd(handle, groups[i], NFULNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));

                                goto close_fail;
                        }
 
                        if (nflog_send_config_mode(handle, groups[i], NFULNL_COPY_PACKET, handle->snapshot) < 0) {
                                goto close_fail;
                        }
 
                        if (nflog_send_config_mode(handle, groups[i], NFULNL_COPY_PACKET, handle->snapshot) < 0) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_COPY_PACKET: %s", pcap_strerror(errno));
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_COPY_PACKET: %s", pcap_strerror(errno));

                                goto close_fail;
                        }
                }
 
        } else {
                if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
                                goto close_fail;
                        }
                }
 
        } else {
                if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));

                        goto close_fail;
                }
 
                if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
                        goto close_fail;
                }
 
                if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_BIND, AF_INET) < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));

                        goto close_fail;
                }
 
                /* Bind socket to the nfqueue groups */
                for (i = 0; i < group_count; i++) {
                        if (nfqueue_send_config_cmd(handle, groups[i], NFQNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
                        goto close_fail;
                }
 
                /* Bind socket to the nfqueue groups */
                for (i = 0; i < group_count; i++) {
                        if (nfqueue_send_config_cmd(handle, groups[i], NFQNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));

                                goto close_fail;
                        }
 
                        if (nfqueue_send_config_mode(handle, groups[i], NFQNL_COPY_PACKET, handle->snapshot) < 0) {
                                goto close_fail;
                        }
 
                        if (nfqueue_send_config_mode(handle, groups[i], NFQNL_COPY_PACKET, handle->snapshot) < 0) {

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_COPY_PACKET: %s", pcap_strerror(errno));
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_COPY_PACKET: %s", pcap_strerror(errno));

                                goto close_fail;
                        }
                }
                                goto close_fail;
                        }
                }


@@ -575,7 +575,7 @@ netfilter_activate(pcap_t* handle)
                 * Set the socket buffer size to the specified value.
                 */
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF, &handle->opt.buffer_size, sizeof(handle->opt.buffer_size)) == -1) {
                 * Set the socket buffer size to the specified value.
                 */
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF, &handle->opt.buffer_size, sizeof(handle->opt.buffer_size)) == -1) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "SO_RCVBUF: %s", pcap_strerror(errno));
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "SO_RCVBUF: %s", pcap_strerror(errno));

                        goto close_fail;
                }
        }
                        goto close_fail;
                }
        }


@@ -641,7 +641,7 @@ netfilter_findalldevs(pcap_if_t **alldevsp, char *err_str)
                /* if netlink is not supported this is not fatal */
                if (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT)
                        return 0;
                /* if netlink is not supported this is not fatal */
                if (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT)
                        return 0;

-               snprintf(err_str, PCAP_ERRBUF_SIZE, "Can't open netlink socket %d:%s",
+               pcap_snprintf(err_str, PCAP_ERRBUF_SIZE, "Can't open netlink socket %d:%s",

                        errno, pcap_strerror(errno));
                return -1;
        }
                        errno, pcap_strerror(errno));
                return -1;
        }

diff --git a/pcap-nit.c b/pcap-nit.c
index 36ed7758268e8a6a0d8fa881f19b70ae03cefd3f..a01665c57d6063d5656c0c3ead1840725c251ad7 100644 (file)
--- a/pcap-nit.c
+++ b/pcap-nit.c
@@ -114,7 +114,7 @@ pcap_read_nit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                if (cc < 0) {
                        if (errno == EWOULDBLOCK)
                                return (0);
                if (cc < 0) {
                        if (errno == EWOULDBLOCK)
                                return (0);

-                       snprintf(p->errbuf, sizeof(p->errbuf), "pcap_read: %s",
+                       pcap_snprintf(p->errbuf, sizeof(p->errbuf), "pcap_read: %s",

                                pcap_strerror(errno));
                        return (-1);
                }
                                pcap_strerror(errno));
                        return (-1);
                }


@@ -168,7 +168,7 @@ pcap_read_nit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                        continue;
 
                default:
                        continue;
 
                default:

-                       snprintf(p->errbuf, sizeof(p->errbuf),
+                       pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                            "bad nit state %d", nh->nh_state);
                        return (-1);
                }
                            "bad nit state %d", nh->nh_state);
                        return (-1);
                }


@@ -206,7 +206,7 @@ pcap_inject_nit(pcap_t *p, const void *buf, size_t size)
        strncpy(sa.sa_data, device, sizeof(sa.sa_data));
        ret = sendto(p->fd, buf, size, 0, &sa, sizeof(sa));
        if (ret == -1) {
        strncpy(sa.sa_data, device, sizeof(sa.sa_data));
        ret = sendto(p->fd, buf, size, 0, &sa, sizeof(sa));
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -249,7 +249,7 @@ nit_setflags(pcap_t *p)
                nioc.nioc_flags |= NF_PROMISC;
 
        if (ioctl(p->fd, SIOCSNIT, &nioc) < 0) {
                nioc.nioc_flags |= NF_PROMISC;
 
        if (ioctl(p->fd, SIOCSNIT, &nioc) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCSNIT: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCSNIT: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -280,7 +280,7 @@ pcap_activate_nit(pcap_t *p)
        memset(p, 0, sizeof(*p));
        p->fd = fd = socket(AF_NIT, SOCK_RAW, NITPROTO_RAW);
        if (fd < 0) {
        memset(p, 0, sizeof(*p));
        p->fd = fd = socket(AF_NIT, SOCK_RAW, NITPROTO_RAW);
        if (fd < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "socket: %s", pcap_strerror(errno));
                goto bad;
        }
                    "socket: %s", pcap_strerror(errno));
                goto bad;
        }


@@ -288,7 +288,7 @@ pcap_activate_nit(pcap_t *p)
        (void)strncpy(snit.snit_ifname, p->opt.source, NITIFSIZ);
 
        if (bind(fd, (struct sockaddr *)&snit, sizeof(snit))) {
        (void)strncpy(snit.snit_ifname, p->opt.source, NITIFSIZ);
 
        if (bind(fd, (struct sockaddr *)&snit, sizeof(snit))) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "bind: %s: %s", snit.snit_ifname, pcap_strerror(errno));
                goto bad;
        }
                    "bind: %s: %s", snit.snit_ifname, pcap_strerror(errno));
                goto bad;
        }

diff --git a/pcap-pf.c b/pcap-pf.c
index d9e9ec7604db25b42e76c6d3af737017746c83be..fbf02743ee0593fb64c964f009788cab095442ef 100644 (file)
--- a/pcap-pf.c
+++ b/pcap-pf.c
@@ -127,7 +127,7 @@ pcap_read_pf(pcap_t *pc, int cnt, pcap_handler callback, u_char *user)
                                (void)lseek(pc->fd, 0L, SEEK_SET);
                                goto again;
                        }
                                (void)lseek(pc->fd, 0L, SEEK_SET);
                                goto again;
                        }

-                       snprintf(pc->errbuf, sizeof(pc->errbuf), "pf read: %s",
+                       pcap_snprintf(pc->errbuf, sizeof(pc->errbuf), "pf read: %s",

                                pcap_strerror(errno));
                        return (-1);
                }
                                pcap_strerror(errno));
                        return (-1);
                }


@@ -160,7 +160,7 @@ pcap_read_pf(pcap_t *pc, int cnt, pcap_handler callback, u_char *user)
                        }
                }
                if (cc < sizeof(*sp)) {
                        }
                }
                if (cc < sizeof(*sp)) {

-                       snprintf(pc->errbuf, sizeof(pc->errbuf),
+                       pcap_snprintf(pc->errbuf, sizeof(pc->errbuf),

                            "pf short read (%d)", cc);
                        return (-1);
                }
                            "pf short read (%d)", cc);
                        return (-1);
                }


@@ -172,7 +172,7 @@ pcap_read_pf(pcap_t *pc, int cnt, pcap_handler callback, u_char *user)
 #endif
                        sp = (struct enstamp *)bp;
                if (sp->ens_stamplen != sizeof(*sp)) {
 #endif
                        sp = (struct enstamp *)bp;
                if (sp->ens_stamplen != sizeof(*sp)) {

-                       snprintf(pc->errbuf, sizeof(pc->errbuf),
+                       pcap_snprintf(pc->errbuf, sizeof(pc->errbuf),

                            "pf short stamplen (%d)",
                            sp->ens_stamplen);
                        return (-1);
                            "pf short stamplen (%d)",
                            sp->ens_stamplen);
                        return (-1);


@@ -232,7 +232,7 @@ pcap_inject_pf(pcap_t *p, const void *buf, size_t size)
 
        ret = write(p->fd, buf, size);
        if (ret == -1) {
 
        ret = write(p->fd, buf, size);
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -326,7 +326,7 @@ pcap_activate_pf(pcap_t *p)
        if (p->fd == -1 && errno == EACCES)
                p->fd = pfopen(p->opt.source, O_RDONLY);
        if (p->fd < 0) {
        if (p->fd == -1 && errno == EACCES)
                p->fd = pfopen(p->opt.source, O_RDONLY);
        if (p->fd < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "pf open: %s: %s\n\
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "pf open: %s: %s\n\

 your system may not be properly configured; see the packetfilter(4) man page\n",
                        p->opt.source, pcap_strerror(errno));
                goto bad;
 your system may not be properly configured; see the packetfilter(4) man page\n",
                        p->opt.source, pcap_strerror(errno));
                goto bad;


@@ -338,7 +338,7 @@ your system may not be properly configured; see the packetfilter(4) man page\n",
        if (p->opt.promisc)
                enmode |= ENPROMISC;
        if (ioctl(p->fd, EIOCMBIS, (caddr_t)&enmode) < 0) {
        if (p->opt.promisc)
                enmode |= ENPROMISC;
        if (ioctl(p->fd, EIOCMBIS, (caddr_t)&enmode) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCMBIS: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCMBIS: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -349,13 +349,13 @@ your system may not be properly configured; see the packetfilter(4) man page\n",
 #endif
        /* set the backlog */
        if (ioctl(p->fd, EIOCSETW, (caddr_t)&backlog) < 0) {
 #endif
        /* set the backlog */
        if (ioctl(p->fd, EIOCSETW, (caddr_t)&backlog) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCSETW: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCSETW: %s",

                    pcap_strerror(errno));
                goto bad;
        }
        /* discover interface type */
        if (ioctl(p->fd, EIOCDEVP, (caddr_t)&devparams) < 0) {
                    pcap_strerror(errno));
                goto bad;
        }
        /* discover interface type */
        if (ioctl(p->fd, EIOCDEVP, (caddr_t)&devparams) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCDEVP: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCDEVP: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -437,7 +437,7 @@ your system may not be properly configured; see the packetfilter(4) man page\n",
                 * framing", there's not much we can do, as that
                 * doesn't specify a particular type of header.
                 */
                 * framing", there's not much we can do, as that
                 * doesn't specify a particular type of header.
                 */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "unknown data-link type %u", devparams.end_dev_type);
                goto bad;
        }
                    "unknown data-link type %u", devparams.end_dev_type);
                goto bad;
        }


@@ -450,7 +450,7 @@ your system may not be properly configured; see the packetfilter(4) man page\n",
        } else
                p->fddipad = 0;
        if (ioctl(p->fd, EIOCTRUNCATE, (caddr_t)&p->snapshot) < 0) {
        } else
                p->fddipad = 0;
        if (ioctl(p->fd, EIOCTRUNCATE, (caddr_t)&p->snapshot) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCTRUNCATE: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCTRUNCATE: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -459,7 +459,7 @@ your system may not be properly configured; see the packetfilter(4) man page\n",
        Filter.enf_Priority = 37;       /* anything > 2 */
        Filter.enf_FilterLen = 0;       /* means "always true" */
        if (ioctl(p->fd, EIOCSETF, (caddr_t)&Filter) < 0) {
        Filter.enf_Priority = 37;       /* anything > 2 */
        Filter.enf_FilterLen = 0;       /* means "always true" */
        if (ioctl(p->fd, EIOCSETF, (caddr_t)&Filter) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCSETF: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCSETF: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -469,7 +469,7 @@ your system may not be properly configured; see the packetfilter(4) man page\n",
                timeout.tv_sec = p->opt.timeout / 1000;
                timeout.tv_usec = (p->opt.timeout * 1000) % 1000000;
                if (ioctl(p->fd, EIOCSRTIMEOUT, (caddr_t)&timeout) < 0) {
                timeout.tv_sec = p->opt.timeout / 1000;
                timeout.tv_usec = (p->opt.timeout * 1000) % 1000000;
                if (ioctl(p->fd, EIOCSRTIMEOUT, (caddr_t)&timeout) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCSRTIMEOUT: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "EIOCSRTIMEOUT: %s",

                                pcap_strerror(errno));
                        goto bad;
                }
                                pcap_strerror(errno));
                        goto bad;
                }


@@ -547,7 +547,7 @@ pcap_setfilter_pf(pcap_t *p, struct bpf_program *fp)
                         * Yes.  Try to install the filter.
                         */
                        if (ioctl(p->fd, BIOCSETF, (caddr_t)fp) < 0) {
                         * Yes.  Try to install the filter.
                         */
                        if (ioctl(p->fd, BIOCSETF, (caddr_t)fp) < 0) {

-                               snprintf(p->errbuf, sizeof(p->errbuf),
+                               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                                    "BIOCSETF: %s", pcap_strerror(errno));
                                return (-1);
                        }
                                    "BIOCSETF: %s", pcap_strerror(errno));
                                return (-1);
                        }

diff --git a/pcap-septel.c b/pcap-septel.c
index 61cd2f5775e717433e313c98552f1ddca597b9d1..2d23b9c0cfc4fd50a2d7f74cc040f0e7768f3006 100644 (file)
--- a/pcap-septel.c
+++ b/pcap-septel.c
@@ -276,7 +276,7 @@ static int septel_setfilter(pcap_t *p, struct bpf_program *fp) {
   /* Make our private copy of the filter */
 
   if (install_bpf_program(p, fp) < 0) {
   /* Make our private copy of the filter */
 
   if (install_bpf_program(p, fp) < 0) {

-    snprintf(p->errbuf, sizeof(p->errbuf),
+    pcap_snprintf(p->errbuf, sizeof(p->errbuf),

             "malloc: %s", pcap_strerror(errno));
     return -1;
   }
             "malloc: %s", pcap_strerror(errno));
     return -1;
   }

diff --git a/pcap-sita.c b/pcap-sita.c
index 52440c784fea6c6b3ade1c45d5f4d9e5718955d4..8fcdcc7e02a9d71c8d03f27005689ddf441d23d1 100644 (file)
--- a/pcap-sita.c
+++ b/pcap-sita.c
@@ -266,7 +266,7 @@ int acn_parse_hosts_file(char *errbuf) {                            /* returns: -1 = error, 0 = OK */
 
        empty_unit_table();
        if ((fp = fopen("/etc/hosts", "r")) == NULL) {                                                                          /* try to open the hosts file and if it fails */
 
        empty_unit_table();
        if ((fp = fopen("/etc/hosts", "r")) == NULL) {                                                                          /* try to open the hosts file and if it fails */

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "Cannot open '/etc/hosts' for reading.");    /* return the nohostsfile error response */
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "Cannot open '/etc/hosts' for reading.");       /* return the nohostsfile error response */

                return -1;
        }
        while (fgets(buf, MAX_LINE_SIZE-1, fp)) {                       /* while looping over the file */
                return -1;
        }
        while (fgets(buf, MAX_LINE_SIZE-1, fp)) {                       /* while looping over the file */


@@ -289,11 +289,11 @@ int acn_parse_hosts_file(char *errbuf) {                          /* returns: -1 = error, 0 = OK */
                geoslot = *(ptr2 + 5) - '0';                                    /* and geo-slot number */
                if (chassis < 1 || chassis > MAX_CHASSIS ||
                        geoslot < 1 || geoslot > MAX_GEOSLOT) {         /* if the chassis and/or slot numbers appear to be bad... */
                geoslot = *(ptr2 + 5) - '0';                                    /* and geo-slot number */
                if (chassis < 1 || chassis > MAX_CHASSIS ||
                        geoslot < 1 || geoslot > MAX_GEOSLOT) {         /* if the chassis and/or slot numbers appear to be bad... */

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "Invalid ACN name in '/etc/hosts'.");        /* warn the user */
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "Invalid ACN name in '/etc/hosts'.");   /* warn the user */

                        continue;                                                                                                                                       /* and ignore the entry */
                }
                if ((ptr2 = (char *)malloc(strlen(ptr) + 1)) == NULL) {
                        continue;                                                                                                                                       /* and ignore the entry */
                }
                if ((ptr2 = (char *)malloc(strlen(ptr) + 1)) == NULL) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                        continue;
                }
                strcpy(ptr2, ptr);                                                              /* copy the IP address into our malloc'ed memory */
                        continue;
                }
                strcpy(ptr2, ptr);                                                              /* copy the IP address into our malloc'ed memory */


@@ -406,14 +406,14 @@ static void acn_freealldevs(void) {
 
 static void nonUnified_IOP_port_name(char *buf, size_t bufsize, const char *proto, unit_t *u) {
 
 
 static void nonUnified_IOP_port_name(char *buf, size_t bufsize, const char *proto, unit_t *u) {
 

-       snprintf(buf, bufsize, "%s_%d_%d", proto, u->chassis, u->geoslot);
+       pcap_snprintf(buf, bufsize, "%s_%d_%d", proto, u->chassis, u->geoslot);

 }
 
 static void unified_IOP_port_name(char *buf, size_t bufsize, const char *proto, unit_t *u, int IOPportnum) {
        int                     portnum;
 
        portnum = ((u->chassis - 1) * 64) + ((u->geoslot - 1) * 8) + IOPportnum + 1;
 }
 
 static void unified_IOP_port_name(char *buf, size_t bufsize, const char *proto, unit_t *u, int IOPportnum) {
        int                     portnum;
 
        portnum = ((u->chassis - 1) * 64) + ((u->geoslot - 1) * 8) + IOPportnum + 1;

-       snprintf(buf, bufsize, "%s_%d", proto, portnum);
+       pcap_snprintf(buf, bufsize, "%s_%d", proto, portnum);

 }
 
 static char *translate_IOP_to_pcap_name(unit_t *u, char *IOPname, bpf_u_int32 iftype) {
 }
 
 static char *translate_IOP_to_pcap_name(unit_t *u, char *IOPname, bpf_u_int32 iftype) {


@@ -582,7 +582,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                        ptr = u->imsg;                                                                                                  /* point to the start of the msg for this IOP */
                        while (ptr < (u->imsg + u->len)) {
                                if ((iff = malloc(sizeof(pcap_if_t))) == NULL) {
                        ptr = u->imsg;                                                                                                  /* point to the start of the msg for this IOP */
                        while (ptr < (u->imsg + u->len)) {
                                if ((iff = malloc(sizeof(pcap_if_t))) == NULL) {

-                                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                        return -1;
                                }
                                memset((char *)iff, 0, sizeof(pcap_if_t)); /* bzero() is deprecated, replaced with memset() */
                                        return -1;
                                }
                                memset((char *)iff, 0, sizeof(pcap_if_t)); /* bzero() is deprecated, replaced with memset() */


@@ -591,7 +591,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
 
                                if (*ptr) {                                                                                                     /* if there is a count for the name */
                                        if ((iff->name = malloc(*ptr + 1)) == NULL) {                   /* get that amount of space */
 
                                if (*ptr) {                                                                                                     /* if there is a count for the name */
                                        if ((iff->name = malloc(*ptr + 1)) == NULL) {                   /* get that amount of space */

-                                               snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                return -1;
                                        }
                                        memcpy(iff->name, (ptr + 1), *ptr);                                             /* copy the name into the malloc'ed space */
                                                return -1;
                                        }
                                        memcpy(iff->name, (ptr + 1), *ptr);                                             /* copy the name into the malloc'ed space */


@@ -602,7 +602,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
 
                                if (*ptr) {                                                                                                     /* if there is a count for the description */
                                        if ((iff->description = malloc(*ptr + 1)) == NULL) {    /* get that amount of space */
 
                                if (*ptr) {                                                                                                     /* if there is a count for the description */
                                        if ((iff->description = malloc(*ptr + 1)) == NULL) {    /* get that amount of space */

-                                               snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                return -1;
                                        }
                                        memcpy(iff->description, (ptr + 1), *ptr);                              /* copy the name into the malloc'ed space */
                                                return -1;
                                        }
                                        memcpy(iff->description, (ptr + 1), *ptr);                              /* copy the name into the malloc'ed space */


@@ -622,7 +622,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                                prev_addr = 0;
                                while (address_count--) {
                                        if ((addr = malloc(sizeof(pcap_addr_t))) == NULL) {
                                prev_addr = 0;
                                while (address_count--) {
                                        if ((addr = malloc(sizeof(pcap_addr_t))) == NULL) {

-                                               snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                return -1;
                                        }
                                        memset((char *)addr, 0, sizeof(pcap_addr_t)); /* bzero() is deprecated, replaced with memset() */
                                                return -1;
                                        }
                                        memset((char *)addr, 0, sizeof(pcap_addr_t)); /* bzero() is deprecated, replaced with memset() */


@@ -630,7 +630,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                                        if (prev_addr) prev_addr->next = addr;                                                  /* insert a forward link */
                                        if (*ptr) {                                                                                                             /* if there is a count for the address */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {         /* get that amount of space */
                                        if (prev_addr) prev_addr->next = addr;                                                  /* insert a forward link */
                                        if (*ptr) {                                                                                                             /* if there is a count for the address */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {         /* get that amount of space */

-                                                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                        return -1;
                                                }
                                                memset((char *)s, 0, sizeof(struct sockaddr_in)); /* bzero() is deprecated, replaced with memset() */
                                                        return -1;
                                                }
                                                memset((char *)s, 0, sizeof(struct sockaddr_in)); /* bzero() is deprecated, replaced with memset() */


@@ -642,7 +642,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                                        ptr++;                                                                                                  /* then forwards one more for the 'length of the address' field */
                                        if (*ptr) {                                                                                             /* process any netmask */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
                                        ptr++;                                                                                                  /* then forwards one more for the 'length of the address' field */
                                        if (*ptr) {                                                                                             /* process any netmask */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {

-                                                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                        return -1;
                                                }
                                                /* bzero() is deprecated, replaced with memset() */
                                                        return -1;
                                                }
                                                /* bzero() is deprecated, replaced with memset() */


@@ -656,7 +656,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                                        ptr++;
                                        if (*ptr) {                                                                                             /* process any broadcast address */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
                                        ptr++;
                                        if (*ptr) {                                                                                             /* process any broadcast address */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {

-                                                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                        return -1;
                                                }
                                                /* bzero() is deprecated, replaced with memset() */
                                                        return -1;
                                                }
                                                /* bzero() is deprecated, replaced with memset() */


@@ -670,7 +670,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                                        ptr++;
                                        if (*ptr) {                                                                                             /* process any destination address */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {
                                        ptr++;
                                        if (*ptr) {                                                                                             /* process any destination address */
                                                if ((s = malloc(sizeof(struct sockaddr_in))) == NULL) {

-                                                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                                                        return -1;
                                                }
                                                /* bzero() is deprecated, replaced with memset() */
                                                        return -1;
                                                }
                                                /* bzero() is deprecated, replaced with memset() */


@@ -689,7 +689,7 @@ static int process_client_data (char *errbuf) {                                                             /* returns: -1 = error, 0
                                newname = translate_IOP_to_pcap_name(u, iff->name, interfaceType);              /* add a translation entry and get a point to the mangled name */
                                bigger_buffer = realloc(iff->name, strlen(newname) + 1));
                                if (bigger_buffer == NULL) {    /* we now re-write the name stored in the interface list */
                                newname = translate_IOP_to_pcap_name(u, iff->name, interfaceType);              /* add a translation entry and get a point to the mangled name */
                                bigger_buffer = realloc(iff->name, strlen(newname) + 1));
                                if (bigger_buffer == NULL) {    /* we now re-write the name stored in the interface list */

-                                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "realloc: %s", pcap_strerror(errno));
+                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "realloc: %s", pcap_strerror(errno));

                                        return -1;
                                }
                                iff->name = bigger_buffer;
                                        return -1;
                                }
                                iff->name = bigger_buffer;


@@ -899,7 +899,7 @@ static int pcap_setfilter_acn(pcap_t *handle, struct bpf_program *bpf) {
 }
 
 static int pcap_setdirection_acn(pcap_t *handle, pcap_direction_t d) {
 }
 
 static int pcap_setdirection_acn(pcap_t *handle, pcap_direction_t d) {

-       snprintf(handle->errbuf, sizeof(handle->errbuf),
+       pcap_snprintf(handle->errbuf, sizeof(handle->errbuf),

            "Setting direction is not supported on ACN adapters");
        return -1;
 }
            "Setting direction is not supported on ACN adapters");
        return -1;
 }


@@ -999,7 +999,7 @@ static int pcap_activate_sita(pcap_t *handle) {
 
        handle->buffer   = malloc(handle->bufsize + handle->offset);
        if (!handle->buffer) {
 
        handle->buffer   = malloc(handle->bufsize + handle->offset);
        if (!handle->buffer) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "malloc: %s", pcap_strerror(errno));
                pcap_cleanup_acn(handle);
                return PCAP_ERROR;
                         "malloc: %s", pcap_strerror(errno));
                pcap_cleanup_acn(handle);
                return PCAP_ERROR;

diff --git a/pcap-snf.c b/pcap-snf.c
index bfa0990e0f6ddfe4fa378811381a076b32cd999a..2271fd668b9139c29e3f68295b80a36be1286ab2 100644 (file)
--- a/pcap-snf.c
+++ b/pcap-snf.c
@@ -51,7 +51,7 @@ snf_pcap_stats(pcap_t *p, struct pcap_stat *ps)
        int rc;
 
        if ((rc = snf_ring_getstats(snfps->snf_ring, &stats))) {
        int rc;
 
        if ((rc = snf_ring_getstats(snfps->snf_ring, &stats))) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_get_stats: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_get_stats: %s",

                         pcap_strerror(rc));
                return -1;
        }
                         pcap_strerror(rc));
                return -1;
        }


@@ -164,7 +164,7 @@ snf_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                continue;
                        }
                        else {
                                continue;
                        }
                        else {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_read: %s",
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_read: %s",

                                         pcap_strerror(err));
                                return -1;
                        }
                                         pcap_strerror(err));
                                return -1;
                        }


@@ -219,7 +219,7 @@ snf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
         if (ps->snf_inj == NULL) {
                 rc = snf_inject_open(ps->snf_boardnum, 0, &ps->snf_inj);
                 if (rc) {
         if (ps->snf_inj == NULL) {
                 rc = snf_inject_open(ps->snf_boardnum, 0, &ps->snf_inj);
                 if (rc) {

-                        snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                        pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                 "snf_inject_open: %s", pcap_strerror(rc));
                         return (-1);
                 }
                                 "snf_inject_open: %s", pcap_strerror(rc));
                         return (-1);
                 }


@@ -230,7 +230,7 @@ snf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
                 return (size);
         }
         else {
                 return (size);
         }
         else {

-                snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_inject_send: %s",
+                pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snf_inject_send: %s",

                          pcap_strerror(rc));
                 return (-1);
         }
                          pcap_strerror(rc));
                 return (-1);
         }


@@ -251,7 +251,7 @@ snf_activate(pcap_t* p)
        int flags = -1, ring_id = -1;
 
        if (device == NULL) {
        int flags = -1, ring_id = -1;
 
        if (device == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                         "device is NULL: %s", pcap_strerror(errno));
                return -1;
        }
                         "device is NULL: %s", pcap_strerror(errno));
                return -1;
        }


@@ -272,7 +272,7 @@ snf_activate(pcap_t* p)
                        flags, /* may want pshared */
                        &ps->snf_handle);
        if (err != 0) {
                        flags, /* may want pshared */
                        &ps->snf_handle);
        if (err != 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                         "snf_open failed: %s", pcap_strerror(err));
                return -1;
        }
                         "snf_open failed: %s", pcap_strerror(err));
                return -1;
        }


@@ -282,7 +282,7 @@ snf_activate(pcap_t* p)
        }
        err = snf_ring_open_id(ps->snf_handle, ring_id, &ps->snf_ring);
        if (err != 0) {
        }
        err = snf_ring_open_id(ps->snf_handle, ring_id, &ps->snf_ring);
        if (err != 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                         "snf_ring_open_id(ring=%d) failed: %s",
                         ring_id, pcap_strerror(err));
                return -1;
                         "snf_ring_open_id(ring=%d) failed: %s",
                         ring_id, pcap_strerror(err));
                return -1;


@@ -295,7 +295,7 @@ snf_activate(pcap_t* p)
 
        err = snf_start(ps->snf_handle);
        if (err != 0) {
 
        err = snf_start(ps->snf_handle);
        if (err != 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                         "snf_start failed: %s", pcap_strerror(err));
                return -1;
        }
                         "snf_start failed: %s", pcap_strerror(err));
                return -1;
        }


@@ -335,7 +335,7 @@ snf_findalldevs(pcap_if_t **devlistp, char *errbuf)
 
        if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL)
        {
 
        if (snf_getifaddrs(&ifaddrs) || ifaddrs == NULL)
        {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                        "snf_getifaddrs: %s", pcap_strerror(errno));
                return (-1);
        }
                        "snf_getifaddrs: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -347,7 +347,7 @@ snf_findalldevs(pcap_if_t **devlistp, char *errbuf)
                 */
                curdev = (pcap_if_t *)malloc(sizeof(pcap_if_t));
                if (curdev == NULL) {
                 */
                curdev = (pcap_if_t *)malloc(sizeof(pcap_if_t));
                if (curdev == NULL) {

-               (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                        "snf_findalldevs malloc: %s", pcap_strerror(errno));
                        return (-1);
                }
                        "snf_findalldevs malloc: %s", pcap_strerror(errno));
                        return (-1);
                }


@@ -361,16 +361,16 @@ snf_findalldevs(pcap_if_t **devlistp, char *errbuf)
                curdev->next = NULL;
                curdev->name = strdup(ifa->snf_ifa_name);
                if (curdev->name == NULL) {
                curdev->next = NULL;
                curdev->name = strdup(ifa->snf_ifa_name);
                if (curdev->name == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "snf_findalldevs strdup: %s", pcap_strerror(errno));
                        free(curdev);
                        return (-1);
                }
                            "snf_findalldevs strdup: %s", pcap_strerror(errno));
                        free(curdev);
                        return (-1);
                }

-               (void)snprintf(desc,MAX_DESC_LENGTH,"Myricom snf%d",
+               (void)pcap_snprintf(desc,MAX_DESC_LENGTH,"Myricom snf%d",

                                ifa->snf_ifa_portnum);
                curdev->description = strdup(desc);
                if (curdev->description == NULL) {
                                ifa->snf_ifa_portnum);
                curdev->description = strdup(desc);
                if (curdev->description == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                        "snf_findalldevs strdup1: %s", pcap_strerror(errno));
                        free(curdev->name);
                        free(curdev);
                        "snf_findalldevs strdup1: %s", pcap_strerror(errno));
                        free(curdev->name);
                        free(curdev);


@@ -381,7 +381,7 @@ snf_findalldevs(pcap_if_t **devlistp, char *errbuf)
 
                curaddr = (pcap_addr_t *)malloc(sizeof(pcap_addr_t));
                if (curaddr == NULL) {
 
                curaddr = (pcap_addr_t *)malloc(sizeof(pcap_addr_t));
                if (curaddr == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                             "snf_findalldevs malloc1: %s", pcap_strerror(errno));
                        free(curdev->description);
                        free(curdev->name);
                             "snf_findalldevs malloc1: %s", pcap_strerror(errno));
                        free(curdev->description);
                        free(curdev->name);


@@ -392,7 +392,7 @@ snf_findalldevs(pcap_if_t **devlistp, char *errbuf)
                curaddr->next = NULL;
                curaddr->addr = (struct sockaddr*)malloc(sizeof(struct sockaddr_storage));
                if (curaddr->addr == NULL) {
                curaddr->next = NULL;
                curaddr->addr = (struct sockaddr*)malloc(sizeof(struct sockaddr_storage));
                if (curaddr->addr == NULL) {

-                       (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "malloc2: %s", pcap_strerror(errno));
                        free(curdev->description);
                        free(curdev->name);
                            "malloc2: %s", pcap_strerror(errno));
                        free(curdev->description);
                        free(curdev->name);


@@ -481,7 +481,7 @@ snf_create(const char *device, char *ebuf, int *is_ours)
        p->tstamp_precision_count = 2;
        p->tstamp_precision_list = malloc(2 * sizeof(u_int));
        if (p->tstamp_precision_list == NULL) {
        p->tstamp_precision_count = 2;
        p->tstamp_precision_list = malloc(2 * sizeof(u_int));
        if (p->tstamp_precision_list == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                pcap_close(p);
                return NULL;
                    pcap_strerror(errno));
                pcap_close(p);
                return NULL;

diff --git a/pcap-snit.c b/pcap-snit.c
index c6d8a93ff100419a4c299e3d8b9f25052deadfc7..21d08cae61597192f1b97b7e1c1d7c406c1b7ec1 100644 (file)
--- a/pcap-snit.c
+++ b/pcap-snit.c
@@ -130,7 +130,7 @@ pcap_read_snit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                if (cc < 0) {
                        if (errno == EWOULDBLOCK)
                                return (0);
                if (cc < 0) {
                        if (errno == EWOULDBLOCK)
                                return (0);

-                       snprintf(p->errbuf, sizeof(p->errbuf), "pcap_read: %s",
+                       pcap_snprintf(p->errbuf, sizeof(p->errbuf), "pcap_read: %s",

                                pcap_strerror(errno));
                        return (-1);
                }
                                pcap_strerror(errno));
                        return (-1);
                }


@@ -223,7 +223,7 @@ pcap_inject_snit(pcap_t *p, const void *buf, size_t size)
        data.len = size;
        ret = putmsg(p->fd, &ctl, &data);
        if (ret == -1) {
        data.len = size;
        ret = putmsg(p->fd, &ctl, &data);
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -247,7 +247,7 @@ nit_setflags(pcap_t *p)
                si.ic_len = sizeof(zero);
                si.ic_dp = (char *)&zero;
                if (ioctl(p->fd, I_STR, (char *)&si) < 0) {
                si.ic_len = sizeof(zero);
                si.ic_dp = (char *)&zero;
                if (ioctl(p->fd, I_STR, (char *)&si) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSCHUNK: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSCHUNK: %s",

                            pcap_strerror(errno));
                        return (-1);
                }
                            pcap_strerror(errno));
                        return (-1);
                }


@@ -260,7 +260,7 @@ nit_setflags(pcap_t *p)
                si.ic_len = sizeof(timeout);
                si.ic_dp = (char *)&timeout;
                if (ioctl(p->fd, I_STR, (char *)&si) < 0) {
                si.ic_len = sizeof(timeout);
                si.ic_dp = (char *)&timeout;
                if (ioctl(p->fd, I_STR, (char *)&si) < 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSTIME: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSTIME: %s",

                            pcap_strerror(errno));
                        return (-1);
                }
                            pcap_strerror(errno));
                        return (-1);
                }


@@ -272,7 +272,7 @@ nit_setflags(pcap_t *p)
        si.ic_len = sizeof(flags);
        si.ic_dp = (char *)&flags;
        if (ioctl(p->fd, I_STR, (char *)&si) < 0) {
        si.ic_len = sizeof(flags);
        si.ic_dp = (char *)&flags;
        if (ioctl(p->fd, I_STR, (char *)&si) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSFLAGS: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSFLAGS: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -320,19 +320,19 @@ pcap_activate_snit(pcap_t *p)
        if (fd < 0 && errno == EACCES)
                p->fd = fd = open(dev, O_RDONLY);
        if (fd < 0) {
        if (fd < 0 && errno == EACCES)
                p->fd = fd = open(dev, O_RDONLY);
        if (fd < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s", dev,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s", dev,

                    pcap_strerror(errno));
                goto bad;
        }
 
        /* arrange to get discrete messages from the STREAM and use NIT_BUF */
        if (ioctl(fd, I_SRDOPT, (char *)RMSGD) < 0) {
                    pcap_strerror(errno));
                goto bad;
        }
 
        /* arrange to get discrete messages from the STREAM and use NIT_BUF */
        if (ioctl(fd, I_SRDOPT, (char *)RMSGD) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "I_SRDOPT: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "I_SRDOPT: %s",

                    pcap_strerror(errno));
                goto bad;
        }
        if (ioctl(fd, I_PUSH, "nbuf") < 0) {
                    pcap_strerror(errno));
                goto bad;
        }
        if (ioctl(fd, I_PUSH, "nbuf") < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "push nbuf: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "push nbuf: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -342,7 +342,7 @@ pcap_activate_snit(pcap_t *p)
        si.ic_len = sizeof(chunksize);
        si.ic_dp = (char *)&chunksize;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {
        si.ic_len = sizeof(chunksize);
        si.ic_dp = (char *)&chunksize;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSCHUNK: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSCHUNK: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -354,7 +354,7 @@ pcap_activate_snit(pcap_t *p)
        si.ic_len = sizeof(ifr);
        si.ic_dp = (char *)&ifr;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {
        si.ic_len = sizeof(ifr);
        si.ic_dp = (char *)&ifr;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCBIND: %s: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCBIND: %s: %s",

                        ifr.ifr_name, pcap_strerror(errno));
                goto bad;
        }
                        ifr.ifr_name, pcap_strerror(errno));
                goto bad;
        }


@@ -364,7 +364,7 @@ pcap_activate_snit(pcap_t *p)
        si.ic_len = sizeof(p->snapshot);
        si.ic_dp = (char *)&p->snapshot;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {
        si.ic_len = sizeof(p->snapshot);
        si.ic_dp = (char *)&p->snapshot;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSSNAP: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSSNAP: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }

diff --git a/pcap-snoop.c b/pcap-snoop.c
index 10b93aa66dc291abbc6fa30a5fdc596bf524e333..2c0944a7580b2feb2c64446f265d3a8e8bb51087 100644 (file)
--- a/pcap-snoop.c
+++ b/pcap-snoop.c
@@ -95,7 +95,7 @@ again:
                case EWOULDBLOCK:
                        return (0);                     /* XXX */
                }
                case EWOULDBLOCK:
                        return (0);                     /* XXX */
                }

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "read: %s", pcap_strerror(errno));
                return (-1);
        }
                    "read: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -150,7 +150,7 @@ pcap_inject_snoop(pcap_t *p, const void *buf, size_t size)
         */
        ret = write(p->fd, buf, size);
        if (ret == -1) {
         */
        ret = write(p->fd, buf, size);
        if (ret == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -167,7 +167,7 @@ pcap_stats_snoop(pcap_t *p, struct pcap_stat *ps)
        rs = &rawstats;
        memset(rs, 0, sizeof(*rs));
        if (ioctl(p->fd, SIOCRAWSTATS, (char *)rs) < 0) {
        rs = &rawstats;
        memset(rs, 0, sizeof(*rs));
        if (ioctl(p->fd, SIOCRAWSTATS, (char *)rs) < 0) {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "SIOCRAWSTATS: %s", pcap_strerror(errno));
                return (-1);
        }
                    "SIOCRAWSTATS: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -212,7 +212,7 @@ pcap_activate_snoop(pcap_t *p)
 
        fd = socket(PF_RAW, SOCK_RAW, RAWPROTO_SNOOP);
        if (fd < 0) {
 
        fd = socket(PF_RAW, SOCK_RAW, RAWPROTO_SNOOP);
        if (fd < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snoop socket: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snoop socket: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -221,13 +221,13 @@ pcap_activate_snoop(pcap_t *p)
        sr.sr_family = AF_RAW;
        (void)strncpy(sr.sr_ifname, p->opt.source, sizeof(sr.sr_ifname));
        if (bind(fd, (struct sockaddr *)&sr, sizeof(sr))) {
        sr.sr_family = AF_RAW;
        (void)strncpy(sr.sr_ifname, p->opt.source, sizeof(sr.sr_ifname));
        if (bind(fd, (struct sockaddr *)&sr, sizeof(sr))) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snoop bind: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "snoop bind: %s",

                    pcap_strerror(errno));
                goto bad;
        }
        memset(&sf, 0, sizeof(sf));
        if (ioctl(fd, SIOCADDSNOOP, &sf) < 0) {
                    pcap_strerror(errno));
                goto bad;
        }
        memset(&sf, 0, sizeof(sf));
        if (ioctl(fd, SIOCADDSNOOP, &sf) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCADDSNOOP: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCADDSNOOP: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -303,7 +303,7 @@ pcap_activate_snoop(pcap_t *p)
                p->linktype = DLT_NULL;
                ll_hdrlen = 4;
        } else {
                p->linktype = DLT_NULL;
                ll_hdrlen = 4;
        } else {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "snoop: unknown physical layer type");
                goto bad;
        }
                    "snoop: unknown physical layer type");
                goto bad;
        }


@@ -325,7 +325,7 @@ pcap_activate_snoop(pcap_t *p)
         */
        (void)strncpy(ifr.ifr_name, p->opt.source, sizeof(ifr.ifr_name));
        if (ioctl(fd, SIOCGIFMTU, (char *)&ifr) < 0) {
         */
        (void)strncpy(ifr.ifr_name, p->opt.source, sizeof(ifr.ifr_name));
        if (ioctl(fd, SIOCGIFMTU, (char *)&ifr) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCGIFMTU: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCGIFMTU: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -359,13 +359,13 @@ pcap_activate_snoop(pcap_t *p)
        if (snooplen < 0)
                snooplen = 0;
        if (ioctl(fd, SIOCSNOOPLEN, &snooplen) < 0) {
        if (snooplen < 0)
                snooplen = 0;
        if (ioctl(fd, SIOCSNOOPLEN, &snooplen) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCSNOOPLEN: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCSNOOPLEN: %s",

                    pcap_strerror(errno));
                goto bad;
        }
        v = 1;
        if (ioctl(fd, SIOCSNOOPING, &v) < 0) {
                    pcap_strerror(errno));
                goto bad;
        }
        v = 1;
        if (ioctl(fd, SIOCSNOOPING, &v) < 0) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCSNOOPING: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "SIOCSNOOPING: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }


@@ -373,7 +373,7 @@ pcap_activate_snoop(pcap_t *p)
        p->bufsize = 4096;                              /* XXX */
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {
        p->bufsize = 4096;                              /* XXX */
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                goto bad;
        }
                    pcap_strerror(errno));
                goto bad;
        }

diff --git a/pcap-stdinc.h b/pcap-stdinc.h
index 65ee419358a6a5ed3ba2ee018f7f81f17090b24d..b890b647374e2e0e8aa6177cf4045e814c39c8e9 100644 (file)
--- a/pcap-stdinc.h
+++ b/pcap-stdinc.h
@@ -164,11 +164,7 @@
   #endif
 #endif
 
   #endif
 #endif
 

-#define caddr_t char*
-

 #ifdef _MSC_VER
 #ifdef _MSC_VER

-  #define snprintf  _snprintf
-  #define vsnprintf _vsnprintf

   #define strdup    _strdup
 #endif
 
   #define strdup    _strdup
 #endif
 

diff --git a/pcap-tc.c b/pcap-tc.c
index b022583b38dc40b82e6037e7d7a300d9e04551d4..da2f6f3b3d52885adc052804b31f504d12ac1808 100644 (file)
--- a/pcap-tc.c
+++ b/pcap-tc.c
@@ -565,7 +565,7 @@ TcActivate(pcap_t *p)
 
        if (pt->PpiPacket == NULL)
        {
 
        if (pt->PpiPacket == NULL)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Error allocating memory");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Error allocating memory");

                return PCAP_ERROR;
        }
 
                return PCAP_ERROR;
        }
 


@@ -589,7 +589,7 @@ TcActivate(pcap_t *p)
        if (status != TC_SUCCESS)
        {
                /* Adapter detected but we are not able to open it. Return failure. */
        if (status != TC_SUCCESS)
        {
                /* Adapter detected but we are not able to open it. Return failure. */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Error opening TurboCap adapter: %s", g_TcFunctions.StatusGetString(status));
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Error opening TurboCap adapter: %s", g_TcFunctions.StatusGetString(status));

                return PCAP_ERROR;
        }
 
                return PCAP_ERROR;
        }
 


@@ -621,7 +621,7 @@ TcActivate(pcap_t *p)
 
        if (status != TC_SUCCESS)
        {
 
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,"Error enabling reception on a TurboCap instance: %s", g_TcFunctions.StatusGetString(status));
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,"Error enabling reception on a TurboCap instance: %s", g_TcFunctions.StatusGetString(status));

                goto bad;
        }
 
                goto bad;
        }
 


@@ -660,7 +660,7 @@ TcActivate(pcap_t *p)
 
        if (status != TC_SUCCESS)
        {
 
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,"Error setting the read timeout a TurboCap instance: %s", g_TcFunctions.StatusGetString(status));
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,"Error setting the read timeout a TurboCap instance: %s", g_TcFunctions.StatusGetString(status));

                goto bad;
        }
 
                goto bad;
        }
 


@@ -776,18 +776,18 @@ static int TcSetDatalink(pcap_t *p, int dlt)
 
 static int TcGetNonBlock(pcap_t *p, char *errbuf)
 {
 
 static int TcGetNonBlock(pcap_t *p, char *errbuf)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Getting the non blocking status is not available for TurboCap ports");
                    "Getting the non blocking status is not available for TurboCap ports");

-       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "Getting the non blocking status is not available for TurboCap ports");
                return -1;
 
 }
 static int TcSetNonBlock(pcap_t *p, int nonblock, char *errbuf)
 {
                    "Getting the non blocking status is not available for TurboCap ports");
                return -1;
 
 }
 static int TcSetNonBlock(pcap_t *p, int nonblock, char *errbuf)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Setting the non blocking status is not available for TurboCap ports");
                    "Setting the non blocking status is not available for TurboCap ports");

-       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "Setting the non blocking status is not available for TurboCap ports");
                return -1;
 }
                    "Setting the non blocking status is not available for TurboCap ports");
                return -1;
 }


@@ -830,7 +830,7 @@ static int TcInject(pcap_t *p, const void *buf, size_t size)
 
        if (size >= 0xFFFF)
        {
 
        if (size >= 0xFFFF)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: the TurboCap API does not support packets larger than 64k");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: the TurboCap API does not support packets larger than 64k");

                return -1;
        }
 
                return -1;
        }
 


@@ -838,7 +838,7 @@ static int TcInject(pcap_t *p, const void *buf, size_t size)
 
        if (status != TC_SUCCESS)
        {
 
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: TcPacketsBufferCreate failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: TcPacketsBufferCreate failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return -1;
        }
 
                return -1;
        }
 


@@ -858,12 +858,12 @@ static int TcInject(pcap_t *p, const void *buf, size_t size)
 
                if (status != TC_SUCCESS)
                {
 
                if (status != TC_SUCCESS)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: TcInstanceTransmitPackets failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: TcInstanceTransmitPackets failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                }
        }
        else
        {
                }
        }
        else
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: TcPacketsBufferCommitNextPacket failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: TcPacketsBufferCommitNextPacket failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

        }
 
        g_TcFunctions.PacketsBufferDestroy(buffer);
        }
 
        g_TcFunctions.PacketsBufferDestroy(buffer);


@@ -903,7 +903,7 @@ static int TcRead(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                status = g_TcFunctions.InstanceReceivePackets(pt->TcInstance, &pt->TcPacketsBuffer);
                if (status != TC_SUCCESS)
                {
                status = g_TcFunctions.InstanceReceivePackets(pt->TcInstance, &pt->TcPacketsBuffer);
                if (status != TC_SUCCESS)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error, TcInstanceReceivePackets failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error, TcInstanceReceivePackets failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                        return -1;
                }
        }
                        return -1;
                }
        }


@@ -953,7 +953,7 @@ static int TcRead(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 
                if (status != TC_SUCCESS)
                {
 
                if (status != TC_SUCCESS)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error, TcPacketsBufferQueryNextPacket failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error, TcPacketsBufferQueryNextPacket failure: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                        return -1;
                }
 
                        return -1;
                }
 


@@ -1043,7 +1043,7 @@ TcStats(pcap_t *p, struct pcap_stat *ps)
 
        if (status != TC_SUCCESS)
        {
 
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcInstanceQueryStatistics: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcInstanceQueryStatistics: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return -1;
        }
 
                return -1;
        }
 


@@ -1052,7 +1052,7 @@ TcStats(pcap_t *p, struct pcap_stat *ps)
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_TOTAL_RX_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_TOTAL_RX_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return -1;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)
                return -1;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)


@@ -1067,7 +1067,7 @@ TcStats(pcap_t *p, struct pcap_stat *ps)
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_RX_DROPPED_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_RX_DROPPED_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return -1;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)
                return -1;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)


@@ -1105,7 +1105,7 @@ TcSetFilter(pcap_t *p, struct bpf_program *fp)
        /* Install a user level filter */
        if (install_bpf_program(p, fp) < 0)
        {
        /* Install a user level filter */
        if (install_bpf_program(p, fp) < 0)
        {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                        "setfilter, unable to install the filter: %s", pcap_strerror(errno));
                return -1;
        }
                        "setfilter, unable to install the filter: %s", pcap_strerror(errno));
                return -1;
        }


@@ -1128,7 +1128,7 @@ TcStatsEx(pcap_t *p, int *pcap_stat_size)
 
        if (status != TC_SUCCESS)
        {
 
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcInstanceQueryStatistics: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcInstanceQueryStatistics: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return NULL;
        }
 
                return NULL;
        }
 


@@ -1137,7 +1137,7 @@ TcStatsEx(pcap_t *p, int *pcap_stat_size)
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_TOTAL_RX_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_TOTAL_RX_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return NULL;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)
                return NULL;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)


@@ -1152,7 +1152,7 @@ TcStatsEx(pcap_t *p, int *pcap_stat_size)
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_RX_DROPPED_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {
        status = g_TcFunctions.StatisticsQueryValue(statistics, TC_COUNTER_INSTANCE_RX_DROPPED_PACKETS, &counter);
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error in TcStatisticsQueryValue: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

                return NULL;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)
                return NULL;
        }
        if (counter <= (ULONGLONG)0xFFFFFFFF)


@@ -1190,7 +1190,7 @@ TcSetMode(pcap_t *p, int mode)
 {
        if (mode != MODE_CAPT)
        {
 {
        if (mode != MODE_CAPT)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Mode %u not supported by TurboCap devices. TurboCap only supports capture.", mode);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Mode %u not supported by TurboCap devices. TurboCap only supports capture.", mode);

                return -1;
        }
 
                return -1;
        }
 


@@ -1205,7 +1205,7 @@ TcSetMinToCopy(pcap_t *p, int size)
 
        if (size < 0)
        {
 
        if (size < 0)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Mintocopy cannot be less than 0.");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Mintocopy cannot be less than 0.");

                return -1;
        }
 
                return -1;
        }
 


@@ -1213,7 +1213,7 @@ TcSetMinToCopy(pcap_t *p, int size)
 
        if (status != TC_SUCCESS)
        {
 
        if (status != TC_SUCCESS)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error setting the mintocopy: %s (%08x)", g_TcFunctions.StatusGetString(status), status);
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "TurboCap error setting the mintocopy: %s (%08x)", g_TcFunctions.StatusGetString(status), status);

        }
 
        return 0;
        }
 
        return 0;


@@ -1230,7 +1230,7 @@ TcGetReceiveWaitHandle(pcap_t *p)
 static int
 TcOidGetRequest(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_, size_t len _U_)
 {
 static int
 TcOidGetRequest(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_, size_t len _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "An OID get request cannot be performed on a TurboCap device");
        return PCAP_ERROR;
 }
            "An OID get request cannot be performed on a TurboCap device");
        return PCAP_ERROR;
 }


@@ -1239,7 +1239,7 @@ static int
 TcOidSetRequest(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
     size_t len _U_)
 {
 TcOidSetRequest(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
     size_t len _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "An OID set request cannot be performed on a TurboCap device");
        return PCAP_ERROR;
 }
            "An OID set request cannot be performed on a TurboCap device");
        return PCAP_ERROR;
 }


@@ -1247,7 +1247,7 @@ TcOidSetRequest(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
 static u_int
 TcSendqueueTransmit(pcap_t *p, pcap_send_queue *queue _U_, int sync _U_)
 {
 static u_int
 TcSendqueueTransmit(pcap_t *p, pcap_send_queue *queue _U_, int sync _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Packets cannot be bulk transmitted on a TurboCap device");
        return 0;
 }
            "Packets cannot be bulk transmitted on a TurboCap device");
        return 0;
 }


@@ -1255,7 +1255,7 @@ TcSendqueueTransmit(pcap_t *p, pcap_send_queue *queue _U_, int sync _U_)
 static int
 TcSetUserBuffer(pcap_t *p, int size _U_)
 {
 static int
 TcSetUserBuffer(pcap_t *p, int size _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The user buffer cannot be set on a TurboCap device");
        return -1;
 }
            "The user buffer cannot be set on a TurboCap device");
        return -1;
 }


@@ -1263,7 +1263,7 @@ TcSetUserBuffer(pcap_t *p, int size _U_)
 static int
 TcLiveDump(pcap_t *p, char *filename _U_, int maxsize _U_, int maxpacks _U_)
 {
 static int
 TcLiveDump(pcap_t *p, char *filename _U_, int maxsize _U_, int maxpacks _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Live packet dumping cannot be performed on a TurboCap device");
        return -1;
 }
            "Live packet dumping cannot be performed on a TurboCap device");
        return -1;
 }


@@ -1271,7 +1271,7 @@ TcLiveDump(pcap_t *p, char *filename _U_, int maxsize _U_, int maxpacks _U_)
 static int
 TcLiveDumpEnded(pcap_t *p, int sync _U_)
 {
 static int
 TcLiveDumpEnded(pcap_t *p, int sync _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Live packet dumping cannot be performed on a TurboCap device");
        return -1;
 }
            "Live packet dumping cannot be performed on a TurboCap device");
        return -1;
 }

diff --git a/pcap-usb-linux.c b/pcap-usb-linux.c
index 98e7e32d6d9c2f70ec48cc8bb3628f324dc19a09..bf526a38a0a756db3e6dab6a278f316736748290 100644 (file)
--- a/pcap-usb-linux.c
+++ b/pcap-usb-linux.c
@@ -144,8 +144,8 @@ usb_dev_add(pcap_if_t** alldevsp, int n, char *err_str)
 {
        char dev_name[10];
        char dev_descr[30];
 {
        char dev_name[10];
        char dev_descr[30];

-       snprintf(dev_name, 10, USB_IFACE"%d", n);
-       snprintf(dev_descr, 30, "USB bus number %d", n);
+       pcap_snprintf(dev_name, 10, USB_IFACE"%d", n);
+       pcap_snprintf(dev_descr, 30, "USB bus number %d", n);

 
        if (pcap_add_if(alldevsp, dev_name, 0,
            dev_descr, err_str) < 0)
 
        if (pcap_add_if(alldevsp, dev_name, 0,
            dev_descr, err_str) < 0)


@@ -287,7 +287,7 @@ probe_devices(int bus)
        DIR* dir;
 
        /* scan usb bus directories for device nodes */
        DIR* dir;
 
        /* scan usb bus directories for device nodes */

-       snprintf(buf, sizeof(buf), "/dev/bus/usb/%03d", bus);
+       pcap_snprintf(buf, sizeof(buf), "/dev/bus/usb/%03d", bus);

        dir = opendir(buf);
        if (!dir)
                return;
        dir = opendir(buf);
        if (!dir)
                return;


@@ -299,7 +299,7 @@ probe_devices(int bus)
                if (name[0] == '.')
                        continue;
 
                if (name[0] == '.')
                        continue;
 

-               snprintf(buf, sizeof(buf), "/dev/bus/usb/%03d/%s", bus, data->d_name);
+               pcap_snprintf(buf, sizeof(buf), "/dev/bus/usb/%03d/%s", bus, data->d_name);

 
                fd = open(buf, O_RDWR);
                if (fd == -1)
 
                fd = open(buf, O_RDWR);
                if (fd == -1)


@@ -397,13 +397,13 @@ usb_activate(pcap_t* handle)
        /*get usb bus index from device name */
        if (sscanf(handle->opt.source, USB_IFACE"%d", &handlep->bus_index) != 1)
        {
        /*get usb bus index from device name */
        if (sscanf(handle->opt.source, USB_IFACE"%d", &handlep->bus_index) != 1)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "Can't get USB bus index from %s", handle->opt.source);
                return PCAP_ERROR;
        }
 
        /*now select the read method: try to open binary interface */
                        "Can't get USB bus index from %s", handle->opt.source);
                return PCAP_ERROR;
        }
 
        /*now select the read method: try to open binary interface */

-       snprintf(full_path, USB_LINE_LEN, LINUX_USB_MON_DEV"%d", handlep->bus_index);
+       pcap_snprintf(full_path, USB_LINE_LEN, LINUX_USB_MON_DEV"%d", handlep->bus_index);

        handle->fd = open(full_path, O_RDONLY, 0);
        if (handle->fd >= 0)
        {
        handle->fd = open(full_path, O_RDONLY, 0);
        if (handle->fd >= 0)
        {


@@ -442,7 +442,7 @@ usb_activate(pcap_t* handle)
        }
        else {
                /*Binary interface not available, try open text interface */
        }
        else {
                /*Binary interface not available, try open text interface */

-               snprintf(full_path, USB_LINE_LEN, USB_TEXT_DIR"/%dt", handlep->bus_index);
+               pcap_snprintf(full_path, USB_LINE_LEN, USB_TEXT_DIR"/%dt", handlep->bus_index);

                handle->fd = open(full_path, O_RDONLY, 0);
                if (handle->fd < 0)
                {
                handle->fd = open(full_path, O_RDONLY, 0);
                if (handle->fd < 0)
                {


@@ -452,12 +452,12 @@ usb_activate(pcap_t* handle)
                                 * Not found at the new location; try
                                 * the old location.
                                 */
                                 * Not found at the new location; try
                                 * the old location.
                                 */

-                               snprintf(full_path, USB_LINE_LEN, USB_TEXT_DIR_OLD"/%dt", handlep->bus_index);
+                               pcap_snprintf(full_path, USB_LINE_LEN, USB_TEXT_DIR_OLD"/%dt", handlep->bus_index);

                                handle->fd = open(full_path, O_RDONLY, 0);
                        }
                        if (handle->fd < 0) {
                                /* no more fallback, give it up*/
                                handle->fd = open(full_path, O_RDONLY, 0);
                        }
                        if (handle->fd < 0) {
                                /* no more fallback, give it up*/

-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                        "Can't open USB bus file %s: %s", full_path, strerror(errno));
                                return PCAP_ERROR;
                        }
                                        "Can't open USB bus file %s: %s", full_path, strerror(errno));
                                return PCAP_ERROR;
                        }


@@ -485,7 +485,7 @@ usb_activate(pcap_t* handle)
         * buffer */
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {
         * buffer */
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                         "malloc: %s", pcap_strerror(errno));
                close(handle->fd);
                return PCAP_ERROR;
                         "malloc: %s", pcap_strerror(errno));
                close(handle->fd);
                return PCAP_ERROR;


@@ -536,7 +536,7 @@ usb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
                if (errno == EAGAIN)
                        return 0;       /* no data there */
 
                if (errno == EAGAIN)
                        return 0;       /* no data there */
 

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't read from fd %d: %s", handle->fd, strerror(errno));
                return -1;
        }
                    "Can't read from fd %d: %s", handle->fd, strerror(errno));
                return -1;
        }


@@ -549,7 +549,7 @@ usb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
                &cnt);
        if (ret < 8)
        {
                &cnt);
        if (ret < 8)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't parse USB bus message '%s', too few tokens (expected 8 got %d)",
                    string, ret);
                return -1;
                    "Can't parse USB bus message '%s', too few tokens (expected 8 got %d)",
                    string, ret);
                return -1;


@@ -563,7 +563,7 @@ usb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
        /* don't use usbmon provided timestamp, since it have low precision*/
        if (gettimeofday(&pkth.ts, NULL) < 0)
        {
        /* don't use usbmon provided timestamp, since it have low precision*/
        if (gettimeofday(&pkth.ts, NULL) < 0)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "Can't get timestamp for message '%s' %d:%s",
                        string, errno, strerror(errno));
                return -1;
                        "Can't get timestamp for message '%s' %d:%s",
                        string, errno, strerror(errno));
                return -1;


@@ -615,7 +615,7 @@ usb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
                str5, &cnt);
                if (ret < 5)
                {
                str5, &cnt);
                if (ret < 5)
                {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "Can't parse USB bus message '%s', too few tokens (expected 5 got %d)",
                                string, ret);
                        return -1;
                                "Can't parse USB bus message '%s', too few tokens (expected 5 got %d)",
                                string, ret);
                        return -1;


@@ -639,7 +639,7 @@ usb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
        ret = sscanf(string, " %d%n", &urb_len, &cnt);
        if (ret < 1)
        {
        ret = sscanf(string, " %d%n", &urb_len, &cnt);
        if (ret < 1)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                  "Can't parse urb length from '%s'", string);
                return -1;
        }
                  "Can't parse urb length from '%s'", string);
                return -1;
        }


@@ -657,7 +657,7 @@ usb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *u
        /* check for data presence; data is present if and only if urb tag is '=' */
        if (sscanf(string, " %c", &urb_tag) != 1)
        {
        /* check for data presence; data is present if and only if urb tag is '=' */
        if (sscanf(string, " %c", &urb_tag) != 1)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "Can't parse urb tag from '%s'", string);
                return -1;
        }
                        "Can't parse urb tag from '%s'", string);
                return -1;
        }


@@ -705,7 +705,7 @@ got:
 static int
 usb_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {
 static int
 usb_inject_linux(pcap_t *handle, const void *buf, size_t size)
 {

-       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on "
+       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on "

                "USB devices");
        return (-1);
 }
                "USB devices");
        return (-1);
 }


@@ -720,7 +720,7 @@ usb_stats_linux(pcap_t *handle, struct pcap_stat *stats)
        char * ptr = string;
        int fd;
 
        char * ptr = string;
        int fd;
 

-       snprintf(string, USB_LINE_LEN, USB_TEXT_DIR"/%ds", handlep->bus_index);
+       pcap_snprintf(string, USB_LINE_LEN, USB_TEXT_DIR"/%ds", handlep->bus_index);

        fd = open(string, O_RDONLY, 0);
        if (fd < 0)
        {
        fd = open(string, O_RDONLY, 0);
        if (fd < 0)
        {


@@ -730,11 +730,11 @@ usb_stats_linux(pcap_t *handle, struct pcap_stat *stats)
                         * Not found at the new location; try the old
                         * location.
                         */
                         * Not found at the new location; try the old
                         * location.
                         */

-                       snprintf(string, USB_LINE_LEN, USB_TEXT_DIR_OLD"/%ds", handlep->bus_index);
+                       pcap_snprintf(string, USB_LINE_LEN, USB_TEXT_DIR_OLD"/%ds", handlep->bus_index);

                        fd = open(string, O_RDONLY, 0);
                }
                if (fd < 0) {
                        fd = open(string, O_RDONLY, 0);
                }
                if (fd < 0) {

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                                "Can't open USB stats file %s: %s",
                                string, strerror(errno));
                        return -1;
                                "Can't open USB stats file %s: %s",
                                string, strerror(errno));
                        return -1;


@@ -749,7 +749,7 @@ usb_stats_linux(pcap_t *handle, struct pcap_stat *stats)
 
        if (ret < 0)
        {
 
        if (ret < 0)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "Can't read stats from fd %d ", fd);
                return -1;
        }
                        "Can't read stats from fd %d ", fd);
                return -1;
        }


@@ -803,7 +803,7 @@ usb_stats_linux_bin(pcap_t *handle, struct pcap_stat *stats)
        ret = ioctl(handle->fd, MON_IOCG_STATS, &st);
        if (ret < 0)
        {
        ret = ioctl(handle->fd, MON_IOCG_STATS, &st);
        if (ret < 0)
        {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                        "Can't read stats from fd %d:%s ", handle->fd, strerror(errno));
                return -1;
        }
                        "Can't read stats from fd %d:%s ", handle->fd, strerror(errno));
                return -1;
        }


@@ -846,7 +846,7 @@ usb_read_linux_bin(pcap_t *handle, int max_packets, pcap_handler callback, u_cha
                if (errno == EAGAIN)
                        return 0;       /* no data there */
 
                if (errno == EAGAIN)
                        return 0;       /* no data there */
 

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't read from fd %d: %s", handle->fd, strerror(errno));
                return -1;
        }
                    "Can't read from fd %d: %s", handle->fd, strerror(errno));
                return -1;
        }


@@ -917,7 +917,7 @@ usb_read_linux_mmap(pcap_t *handle, int max_packets, pcap_handler callback, u_ch
                        if (errno == EAGAIN)
                                return 0;       /* no data there */
 
                        if (errno == EAGAIN)
                                return 0;       /* no data there */
 

-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                            "Can't mfetch fd %d: %s", handle->fd, strerror(errno));
                        return -1;
                }
                            "Can't mfetch fd %d: %s", handle->fd, strerror(errno));
                        return -1;
                }


@@ -958,7 +958,7 @@ usb_read_linux_mmap(pcap_t *handle, int max_packets, pcap_handler callback, u_ch
 
        /* flush pending events*/
        if (ioctl(handle->fd, MON_IOCH_MFLUSH, nflush) == -1) {
 
        /* flush pending events*/
        if (ioctl(handle->fd, MON_IOCH_MFLUSH, nflush) == -1) {

-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,

                    "Can't mflush fd %d: %s", handle->fd, strerror(errno));
                return -1;
        }
                    "Can't mflush fd %d: %s", handle->fd, strerror(errno));
                return -1;
        }

diff --git a/pcap-win32.c b/pcap-win32.c
index 7c749889abf04012cb667e19350ba6d43fee1dcf..d63b83c9894ffc057341d18e34a2ea047a692fd1 100644 (file)
--- a/pcap-win32.c
+++ b/pcap-win32.c
@@ -147,7 +147,7 @@ pcap_stats_win32(pcap_t *p, struct pcap_stat *ps)
         */
        if (!PacketGetStats(p->adapter, &bstats)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);
         */
        if (!PacketGetStats(p->adapter, &bstats)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "PacketGetStats error: %s", errbuf);
                return (-1);
        }
                    "PacketGetStats error: %s", errbuf);
                return (-1);
        }


@@ -205,7 +205,7 @@ pcap_stats_ex_win32(pcap_t *p, int *pcap_stat_size)
         */
        if (!PacketGetStatsEx(p->adapter, &bstats)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);
         */
        if (!PacketGetStatsEx(p->adapter, &bstats)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "PacketGetStatsEx error: %s", errbuf);
                return (NULL);
        }
                    "PacketGetStatsEx error: %s", errbuf);
                return (NULL);
        }


@@ -224,7 +224,7 @@ pcap_setbuff_win32(pcap_t *p, int dim)
 {
        if(PacketSetBuff(p->adapter,dim)==FALSE)
        {
 {
        if(PacketSetBuff(p->adapter,dim)==FALSE)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: not enough memory to allocate the kernel buffer");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: not enough memory to allocate the kernel buffer");

                return (-1);
        }
        return (0);
                return (-1);
        }
        return (0);


@@ -236,7 +236,7 @@ pcap_setmode_win32(pcap_t *p, int mode)
 {
        if(PacketSetMode(p->adapter,mode)==FALSE)
        {
 {
        if(PacketSetMode(p->adapter,mode)==FALSE)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: working mode not recognized");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: working mode not recognized");

                return (-1);
        }
 
                return (-1);
        }
 


@@ -249,7 +249,7 @@ pcap_setmintocopy_win32(pcap_t *p, int size)
 {
        if(PacketSetMinToCopy(p->adapter, size)==FALSE)
        {
 {
        if(PacketSetMinToCopy(p->adapter, size)==FALSE)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: unable to set the requested mintocopy size");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: unable to set the requested mintocopy size");

                return (-1);
        }
        return (0);
                return (-1);
        }
        return (0);


@@ -276,7 +276,7 @@ pcap_oid_get_request_win32(pcap_t *p, bpf_u_int32 oid, void *data, size_t len)
         */
        oid_data_arg = malloc(sizeof (PACKET_OID_DATA) + len);
        if (oid_data_arg == NULL) {
         */
        oid_data_arg = malloc(sizeof (PACKET_OID_DATA) + len);
        if (oid_data_arg == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Couldn't allocate argument buffer for PacketRequest");
                return (PCAP_ERROR);
        }
                    "Couldn't allocate argument buffer for PacketRequest");
                return (PCAP_ERROR);
        }


@@ -288,7 +288,7 @@ pcap_oid_get_request_win32(pcap_t *p, bpf_u_int32 oid, void *data, size_t len)
        oid_data_arg->Length = (ULONG)len;      /* XXX - check for ridiculously large value? */
        if (!PacketRequest(p->adapter, FALSE, oid_data_arg)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);
        oid_data_arg->Length = (ULONG)len;      /* XXX - check for ridiculously large value? */
        if (!PacketRequest(p->adapter, FALSE, oid_data_arg)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error calling PacketRequest: %s", errbuf);
                free(oid_data_arg);
                return (PCAP_ERROR);
                    "Error calling PacketRequest: %s", errbuf);
                free(oid_data_arg);
                return (PCAP_ERROR);


@@ -318,7 +318,7 @@ pcap_oid_set_request_win32(pcap_t *p, bpf_u_int32 oid, const void *data,
         */
        oid_data_arg = malloc(sizeof (PACKET_OID_DATA) + len);
        if (oid_data_arg == NULL) {
         */
        oid_data_arg = malloc(sizeof (PACKET_OID_DATA) + len);
        if (oid_data_arg == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Couldn't allocate argument buffer for PacketRequest");
                return (PCAP_ERROR);
        }
                    "Couldn't allocate argument buffer for PacketRequest");
                return (PCAP_ERROR);
        }


@@ -328,7 +328,7 @@ pcap_oid_set_request_win32(pcap_t *p, bpf_u_int32 oid, const void *data,
        memcpy(oid_data_arg->Data, data, len);
        if (!PacketRequest(p->adapter, TRUE, oid_data_arg)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);
        memcpy(oid_data_arg->Data, data, len);
        if (!PacketRequest(p->adapter, TRUE, oid_data_arg)) {
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error calling PacketRequest: %s", errbuf);
                free(oid_data_arg);
                return (PCAP_ERROR);
                    "Error calling PacketRequest: %s", errbuf);
                free(oid_data_arg);
                return (PCAP_ERROR);


@@ -348,7 +348,7 @@ pcap_sendqueue_transmit_win32(pcap_t *p, pcap_send_queue *queue, int sync)
        char errbuf[PCAP_ERRBUF_SIZE+1];
 
        if (p->adapter==NULL) {
        char errbuf[PCAP_ERRBUF_SIZE+1];
 
        if (p->adapter==NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Cannot transmit a queue to an offline capture or to a TurboCap port");
                return (0);
        }
                    "Cannot transmit a queue to an offline capture or to a TurboCap port");
                return (0);
        }


@@ -360,7 +360,7 @@ pcap_sendqueue_transmit_win32(pcap_t *p, pcap_send_queue *queue, int sync)
 
        if(res != queue->len){
                pcap_win32_err_to_str(GetLastError(), errbuf);
 
        if(res != queue->len){
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error opening adapter: %s", errbuf);
        }
 
                    "Error opening adapter: %s", errbuf);
        }
 


@@ -374,7 +374,7 @@ pcap_setuserbuffer_win32(pcap_t *p, int size)
 
        if (size<=0) {
                /* Bogus parameter */
 
        if (size<=0) {
                /* Bogus parameter */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error: invalid size %d",size);
                return (-1);
        }
                    "Error: invalid size %d",size);
                return (-1);
        }


@@ -383,7 +383,7 @@ pcap_setuserbuffer_win32(pcap_t *p, int size)
        new_buff=(unsigned char*)malloc(sizeof(char)*size);
 
        if (!new_buff) {
        new_buff=(unsigned char*)malloc(sizeof(char)*size);
 
        if (!new_buff) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error: not enough memory");
                return (-1);
        }
                    "Error: not enough memory");
                return (-1);
        }


@@ -404,7 +404,7 @@ pcap_live_dump_win32(pcap_t *p, char *filename, int maxsize, int maxpacks)
        /* Set the packet driver in dump mode */
        res = PacketSetMode(p->adapter, PACKET_MODE_DUMP);
        if(res == FALSE){
        /* Set the packet driver in dump mode */
        res = PacketSetMode(p->adapter, PACKET_MODE_DUMP);
        if(res == FALSE){

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error setting dump mode");
                return (-1);
        }
                    "Error setting dump mode");
                return (-1);
        }


@@ -412,7 +412,7 @@ pcap_live_dump_win32(pcap_t *p, char *filename, int maxsize, int maxpacks)
        /* Set the name of the dump file */
        res = PacketSetDumpName(p->adapter, filename, (int)strlen(filename));
        if(res == FALSE){
        /* Set the name of the dump file */
        res = PacketSetDumpName(p->adapter, filename, (int)strlen(filename));
        if(res == FALSE){

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error setting kernel dump file name");
                return (-1);
        }
                    "Error setting kernel dump file name");
                return (-1);
        }


@@ -478,7 +478,7 @@ pcap_read_win32_npf(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                 */
                PacketInitPacket(&Packet, (BYTE *)p->buffer, p->bufsize);
                if (!PacketReceivePacket(p->adapter, &Packet, TRUE)) {
                 */
                PacketInitPacket(&Packet, (BYTE *)p->buffer, p->bufsize);
                if (!PacketReceivePacket(p->adapter, &Packet, TRUE)) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error: PacketReceivePacket failed");
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error: PacketReceivePacket failed");

                        return (PCAP_ERROR);
                }
 
                        return (PCAP_ERROR);
                }
 


@@ -593,7 +593,7 @@ pcap_read_win32_dag(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                 */
                PacketInitPacket(&Packet, (BYTE *)p->buffer, p->bufsize);
                if (!PacketReceivePacket(p->adapter, &Packet, TRUE)) {
                 */
                PacketInitPacket(&Packet, (BYTE *)p->buffer, p->bufsize);
                if (!PacketReceivePacket(p->adapter, &Packet, TRUE)) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error: PacketReceivePacket failed");
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read error: PacketReceivePacket failed");

                        return (-1);
                }
 
                        return (-1);
                }
 


@@ -742,13 +742,13 @@ pcap_inject_win32(pcap_t *p, const void *buf, size_t size){
 
        if (PacketToSend == NULL)
        {
 
        if (PacketToSend == NULL)
        {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: PacketAllocatePacket failed");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: PacketAllocatePacket failed");

                return (-1);
        }
 
        PacketInitPacket(PacketToSend, (PVOID)buf, (UINT)size);
        if(PacketSendPacket(p->adapter,PacketToSend,TRUE) == FALSE){
                return (-1);
        }
 
        PacketInitPacket(PacketToSend, (PVOID)buf, (UINT)size);
        if(PacketSendPacket(p->adapter,PacketToSend,TRUE) == FALSE){

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: PacketSendPacket failed");
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send error: PacketSendPacket failed");

                PacketFreePacket(PacketToSend);
                return (-1);
        }
                PacketFreePacket(PacketToSend);
                return (-1);
        }


@@ -800,7 +800,7 @@ pcap_activate_win32(pcap_t *p)
        {
                /* Adapter detected but we are not able to open it. Return failure. */
                pcap_win32_err_to_str(GetLastError(), errbuf);
        {
                /* Adapter detected but we are not able to open it. Return failure. */
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Error opening adapter: %s", errbuf);
                return (PCAP_ERROR);
        }
                    "Error opening adapter: %s", errbuf);
                return (PCAP_ERROR);
        }


@@ -809,7 +809,7 @@ pcap_activate_win32(pcap_t *p)
        if(PacketGetNetType (p->adapter,&type) == FALSE)
        {
                pcap_win32_err_to_str(GetLastError(), errbuf);
        if(PacketGetNetType (p->adapter,&type) == FALSE)
        {
                pcap_win32_err_to_str(GetLastError(), errbuf);

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Cannot determine the network type: %s", errbuf);
                goto bad;
        }
                    "Cannot determine the network type: %s", errbuf);
                goto bad;
        }


@@ -899,7 +899,7 @@ pcap_activate_win32(pcap_t *p)
 
                if (PacketSetHwFilter(p->adapter,NDIS_PACKET_TYPE_PROMISCUOUS) == FALSE)
                {
 
                if (PacketSetHwFilter(p->adapter,NDIS_PACKET_TYPE_PROMISCUOUS) == FALSE)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "failed to set hardware filter to promiscuous mode");
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "failed to set hardware filter to promiscuous mode");

                        goto bad;
                }
        }
                        goto bad;
                }
        }


@@ -907,7 +907,7 @@ pcap_activate_win32(pcap_t *p)
        {
                if (PacketSetHwFilter(p->adapter,NDIS_PACKET_TYPE_ALL_LOCAL) == FALSE)
                {
        {
                if (PacketSetHwFilter(p->adapter,NDIS_PACKET_TYPE_ALL_LOCAL) == FALSE)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "failed to set hardware filter to non-promiscuous mode");
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "failed to set hardware filter to non-promiscuous mode");

                        goto bad;
                }
        }
                        goto bad;
                }
        }


@@ -929,14 +929,14 @@ pcap_activate_win32(pcap_t *p)
 
                if(PacketSetBuff(p->adapter,p->opt.buffer_size)==FALSE)
                {
 
                if(PacketSetBuff(p->adapter,p->opt.buffer_size)==FALSE)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: not enough memory to allocate the kernel buffer");
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "driver error: not enough memory to allocate the kernel buffer");

                        goto bad;
                }
 
                p->buffer = malloc(p->bufsize);
                if (p->buffer == NULL)
                {
                        goto bad;
                }
 
                p->buffer = malloc(p->bufsize);
                if (p->buffer == NULL)
                {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "malloc: %s", pcap_strerror(errno));

                        goto bad;
                }
 
                        goto bad;
                }
 


@@ -946,7 +946,7 @@ pcap_activate_win32(pcap_t *p)
                        if(PacketSetMinToCopy(p->adapter,0)==FALSE)
                        {
                                pcap_win32_err_to_str(GetLastError(), errbuf);
                        if(PacketSetMinToCopy(p->adapter,0)==FALSE)
                        {
                                pcap_win32_err_to_str(GetLastError(), errbuf);

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "Error calling PacketSetMinToCopy: %s",
                                    errbuf);
                                goto bad;
                                    "Error calling PacketSetMinToCopy: %s",
                                    errbuf);
                                goto bad;


@@ -958,7 +958,7 @@ pcap_activate_win32(pcap_t *p)
                        if(PacketSetMinToCopy(p->adapter,16000)==FALSE)
                        {
                                pcap_win32_err_to_str(GetLastError(), errbuf);
                        if(PacketSetMinToCopy(p->adapter,16000)==FALSE)
                        {
                                pcap_win32_err_to_str(GetLastError(), errbuf);

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "Error calling PacketSetMinToCopy: %s",
                                    errbuf);
                                goto bad;
                                    "Error calling PacketSetMinToCopy: %s",
                                    errbuf);
                                goto bad;


@@ -978,7 +978,7 @@ pcap_activate_win32(pcap_t *p)
                int             postype = 0;
                char    keyname[512];
 
                int             postype = 0;
                char    keyname[512];
 

-               snprintf(keyname, sizeof(keyname), "%s\\CardParams\\%s",
+               pcap_snprintf(keyname, sizeof(keyname), "%s\\CardParams\\%s",

                        "SYSTEM\\CurrentControlSet\\Services\\DAG",
                        strstr(_strlwr(p->opt.source), "dag"));
                do
                        "SYSTEM\\CurrentControlSet\\Services\\DAG",
                        strstr(_strlwr(p->opt.source), "dag"));
                do


@@ -1083,11 +1083,11 @@ pcap_create_interface(const char *device, char *ebuf)
 
                if (deviceAscii == NULL)
                {
 
                if (deviceAscii == NULL)
                {

-                       snprintf(ebuf, PCAP_ERRBUF_SIZE, "Malloc failed");
+                       pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "Malloc failed");

                        return (NULL);
                }
 
                        return (NULL);
                }
 

-               snprintf(deviceAscii, length + 1, "%ws", (wchar_t*)device);
+               pcap_snprintf(deviceAscii, length + 1, "%ws", (wchar_t*)device);

                p = pcap_create_common(deviceAscii, ebuf, sizeof (struct pcap_win));
                free(deviceAscii);
        }
                p = pcap_create_common(deviceAscii, ebuf, sizeof (struct pcap_win));
                free(deviceAscii);
        }


@@ -1176,7 +1176,7 @@ pcap_setfilter_win32_dag(pcap_t *p, struct bpf_program *fp) {
        /* Install a user level filter */
        if (install_bpf_program(p, fp) < 0)
        {
        /* Install a user level filter */
        if (install_bpf_program(p, fp) < 0)
        {

-               snprintf(p->errbuf, sizeof(p->errbuf),
+               pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                        "setfilter, unable to install the filter: %s", pcap_strerror(errno));
                return (-1);
        }
                        "setfilter, unable to install the filter: %s", pcap_strerror(errno));
                return (-1);
        }


@@ -1222,7 +1222,7 @@ pcap_setnonblock_win32(pcap_t *p, int nonblock, char *errbuf)
        }
        if (!PacketSetReadTimeout(p->adapter, newtimeout)) {
                pcap_win32_err_to_str(GetLastError(), win_errbuf);
        }
        if (!PacketSetReadTimeout(p->adapter, newtimeout)) {
                pcap_win32_err_to_str(GetLastError(), win_errbuf);

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "PacketSetReadTimeout: %s", win_errbuf);
                return (-1);
        }
                    "PacketSetReadTimeout: %s", win_errbuf);
                return (-1);
        }

diff --git a/pcap.c b/pcap.c
index 388802db9cf83653f9422054c427f4531b68ac0a..59f252e45d0d51880a4320399ecabbae2ae54bef 100644 (file)
--- a/pcap.c
+++ b/pcap.c
@@ -116,7 +116,7 @@ static int
 pcap_not_initialized(pcap_t *pcap)
 {
        /* in case the caller doesn't check for PCAP_ERROR_NOT_ACTIVATED */
 pcap_not_initialized(pcap_t *pcap)
 {
        /* in case the caller doesn't check for PCAP_ERROR_NOT_ACTIVATED */

-       (void)snprintf(pcap->errbuf, sizeof(pcap->errbuf),
+       (void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),

            "This handle hasn't been activated yet");
        /* this means 'not initialized' */
        return (PCAP_ERROR_NOT_ACTIVATED);
            "This handle hasn't been activated yet");
        /* this means 'not initialized' */
        return (PCAP_ERROR_NOT_ACTIVATED);


@@ -126,7 +126,7 @@ pcap_not_initialized(pcap_t *pcap)
 static void *
 pcap_not_initialized_ptr(pcap_t *pcap)
 {
 static void *
 pcap_not_initialized_ptr(pcap_t *pcap)
 {

-       (void)snprintf(pcap->errbuf, sizeof(pcap->errbuf),
+       (void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),

            "This handle hasn't been activated yet");
        return (NULL);
 }
            "This handle hasn't been activated yet");
        return (NULL);
 }


@@ -134,7 +134,7 @@ pcap_not_initialized_ptr(pcap_t *pcap)
 static HANDLE
 pcap_getevent_not_initialized(pcap_t *pcap)
 {
 static HANDLE
 pcap_getevent_not_initialized(pcap_t *pcap)
 {

-       (void)snprintf(pcap->errbuf, sizeof(pcap->errbuf),
+       (void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),

            "This handle hasn't been activated yet");
        return (INVALID_HANDLE_VALUE);
 }
            "This handle hasn't been activated yet");
        return (INVALID_HANDLE_VALUE);
 }


@@ -142,7 +142,7 @@ pcap_getevent_not_initialized(pcap_t *pcap)
 static u_int
 pcap_sendqueue_transmit_not_initialized(pcap_t *pcap, pcap_send_queue* queue, int sync)
 {
 static u_int
 pcap_sendqueue_transmit_not_initialized(pcap_t *pcap, pcap_send_queue* queue, int sync)
 {

-       (void)snprintf(pcap->errbuf, sizeof(pcap->errbuf),
+       (void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),

            "This handle hasn't been activated yet");
        return (0);
 }
            "This handle hasn't been activated yet");
        return (0);
 }


@@ -150,7 +150,7 @@ pcap_sendqueue_transmit_not_initialized(pcap_t *pcap, pcap_send_queue* queue, in
 static PAirpcapHandle
 pcap_get_airpcap_handle_not_initialized(pcap_t *pcap)
 {
 static PAirpcapHandle
 pcap_get_airpcap_handle_not_initialized(pcap_t *pcap)
 {

-       (void)snprintf(pcap->errbuf, sizeof(pcap->errbuf),
+       (void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),

            "This handle hasn't been activated yet");
        return (NULL);
 }
            "This handle hasn't been activated yet");
        return (NULL);
 }


@@ -198,7 +198,7 @@ pcap_list_tstamp_types(pcap_t *p, int **tstamp_typesp)
                *tstamp_typesp = (int*)calloc(sizeof(**tstamp_typesp),
                    p->tstamp_type_count);
                if (*tstamp_typesp == NULL) {
                *tstamp_typesp = (int*)calloc(sizeof(**tstamp_typesp),
                    p->tstamp_type_count);
                if (*tstamp_typesp == NULL) {

-                       (void)snprintf(p->errbuf, sizeof(p->errbuf),
+                       (void)pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                            "malloc: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            "malloc: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -542,7 +542,7 @@ pcap_alloc_pcap_t(char *ebuf, size_t size)
         */
        chunk = malloc(sizeof (pcap_t) + size);
        if (chunk == NULL) {
         */
        chunk = malloc(sizeof (pcap_t) + size);
        if (chunk == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                return (NULL);
        }
                    pcap_strerror(errno));
                return (NULL);
        }


@@ -583,7 +583,7 @@ pcap_create_common(const char *source, char *ebuf, size_t size)
 
        p->opt.source = strdup(source);
        if (p->opt.source == NULL) {
 
        p->opt.source = strdup(source);
        if (p->opt.source == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                free(p);
                return (NULL);
                    pcap_strerror(errno));
                free(p);
                return (NULL);


@@ -621,7 +621,7 @@ int
 pcap_check_activated(pcap_t *p)
 {
        if (p->activated) {
 pcap_check_activated(pcap_t *p)
 {
        if (p->activated) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "can't perform "
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "can't perform "

                        " operation on activated capture");
                return (-1);
        }
                        " operation on activated capture");
                return (-1);
        }


@@ -793,7 +793,7 @@ pcap_activate(pcap_t *p)
                         * handle errors other than PCAP_ERROR, return the
                         * error message corresponding to the status.
                         */
                         * handle errors other than PCAP_ERROR, return the
                         * error message corresponding to the status.
                         */

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s",

                            pcap_statustostr(status));
                }
 
                            pcap_statustostr(status));
                }
 


@@ -841,15 +841,15 @@ pcap_open_live(const char *source, int snaplen, int promisc, int to_ms, char *er
        return (p);
 fail:
        if (status == PCAP_ERROR)
        return (p);
 fail:
        if (status == PCAP_ERROR)

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", source,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", source,

                    p->errbuf);
        else if (status == PCAP_ERROR_NO_SUCH_DEVICE ||
            status == PCAP_ERROR_PERM_DENIED ||
            status == PCAP_ERROR_PROMISC_PERM_DENIED)
                    p->errbuf);
        else if (status == PCAP_ERROR_NO_SUCH_DEVICE ||
            status == PCAP_ERROR_PERM_DENIED ||
            status == PCAP_ERROR_PROMISC_PERM_DENIED)

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s (%s)", source,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s (%s)", source,

                    pcap_statustostr(status), p->errbuf);
        else
                    pcap_statustostr(status), p->errbuf);
        else

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", source,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", source,

                    pcap_statustostr(status));
        pcap_close(p);
        return (NULL);
                    pcap_statustostr(status));
        pcap_close(p);
        return (NULL);


@@ -867,7 +867,7 @@ pcap_open_offline_common(char *ebuf, size_t size)
        p->opt.tstamp_precision = PCAP_TSTAMP_PRECISION_MICRO;
        p->opt.source = strdup("(savefile)");
        if (p->opt.source == NULL) {
        p->opt.tstamp_precision = PCAP_TSTAMP_PRECISION_MICRO;
        p->opt.source = strdup("(savefile)");
        if (p->opt.source == NULL) {

-               snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+               pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",

                    pcap_strerror(errno));
                free(p);
                return (NULL);
                    pcap_strerror(errno));
                free(p);
                return (NULL);


@@ -961,7 +961,7 @@ pcap_list_datalinks(pcap_t *p, int **dlt_buffer)
                 */
                *dlt_buffer = (int*)malloc(sizeof(**dlt_buffer));
                if (*dlt_buffer == NULL) {
                 */
                *dlt_buffer = (int*)malloc(sizeof(**dlt_buffer));
                if (*dlt_buffer == NULL) {

-                       (void)snprintf(p->errbuf, sizeof(p->errbuf),
+                       (void)pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                            "malloc: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            "malloc: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -970,7 +970,7 @@ pcap_list_datalinks(pcap_t *p, int **dlt_buffer)
        } else {
                *dlt_buffer = (int*)calloc(sizeof(**dlt_buffer), p->dlt_count);
                if (*dlt_buffer == NULL) {
        } else {
                *dlt_buffer = (int*)calloc(sizeof(**dlt_buffer), p->dlt_count);
                if (*dlt_buffer == NULL) {

-                       (void)snprintf(p->errbuf, sizeof(p->errbuf),
+                       (void)pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                            "malloc: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }
                            "malloc: %s", pcap_strerror(errno));
                        return (PCAP_ERROR);
                }


@@ -1048,11 +1048,11 @@ pcap_set_datalink(pcap_t *p, int dlt)
 unsupported:
        dlt_name = pcap_datalink_val_to_name(dlt);
        if (dlt_name != NULL) {
 unsupported:
        dlt_name = pcap_datalink_val_to_name(dlt);
        if (dlt_name != NULL) {

-               (void) snprintf(p->errbuf, sizeof(p->errbuf),
+               (void) pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "%s is not one of the DLTs supported by this device",
                    dlt_name);
        } else {
                    "%s is not one of the DLTs supported by this device",
                    dlt_name);
        } else {

-               (void) snprintf(p->errbuf, sizeof(p->errbuf),
+               (void) pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "DLT %d is not one of the DLTs supported by this device",
                    dlt);
        }
                    "DLT %d is not one of the DLTs supported by this device",
                    dlt);
        }


@@ -1468,7 +1468,7 @@ pcap_getnonblock_fd(pcap_t *p, char *errbuf)
 
        fdflags = fcntl(p->fd, F_GETFL, 0);
        if (fdflags == -1) {
 
        fdflags = fcntl(p->fd, F_GETFL, 0);
        if (fdflags == -1) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "F_GETFL: %s",
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "F_GETFL: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -1510,7 +1510,7 @@ pcap_setnonblock_fd(pcap_t *p, int nonblock, char *errbuf)
 
        fdflags = fcntl(p->fd, F_GETFL, 0);
        if (fdflags == -1) {
 
        fdflags = fcntl(p->fd, F_GETFL, 0);
        if (fdflags == -1) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "F_GETFL: %s",
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "F_GETFL: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -1519,7 +1519,7 @@ pcap_setnonblock_fd(pcap_t *p, int nonblock, char *errbuf)
        else
                fdflags &= ~O_NONBLOCK;
        if (fcntl(p->fd, F_SETFL, fdflags) == -1) {
        else
                fdflags &= ~O_NONBLOCK;
        if (fcntl(p->fd, F_SETFL, fdflags) == -1) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "F_SETFL: %s",
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "F_SETFL: %s",

                    pcap_strerror(errno));
                return (-1);
        }
                    pcap_strerror(errno));
                return (-1);
        }


@@ -1552,7 +1552,7 @@ pcap_win32_err_to_str(DWORD error, char *errbuf)
                errbuf[errlen - 2] = '\0';
        }
        p = strchr(errbuf, '\0');
                errbuf[errlen - 2] = '\0';
        }
        p = strchr(errbuf, '\0');

-       snprintf (p, PCAP_ERRBUF_SIZE+1-(p-errbuf), " (%lu)", error);
+       pcap_snprintf (p, PCAP_ERRBUF_SIZE+1-(p-errbuf), " (%lu)", error);

 }
 #endif
 
 }
 #endif
 


@@ -1611,7 +1611,7 @@ pcap_statustostr(int errnum)
        case PCAP_ERROR_TSTAMP_PRECISION_NOTSUP:
                return ("That device doesn't support that time stamp precision");
        }
        case PCAP_ERROR_TSTAMP_PRECISION_NOTSUP:
                return ("That device doesn't support that time stamp precision");
        }

-       (void)snprintf(ebuf, sizeof ebuf, "Unknown error: %d", errnum);
+       (void)pcap_snprintf(ebuf, sizeof ebuf, "Unknown error: %d", errnum);

        return(ebuf);
 }
 
        return(ebuf);
 }
 


@@ -1630,7 +1630,7 @@ pcap_strerror(int errnum)
 
        if ((unsigned int)errnum < sys_nerr)
                return ((char *)sys_errlist[errnum]);
 
        if ((unsigned int)errnum < sys_nerr)
                return ((char *)sys_errlist[errnum]);

-       (void)snprintf(ebuf, sizeof ebuf, "Unknown error: %d", errnum);
+       (void)pcap_snprintf(ebuf, sizeof ebuf, "Unknown error: %d", errnum);

        return(ebuf);
 #endif
 }
        return(ebuf);
 #endif
 }


@@ -1651,7 +1651,7 @@ int
 pcap_setdirection(pcap_t *p, pcap_direction_t d)
 {
        if (p->setdirection_op == NULL) {
 pcap_setdirection(pcap_t *p, pcap_direction_t d)
 {
        if (p->setdirection_op == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "Setting direction is not implemented on this platform");
                return (-1);
        } else
                    "Setting direction is not implemented on this platform");
                return (-1);
        } else


@@ -1667,7 +1667,7 @@ pcap_stats(pcap_t *p, struct pcap_stat *ps)
 static int
 pcap_stats_dead(pcap_t *p, struct pcap_stat *ps _U_)
 {
 static int
 pcap_stats_dead(pcap_t *p, struct pcap_stat *ps _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Statistics aren't available from a pcap_open_dead pcap_t");
        return (-1);
 }
            "Statistics aren't available from a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1688,7 +1688,7 @@ pcap_setbuff(pcap_t *p, int dim)
 static int
 pcap_setbuff_dead(pcap_t *p, int dim)
 {
 static int
 pcap_setbuff_dead(pcap_t *p, int dim)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The kernel buffer size cannot be set on a pcap_open_dead pcap_t");
        return (-1);
 }
            "The kernel buffer size cannot be set on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1702,7 +1702,7 @@ pcap_setmode(pcap_t *p, int mode)
 static int
 pcap_setmode_dead(pcap_t *p, int mode)
 {
 static int
 pcap_setmode_dead(pcap_t *p, int mode)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "impossible to set mode on a pcap_open_dead pcap_t");
        return (-1);
 }
            "impossible to set mode on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1716,7 +1716,7 @@ pcap_setmintocopy(pcap_t *p, int size)
 static int
 pcap_setmintocopy_dead(pcap_t *p, int size)
 {
 static int
 pcap_setmintocopy_dead(pcap_t *p, int size)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The mintocopy parameter cannot be set on a pcap_open_dead pcap_t");
        return (-1);
 }
            "The mintocopy parameter cannot be set on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1730,7 +1730,7 @@ pcap_getevent(pcap_t *p)
 static HANDLE
 pcap_getevent_dead(pcap_t *p)
 {
 static HANDLE
 pcap_getevent_dead(pcap_t *p)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "A pcap_open_dead pcap_t has no event handle");
        return (INVALID_HANDLE_VALUE);
 }
            "A pcap_open_dead pcap_t has no event handle");
        return (INVALID_HANDLE_VALUE);
 }


@@ -1745,7 +1745,7 @@ static int
 pcap_oid_get_request_dead(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_,
     size_t len _U_)
 {
 pcap_oid_get_request_dead(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_,
     size_t len _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "An OID get request cannot be performed on a pcap_open_dead pcap_t");
        return (PCAP_ERROR);
 }
            "An OID get request cannot be performed on a pcap_open_dead pcap_t");
        return (PCAP_ERROR);
 }


@@ -1760,7 +1760,7 @@ static int
 pcap_oid_set_request_dead(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
     size_t len _U_)
 {
 pcap_oid_set_request_dead(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
     size_t len _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "An OID set request cannot be performed on a pcap_open_dead pcap_t");
        return (PCAP_ERROR);
 }
            "An OID set request cannot be performed on a pcap_open_dead pcap_t");
        return (PCAP_ERROR);
 }


@@ -1823,7 +1823,7 @@ pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue *queue, int sync)
 static u_int
 pcap_sendqueue_transmit_dead(pcap_t *p, pcap_send_queue *queue, int sync)
 {
 static u_int
 pcap_sendqueue_transmit_dead(pcap_t *p, pcap_send_queue *queue, int sync)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Packets cannot be transmitted on a pcap_open_dead pcap_t");
        return (0);
 }
            "Packets cannot be transmitted on a pcap_open_dead pcap_t");
        return (0);
 }


@@ -1837,7 +1837,7 @@ pcap_setuserbuffer(pcap_t *p, int size)
 static int
 pcap_setuserbuffer_dead(pcap_t *p, int size)
 {
 static int
 pcap_setuserbuffer_dead(pcap_t *p, int size)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The user buffer cannot be set on a pcap_open_dead pcap_t");
        return (-1);
 }
            "The user buffer cannot be set on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1851,7 +1851,7 @@ pcap_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks)
 static int
 pcap_live_dump_dead(pcap_t *p, char *filename, int maxsize, int maxpacks)
 {
 static int
 pcap_live_dump_dead(pcap_t *p, char *filename, int maxsize, int maxpacks)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
        return (-1);
 }
            "Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1865,7 +1865,7 @@ pcap_live_dump_ended(pcap_t *p, int sync)
 static int
 pcap_live_dump_ended_dead(pcap_t *p, int sync)
 {
 static int
 pcap_live_dump_ended_dead(pcap_t *p, int sync)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
        return (-1);
 }
            "Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -1877,7 +1877,7 @@ pcap_get_airpcap_handle(pcap_t *p)
 
        handle = p->get_airpcap_handle_op(p);
        if (handle == NULL) {
 
        handle = p->get_airpcap_handle_op(p);
        if (handle == NULL) {

-               (void)snprintf(p->errbuf, sizeof(p->errbuf),
+               (void)pcap_snprintf(p->errbuf, sizeof(p->errbuf),

                    "This isn't an AirPcap device");
        }
        return (handle);
                    "This isn't an AirPcap device");
        }
        return (handle);

diff --git a/savefile.c b/savefile.c
index 1032b43e8a99754c6fe11b10abc3131025ba745f..b8d1d305805436a17af8353c00b078cd3716f0e4 100644 (file)
--- a/savefile.c
+++ b/savefile.c
@@ -96,7 +96,7 @@ sf_setnonblock(pcap_t *p, int nonblock, char *errbuf)
         * as it would have to handle reading partial packets and
         * keeping the state of the read.)
         */
         * as it would have to handle reading partial packets and
         * keeping the state of the read.)
         */

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Savefiles cannot be put into non-blocking mode");
        return (-1);
 }
            "Savefiles cannot be put into non-blocking mode");
        return (-1);
 }


@@ -104,7 +104,7 @@ sf_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 static int
 sf_stats(pcap_t *p, struct pcap_stat *ps)
 {
 static int
 sf_stats(pcap_t *p, struct pcap_stat *ps)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Statistics aren't available from savefiles");
        return (-1);
 }
            "Statistics aren't available from savefiles");
        return (-1);
 }


@@ -113,7 +113,7 @@ sf_stats(pcap_t *p, struct pcap_stat *ps)
 static struct pcap_stat *
 sf_stats_ex(pcap_t *p, int *size)
 {
 static struct pcap_stat *
 sf_stats_ex(pcap_t *p, int *size)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Statistics aren't available from savefiles");
        return (NULL);
 }
            "Statistics aren't available from savefiles");
        return (NULL);
 }


@@ -121,7 +121,7 @@ sf_stats_ex(pcap_t *p, int *size)
 static int
 sf_setbuff(pcap_t *p, int dim)
 {
 static int
 sf_setbuff(pcap_t *p, int dim)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The kernel buffer size cannot be set while reading from a file");
        return (-1);
 }
            "The kernel buffer size cannot be set while reading from a file");
        return (-1);
 }


@@ -129,7 +129,7 @@ sf_setbuff(pcap_t *p, int dim)
 static int
 sf_setmode(pcap_t *p, int mode)
 {
 static int
 sf_setmode(pcap_t *p, int mode)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "impossible to set mode while reading from a file");
        return (-1);
 }
            "impossible to set mode while reading from a file");
        return (-1);
 }


@@ -137,7 +137,7 @@ sf_setmode(pcap_t *p, int mode)
 static int
 sf_setmintocopy(pcap_t *p, int size)
 {
 static int
 sf_setmintocopy(pcap_t *p, int size)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The mintocopy parameter cannot be set while reading from a file");
        return (-1);
 }
            "The mintocopy parameter cannot be set while reading from a file");
        return (-1);
 }


@@ -145,7 +145,7 @@ sf_setmintocopy(pcap_t *p, int size)
 static HANDLE
 sf_getevent(pcap_t *pcap)
 {
 static HANDLE
 sf_getevent(pcap_t *pcap)
 {

-       (void)snprintf(pcap->errbuf, sizeof(pcap->errbuf),
+       (void)pcap_snprintf(pcap->errbuf, sizeof(pcap->errbuf),

            "The read event cannot be retrieved while reading from a file");
        return (INVALID_HANDLE_VALUE);
 }
            "The read event cannot be retrieved while reading from a file");
        return (INVALID_HANDLE_VALUE);
 }


@@ -154,7 +154,7 @@ static int
 sf_oid_get_request(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_,
     size_t len _U_)
 {
 sf_oid_get_request(pcap_t *p, bpf_u_int32 oid _U_, void *data _U_,
     size_t len _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "An OID get request cannot be performed on a file");
        return (PCAP_ERROR);
 }
            "An OID get request cannot be performed on a file");
        return (PCAP_ERROR);
 }


@@ -163,7 +163,7 @@ static int
 sf_oid_set_request(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
     size_t len _U_)
 {
 sf_oid_set_request(pcap_t *p, bpf_u_int32 oid _U_, const void *data _U_,
     size_t len _U_)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "An OID set request cannot be performed on a file");
        return (PCAP_ERROR);
 }
            "An OID set request cannot be performed on a file");
        return (PCAP_ERROR);
 }


@@ -179,7 +179,7 @@ sf_sendqueue_transmit(pcap_t *p, pcap_send_queue *queue, int sync)
 static int
 sf_setuserbuffer(pcap_t *p, int size)
 {
 static int
 sf_setuserbuffer(pcap_t *p, int size)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "The user buffer cannot be set when reading from a file");
        return (-1);
 }
            "The user buffer cannot be set when reading from a file");
        return (-1);
 }


@@ -187,7 +187,7 @@ sf_setuserbuffer(pcap_t *p, int size)
 static int
 sf_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks)
 {
 static int
 sf_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Live packet dumping cannot be performed when reading from a file");
        return (-1);
 }
            "Live packet dumping cannot be performed when reading from a file");
        return (-1);
 }


@@ -195,7 +195,7 @@ sf_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks)
 static int
 sf_live_dump_ended(pcap_t *p, int sync)
 {
 static int
 sf_live_dump_ended(pcap_t *p, int sync)
 {

-       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

            "Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
        return (-1);
 }
            "Live packet dumping cannot be performed on a pcap_open_dead pcap_t");
        return (-1);
 }


@@ -222,7 +222,7 @@ sf_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
 static int
 sf_setdirection(pcap_t *p, pcap_direction_t d)
 {
 static int
 sf_setdirection(pcap_t *p, pcap_direction_t d)
 {

-       snprintf(p->errbuf, sizeof(p->errbuf),
+       pcap_snprintf(p->errbuf, sizeof(p->errbuf),

            "Setting direction is not supported on savefiles");
        return (-1);
 }
            "Setting direction is not supported on savefiles");
        return (-1);
 }


@@ -262,7 +262,7 @@ pcap_open_offline_with_tstamp_precision(const char *fname, u_int precision,
                fp = fopen(fname, "rb");
 #endif
                if (fp == NULL) {
                fp = fopen(fname, "rb");
 #endif
                if (fp == NULL) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", fname,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "%s: %s", fname,

                            pcap_strerror(errno));
                        return (NULL);
                }
                            pcap_strerror(errno));
                        return (NULL);
                }


@@ -292,14 +292,14 @@ pcap_t* pcap_hopen_offline_with_tstamp_precision(intptr_t osfd, u_int precision,
        fd = _open_osfhandle(osfd, _O_RDONLY);
        if ( fd < 0 )
        {
        fd = _open_osfhandle(osfd, _O_RDONLY);
        if ( fd < 0 )
        {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));

                return NULL;
        }
 
        file = _fdopen(fd, "rb");
        if ( file == NULL )
        {
                return NULL;
        }
 
        file = _fdopen(fd, "rb");
        if ( file == NULL )
        {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, pcap_strerror(errno));

                return NULL;
        }
 
                return NULL;
        }
 


@@ -344,11 +344,11 @@ pcap_fopen_offline_with_tstamp_precision(FILE *fp, u_int precision,
        amt_read = fread((char *)&magic, 1, sizeof(magic), fp);
        if (amt_read != sizeof(magic)) {
                if (ferror(fp)) {
        amt_read = fread((char *)&magic, 1, sizeof(magic), fp);
        if (amt_read != sizeof(magic)) {
                if (ferror(fp)) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "error reading dump file: %s",
                            pcap_strerror(errno));
                } else {
                            "error reading dump file: %s",
                            pcap_strerror(errno));
                } else {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "truncated dump file; tried to read %lu file header bytes, only got %lu",
                            (unsigned long)sizeof(magic),
                            (unsigned long)amt_read);
                            "truncated dump file; tried to read %lu file header bytes, only got %lu",
                            (unsigned long)sizeof(magic),
                            (unsigned long)amt_read);


@@ -376,7 +376,7 @@ pcap_fopen_offline_with_tstamp_precision(FILE *fp, u_int precision,
        /*
         * Well, who knows what this mess is....
         */
        /*
         * Well, who knows what this mess is....
         */

-       snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown file format");
+       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "unknown file format");

        return (NULL);
 
 found:
        return (NULL);
 
 found:

diff --git a/sf-pcap-ng.c b/sf-pcap-ng.c
index ec1b9639fd21e150717ed78d9a984f5d7d3c6fe7..2d4ec8135f5f9b9fe9b10d838b9b86ddadd1f0f8 100644 (file)
--- a/sf-pcap-ng.c
+++ b/sf-pcap-ng.c
@@ -240,13 +240,13 @@ read_bytes(FILE *fp, void *buf, size_t bytes_to_read, int fail_on_eof,
        amt_read = fread(buf, 1, bytes_to_read, fp);
        if (amt_read != bytes_to_read) {
                if (ferror(fp)) {
        amt_read = fread(buf, 1, bytes_to_read, fp);
        if (amt_read != bytes_to_read) {
                if (ferror(fp)) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "error reading dump file: %s",
                            pcap_strerror(errno));
                } else {
                        if (amt_read == 0 && !fail_on_eof)
                                return (0);     /* EOF */
                            "error reading dump file: %s",
                            pcap_strerror(errno));
                } else {
                        if (amt_read == 0 && !fail_on_eof)
                                return (0);     /* EOF */

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "truncated dump file; tried to read %lu bytes, only got %lu",
                            (unsigned long)bytes_to_read,
                            (unsigned long)amt_read);
                            "truncated dump file; tried to read %lu bytes, only got %lu",
                            (unsigned long)bytes_to_read,
                            (unsigned long)amt_read);


@@ -281,7 +281,7 @@ read_block(FILE *fp, pcap_t *p, struct block_cursor *cursor, char *errbuf)
         * memory if we read a malformed file.
         */
        if (bhdr.total_length > 16*1024*1024) {
         * memory if we read a malformed file.
         */
        if (bhdr.total_length > 16*1024*1024) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "pcap-ng block size %u > maximum %u",
                    bhdr.total_length, 16*1024*1024);
                    return (-1);
                    "pcap-ng block size %u > maximum %u",
                    bhdr.total_length, 16*1024*1024);
                    return (-1);


@@ -293,7 +293,7 @@ read_block(FILE *fp, pcap_t *p, struct block_cursor *cursor, char *errbuf)
         */
        if (bhdr.total_length < sizeof(struct block_header) +
            sizeof(struct block_trailer)) {
         */
        if (bhdr.total_length < sizeof(struct block_header) +
            sizeof(struct block_trailer)) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "block in pcap-ng dump file has a length of %u < %lu",
                    bhdr.total_length,
                    (unsigned long)(sizeof(struct block_header) + sizeof(struct block_trailer)));
                    "block in pcap-ng dump file has a length of %u < %lu",
                    bhdr.total_length,
                    (unsigned long)(sizeof(struct block_header) + sizeof(struct block_trailer)));


@@ -311,7 +311,7 @@ read_block(FILE *fp, pcap_t *p, struct block_cursor *cursor, char *errbuf)
 
                bigger_buffer = realloc(p->buffer, bhdr.total_length);
                if (bigger_buffer == NULL) {
 
                bigger_buffer = realloc(p->buffer, bhdr.total_length);
                if (bigger_buffer == NULL) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");

                        return (-1);
                }
                p->buffer = bigger_buffer;
                        return (-1);
                }
                p->buffer = bigger_buffer;


@@ -347,7 +347,7 @@ get_from_block_data(struct block_cursor *cursor, size_t chunk_size,
         * the block data.
         */
        if (cursor->data_remaining < chunk_size) {
         * the block data.
         */
        if (cursor->data_remaining < chunk_size) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "block of type %u in pcap-ng dump file is too short",
                    cursor->block_type);
                return (NULL);
                    "block of type %u in pcap-ng dump file is too short",
                    cursor->block_type);
                return (NULL);


@@ -448,7 +448,7 @@ process_idb_options(pcap_t *p, struct block_cursor *cursor, u_int *tsresol,
 
                case OPT_ENDOFOPT:
                        if (opthdr->option_length != 0) {
 
                case OPT_ENDOFOPT:
                        if (opthdr->option_length != 0) {

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "Interface Description Block has opt_endofopt option with length %u != 0",
                                    opthdr->option_length);
                                return (-1);
                                    "Interface Description Block has opt_endofopt option with length %u != 0",
                                    opthdr->option_length);
                                return (-1);


@@ -457,13 +457,13 @@ process_idb_options(pcap_t *p, struct block_cursor *cursor, u_int *tsresol,
 
                case IF_TSRESOL:
                        if (opthdr->option_length != 1) {
 
                case IF_TSRESOL:
                        if (opthdr->option_length != 1) {

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "Interface Description Block has if_tsresol option with length %u != 1",
                                    opthdr->option_length);
                                return (-1);
                        }
                        if (saw_tsresol) {
                                    "Interface Description Block has if_tsresol option with length %u != 1",
                                    opthdr->option_length);
                                return (-1);
                        }
                        if (saw_tsresol) {

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "Interface Description Block has more than one if_tsresol option");
                                return (-1);
                        }
                                    "Interface Description Block has more than one if_tsresol option");
                                return (-1);
                        }


@@ -489,11 +489,11 @@ process_idb_options(pcap_t *p, struct block_cursor *cursor, u_int *tsresol,
                                 * Resolution is too high.
                                 */
                                if (tsresol_opt & 0x80) {
                                 * Resolution is too high.
                                 */
                                if (tsresol_opt & 0x80) {

-                                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                            "Interface Description Block if_tsresol option resolution 2^-%u is too high",
                                            tsresol_opt & 0x7F);
                                } else {
                                            "Interface Description Block if_tsresol option resolution 2^-%u is too high",
                                            tsresol_opt & 0x7F);
                                } else {

-                                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                            "Interface Description Block if_tsresol option resolution 10^-%u is too high",
                                            tsresol_opt);
                                }
                                            "Interface Description Block if_tsresol option resolution 10^-%u is too high",
                                            tsresol_opt);
                                }


@@ -503,13 +503,13 @@ process_idb_options(pcap_t *p, struct block_cursor *cursor, u_int *tsresol,
 
                case IF_TSOFFSET:
                        if (opthdr->option_length != 8) {
 
                case IF_TSOFFSET:
                        if (opthdr->option_length != 8) {

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "Interface Description Block has if_tsoffset option with length %u != 8",
                                    opthdr->option_length);
                                return (-1);
                        }
                        if (saw_tsoffset) {
                                    "Interface Description Block has if_tsoffset option with length %u != 8",
                                    opthdr->option_length);
                                return (-1);
                        }
                        if (saw_tsoffset) {

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "Interface Description Block has more than one if_tsoffset option");
                                return (-1);
                        }
                                    "Interface Description Block has more than one if_tsoffset option");
                                return (-1);
                        }


@@ -586,7 +586,7 @@ add_interface(pcap_t *p, struct block_cursor *cursor, char *errbuf)
                                 * possible 32-bit power of 2, as we do
                                 * size doubling.
                                 */
                                 * possible 32-bit power of 2, as we do
                                 * size doubling.
                                 */

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "more than %u interfaces in the file",
                                    0x80000000U);
                                return (0);
                                    "more than %u interfaces in the file",
                                    0x80000000U);
                                return (0);


@@ -617,7 +617,7 @@ add_interface(pcap_t *p, struct block_cursor *cursor, char *errbuf)
                                 * (unsigned) value divided by
                                 * sizeof (struct pcap_ng_if).
                                 */
                                 * (unsigned) value divided by
                                 * sizeof (struct pcap_ng_if).
                                 */

-                               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                                    "more than %u interfaces in the file",
                                    0xFFFFFFFFU / ((u_int)sizeof (struct pcap_ng_if)));
                                return (0);
                                    "more than %u interfaces in the file",
                                    0xFFFFFFFFU / ((u_int)sizeof (struct pcap_ng_if)));
                                return (0);


@@ -629,7 +629,7 @@ add_interface(pcap_t *p, struct block_cursor *cursor, char *errbuf)
                         * We ran out of memory.
                         * Give up.
                         */
                         * We ran out of memory.
                         * Give up.
                         */

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "out of memory for per-interface information (%u interfaces)",
                            ps->ifcount);
                        return (0);
                            "out of memory for per-interface information (%u interfaces)",
                            ps->ifcount);
                        return (0);


@@ -754,7 +754,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
        amt_read = fread(&total_length, 1, sizeof(total_length), fp);
        if (amt_read < sizeof(total_length)) {
                if (ferror(fp)) {
        amt_read = fread(&total_length, 1, sizeof(total_length), fp);
        if (amt_read < sizeof(total_length)) {
                if (ferror(fp)) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "error reading dump file: %s",
                            pcap_strerror(errno));
                        *err = 1;
                            "error reading dump file: %s",
                            pcap_strerror(errno));
                        *err = 1;


@@ -770,7 +770,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
        amt_read = fread(&byte_order_magic, 1, sizeof(byte_order_magic), fp);
        if (amt_read < sizeof(byte_order_magic)) {
                if (ferror(fp)) {
        amt_read = fread(&byte_order_magic, 1, sizeof(byte_order_magic), fp);
        if (amt_read < sizeof(byte_order_magic)) {
                if (ferror(fp)) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "error reading dump file: %s",
                            pcap_strerror(errno));
                        *err = 1;
                            "error reading dump file: %s",
                            pcap_strerror(errno));
                        *err = 1;


@@ -799,7 +799,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
         * Check the sanity of the total length.
         */
        if (total_length < sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct block_trailer)) {
         * Check the sanity of the total length.
         */
        if (total_length < sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct block_trailer)) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "Section Header Block in pcap-ng dump file has a length of %u < %lu",
                    total_length,
                    (unsigned long)(sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct block_trailer)));
                    "Section Header Block in pcap-ng dump file has a length of %u < %lu",
                    total_length,
                    (unsigned long)(sizeof(*bhdrp) + sizeof(*shbp) + sizeof(struct block_trailer)));


@@ -834,7 +834,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
                break;
 
        default:
                break;
 
        default:

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "unknown time stamp resolution %u", precision);
                free(p);
                *err = 1;
                    "unknown time stamp resolution %u", precision);
                free(p);
                *err = 1;


@@ -860,7 +860,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
                p->bufsize = total_length;
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {
                p->bufsize = total_length;
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");

                free(p);
                *err = 1;
                return (NULL);
                free(p);
                *err = 1;
                return (NULL);


@@ -918,7 +918,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
                status = read_block(fp, p, &cursor, errbuf);
                if (status == 0) {
                        /* EOF - no IDB in this file */
                status = read_block(fp, p, &cursor, errbuf);
                if (status == 0) {
                        /* EOF - no IDB in this file */

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "the capture file has no Interface Description Blocks");
                        goto fail;
                }
                            "the capture file has no Interface Description Blocks");
                        goto fail;
                }


@@ -971,7 +971,7 @@ pcap_ng_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
                         * not valid, as we don't know what link-layer
                         * encapsulation the packet has.
                         */
                         * not valid, as we don't know what link-layer
                         * encapsulation the packet has.
                         */

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "the capture file has a packet block before any Interface Description Blocks");
                        goto fail;
 
                            "the capture file has a packet block before any Interface Description Blocks");
                        goto fail;
 


@@ -1168,13 +1168,13 @@ pcap_ng_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                         * interfaces?
                         */
                        if (p->linktype != idbp->linktype) {
                         * interfaces?
                         */
                        if (p->linktype != idbp->linktype) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "an interface has a type %u different from the type of the first interface",
                                    idbp->linktype);
                                return (-1);
                        }
                        if (p->snapshot != idbp->snaplen) {
                                    "an interface has a type %u different from the type of the first interface",
                                    idbp->linktype);
                                return (-1);
                        }
                        if (p->snapshot != idbp->snaplen) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "an interface has a snapshot length %u different from the type of the first interface",
                                    idbp->snaplen);
                                return (-1);
                                    "an interface has a snapshot length %u different from the type of the first interface",
                                    idbp->snaplen);
                                return (-1);


@@ -1226,7 +1226,7 @@ pcap_ng_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                                /*
                                 * Byte order changes.
                                 */
                                /*
                                 * Byte order changes.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "the file has sections with different byte orders");
                                return (-1);
 
                                    "the file has sections with different byte orders");
                                return (-1);
 


@@ -1234,7 +1234,7 @@ pcap_ng_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                                /*
                                 * Not a valid SHB.
                                 */
                                /*
                                 * Not a valid SHB.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "the file has a section with a bad byte order magic field");
                                return (-1);
                        }
                                    "the file has a section with a bad byte order magic field");
                                return (-1);
                        }


@@ -1244,7 +1244,7 @@ pcap_ng_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                         * we handle.
                         */
                        if (shbp->major_version != PCAP_NG_VERSION_MAJOR) {
                         * we handle.
                         */
                        if (shbp->major_version != PCAP_NG_VERSION_MAJOR) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "unknown pcap-ng savefile major version number %u",
                                    shbp->major_version);
                                return (-1);
                                    "unknown pcap-ng savefile major version number %u",
                                    shbp->major_version);
                                return (-1);


@@ -1278,7 +1278,7 @@ found:
                /*
                 * Yes.  Fail.
                 */
                /*
                 * Yes.  Fail.
                 */

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "a packet arrived on interface %u, but there's no Interface Description Block for that interface",
                    interface_id);
                return (-1);
                    "a packet arrived on interface %u, but there's no Interface Description Block for that interface",
                    interface_id);
                return (-1);

diff --git a/sf-pcap.c b/sf-pcap.c
index 554a28bfa1fb8a46e2b0e0056f23e96b5ff6f707..4f47c10159c5ecc5bba756702c2afb840abe0088 100644 (file)
--- a/sf-pcap.c
+++ b/sf-pcap.c
@@ -185,11 +185,11 @@ pcap_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
            sizeof(hdr) - sizeof(hdr.magic), fp);
        if (amt_read != sizeof(hdr) - sizeof(hdr.magic)) {
                if (ferror(fp)) {
            sizeof(hdr) - sizeof(hdr.magic), fp);
        if (amt_read != sizeof(hdr) - sizeof(hdr.magic)) {
                if (ferror(fp)) {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "error reading dump file: %s",
                            pcap_strerror(errno));
                } else {
                            "error reading dump file: %s",
                            pcap_strerror(errno));
                } else {

-                       snprintf(errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                            "truncated dump file; tried to read %lu file header bytes, only got %lu",
                            (unsigned long)sizeof(hdr),
                            (unsigned long)amt_read);
                            "truncated dump file; tried to read %lu file header bytes, only got %lu",
                            (unsigned long)sizeof(hdr),
                            (unsigned long)amt_read);


@@ -211,7 +211,7 @@ pcap_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
        }
 
        if (hdr.version_major < PCAP_VERSION_MAJOR) {
        }
 
        if (hdr.version_major < PCAP_VERSION_MAJOR) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "archaic pcap savefile format");
                *err = 1;
                return (NULL);
                    "archaic pcap savefile format");
                *err = 1;
                return (NULL);


@@ -305,7 +305,7 @@ pcap_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
                break;
 
        default:
                break;
 
        default:

-               snprintf(errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,

                    "unknown time stamp resolution %u", precision);
                free(p);
                *err = 1;
                    "unknown time stamp resolution %u", precision);
                free(p);
                *err = 1;


@@ -400,7 +400,7 @@ pcap_check_header(bpf_u_int32 magic, FILE *fp, u_int precision, char *errbuf,
        }
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {
        }
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {

-               snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "out of memory");

                free(p);
                *err = 1;
                return (NULL);
                free(p);
                *err = 1;
                return (NULL);


@@ -435,13 +435,13 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
        amt_read = fread(&sf_hdr, 1, ps->hdrsize, fp);
        if (amt_read != ps->hdrsize) {
                if (ferror(fp)) {
        amt_read = fread(&sf_hdr, 1, ps->hdrsize, fp);
        if (amt_read != ps->hdrsize) {
                if (ferror(fp)) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "error reading dump file: %s",
                            pcap_strerror(errno));
                        return (-1);
                } else {
                        if (amt_read != 0) {
                            "error reading dump file: %s",
                            pcap_strerror(errno));
                        return (-1);
                } else {
                        if (amt_read != 0) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "truncated dump file; tried to read %lu header bytes, only got %lu",
                                    (unsigned long)ps->hdrsize,
                                    (unsigned long)amt_read);
                                    "truncated dump file; tried to read %lu header bytes, only got %lu",
                                    (unsigned long)ps->hdrsize,
                                    (unsigned long)amt_read);


@@ -527,7 +527,7 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                char discard_buf[4096];
 
                if (hdr->caplen > MAXIMUM_SNAPLEN) {
                char discard_buf[4096];
 
                if (hdr->caplen > MAXIMUM_SNAPLEN) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "invalid packet capture length %u, bigger than "
                            "maximum of %u", hdr->caplen, MAXIMUM_SNAPLEN);
                        return (-1);
                            "invalid packet capture length %u, bigger than "
                            "maximum of %u", hdr->caplen, MAXIMUM_SNAPLEN);
                        return (-1);


@@ -545,7 +545,7 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                amt_read = fread(p->buffer, 1, p->bufsize, fp);
                if (amt_read != p->bufsize) {
                        if (ferror(fp)) {
                amt_read = fread(p->buffer, 1, p->bufsize, fp);
                if (amt_read != p->bufsize) {
                        if (ferror(fp)) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "error reading dump file: %s",
                                    pcap_strerror(errno));
                        } else {
                                    "error reading dump file: %s",
                                    pcap_strerror(errno));
                        } else {


@@ -556,7 +556,7 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                                 * that would fail because we got EOF before
                                 * the read finished.
                                 */
                                 * that would fail because we got EOF before
                                 * the read finished.
                                 */

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "truncated dump file; tried to read %u captured bytes, only got %lu",
                                    hdr->caplen, (unsigned long)amt_read);
                        }
                                    "truncated dump file; tried to read %u captured bytes, only got %lu",
                                    hdr->caplen, (unsigned long)amt_read);
                        }


@@ -576,11 +576,11 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                        bytes_read += amt_read;
                        if (amt_read != bytes_to_read) {
                                if (ferror(fp)) {
                        bytes_read += amt_read;
                        if (amt_read != bytes_to_read) {
                                if (ferror(fp)) {

-                                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                            "error reading dump file: %s",
                                            pcap_strerror(errno));
                                } else {
                                            "error reading dump file: %s",
                                            pcap_strerror(errno));
                                } else {

-                                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                            "truncated dump file; tried to read %u captured bytes, only got %lu",
                                            hdr->caplen, (unsigned long)bytes_read);
                                }
                                            "truncated dump file; tried to read %u captured bytes, only got %lu",
                                            hdr->caplen, (unsigned long)bytes_read);
                                }


@@ -599,11 +599,11 @@ pcap_next_packet(pcap_t *p, struct pcap_pkthdr *hdr, u_char **data)
                amt_read = fread(p->buffer, 1, hdr->caplen, fp);
                if (amt_read != hdr->caplen) {
                        if (ferror(fp)) {
                amt_read = fread(p->buffer, 1, hdr->caplen, fp);
                if (amt_read != hdr->caplen) {
                        if (ferror(fp)) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "error reading dump file: %s",
                                    pcap_strerror(errno));
                        } else {
                                    "error reading dump file: %s",
                                    pcap_strerror(errno));
                        } else {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "truncated dump file; tried to read %u captured bytes, only got %lu",
                                    hdr->caplen, (unsigned long)amt_read);
                        }
                                    "truncated dump file; tried to read %u captured bytes, only got %lu",
                                    hdr->caplen, (unsigned long)amt_read);
                        }


@@ -675,7 +675,7 @@ pcap_setup_dump(pcap_t *p, int linktype, FILE *f, const char *fname)
                setbuf(f, NULL);
 #endif
        if (sf_write_header(p, f, linktype, p->tzoff, p->snapshot) == -1) {
                setbuf(f, NULL);
 #endif
        if (sf_write_header(p, f, linktype, p->tzoff, p->snapshot) == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",

                    fname, pcap_strerror(errno));
                if (f != stdout)
                        (void)fclose(f);
                    fname, pcap_strerror(errno));
                if (f != stdout)
                        (void)fclose(f);


@@ -698,14 +698,14 @@ pcap_dump_open(pcap_t *p, const char *fname)
         * link-layer type, so we can't use it.
         */
        if (!p->activated) {
         * link-layer type, so we can't use it.
         */
        if (!p->activated) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: not-yet-activated pcap_t passed to pcap_dump_open",
                    fname);
                return (NULL);
        }
        linktype = dlt_to_linktype(p->linktype);
        if (linktype == -1) {
                    "%s: not-yet-activated pcap_t passed to pcap_dump_open",
                    fname);
                return (NULL);
        }
        linktype = dlt_to_linktype(p->linktype);
        if (linktype == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: link-layer type %d isn't supported in savefiles",
                    fname, p->linktype);
                return (NULL);
                    "%s: link-layer type %d isn't supported in savefiles",
                    fname, p->linktype);
                return (NULL);


@@ -722,7 +722,7 @@ pcap_dump_open(pcap_t *p, const char *fname)
                f = fopen(fname, "wb");
 #endif
                if (f == NULL) {
                f = fopen(fname, "wb");
 #endif
                if (f == NULL) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",

                            fname, pcap_strerror(errno));
                        return (NULL);
                }
                            fname, pcap_strerror(errno));
                        return (NULL);
                }


@@ -740,7 +740,7 @@ pcap_dump_fopen(pcap_t *p, FILE *f)
 
        linktype = dlt_to_linktype(p->linktype);
        if (linktype == -1) {
 
        linktype = dlt_to_linktype(p->linktype);
        if (linktype == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "stream: link-layer type %d isn't supported in savefiles",
                    p->linktype);
                return (NULL);
                    "stream: link-layer type %d isn't supported in savefiles",
                    p->linktype);
                return (NULL);


@@ -760,7 +760,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
 
        linktype = dlt_to_linktype(p->linktype);
        if (linktype == -1) {
 
        linktype = dlt_to_linktype(p->linktype);
        if (linktype == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                    "%s: link-layer type %d isn't supported in savefiles",
                    fname, linktype);
                return (NULL);
                    "%s: link-layer type %d isn't supported in savefiles",
                    fname, linktype);
                return (NULL);


@@ -774,7 +774,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
        f = fopen(fname, "rb+");
 #endif
        if (f == NULL) {
        f = fopen(fname, "rb+");
 #endif
        if (f == NULL) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",

                    fname, pcap_strerror(errno));
                return (NULL);
        }
                    fname, pcap_strerror(errno));
                return (NULL);
        }


@@ -785,12 +785,12 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
        amt_read = fread(&ph, 1, sizeof (ph), f);
        if (amt_read != sizeof (ph)) {
                if (ferror(f)) {
        amt_read = fread(&ph, 1, sizeof (ph), f);
        if (amt_read != sizeof (ph)) {
                if (ferror(f)) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s",

                            fname, pcap_strerror(errno));
                        fclose(f);
                        return (NULL);
                } else if (feof(f) && amt_read > 0) {
                            fname, pcap_strerror(errno));
                        fclose(f);
                        return (NULL);
                } else if (feof(f) && amt_read > 0) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: truncated pcap file header", fname);
                        fclose(f);
                        return (NULL);
                            "%s: truncated pcap file header", fname);
                        fclose(f);
                        return (NULL);


@@ -826,7 +826,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
 
                case TCPDUMP_MAGIC:
                        if (p->opt.tstamp_precision != PCAP_TSTAMP_PRECISION_MICRO) {
 
                case TCPDUMP_MAGIC:
                        if (p->opt.tstamp_precision != PCAP_TSTAMP_PRECISION_MICRO) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "%s: different time stamp precision, cannot append to file", fname);
                                fclose(f);
                                return (NULL);
                                    "%s: different time stamp precision, cannot append to file", fname);
                                fclose(f);
                                return (NULL);


@@ -835,7 +835,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
 
                case NSEC_TCPDUMP_MAGIC:
                        if (p->opt.tstamp_precision != PCAP_TSTAMP_PRECISION_NANO) {
 
                case NSEC_TCPDUMP_MAGIC:
                        if (p->opt.tstamp_precision != PCAP_TSTAMP_PRECISION_NANO) {

-                               snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                                    "%s: different time stamp precision, cannot append to file", fname);
                                fclose(f);
                                return (NULL);
                                    "%s: different time stamp precision, cannot append to file", fname);
                                fclose(f);
                                return (NULL);


@@ -844,7 +844,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
 
                case SWAPLONG(TCPDUMP_MAGIC):
                case SWAPLONG(NSEC_TCPDUMP_MAGIC):
 
                case SWAPLONG(TCPDUMP_MAGIC):
                case SWAPLONG(NSEC_TCPDUMP_MAGIC):

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: different byte order, cannot append to file", fname);
                        fclose(f);
                        return (NULL);
                            "%s: different byte order, cannot append to file", fname);
                        fclose(f);
                        return (NULL);


@@ -853,13 +853,13 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
                case SWAPLONG(KUZNETZOV_TCPDUMP_MAGIC):
                case NAVTEL_TCPDUMP_MAGIC:
                case SWAPLONG(NAVTEL_TCPDUMP_MAGIC):
                case SWAPLONG(KUZNETZOV_TCPDUMP_MAGIC):
                case NAVTEL_TCPDUMP_MAGIC:
                case SWAPLONG(NAVTEL_TCPDUMP_MAGIC):

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: not a pcap file to which we can append", fname);
                        fclose(f);
                        return (NULL);
 
                default:
                            "%s: not a pcap file to which we can append", fname);
                        fclose(f);
                        return (NULL);
 
                default:

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: not a pcap file", fname);
                        fclose(f);
                        return (NULL);
                            "%s: not a pcap file", fname);
                        fclose(f);
                        return (NULL);


@@ -870,20 +870,20 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
                 */
                if (ph.version_major != PCAP_VERSION_MAJOR ||
                    ph.version_minor != PCAP_VERSION_MINOR) {
                 */
                if (ph.version_major != PCAP_VERSION_MAJOR ||
                    ph.version_minor != PCAP_VERSION_MINOR) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: version is %u.%u, cannot append to file", fname,
                            ph.version_major, ph.version_minor);
                        fclose(f);
                        return (NULL);
                }
                if (linktype != ph.linktype) {
                            "%s: version is %u.%u, cannot append to file", fname,
                            ph.version_major, ph.version_minor);
                        fclose(f);
                        return (NULL);
                }
                if (linktype != ph.linktype) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: different linktype, cannot append to file", fname);
                        fclose(f);
                        return (NULL);
                }
                if (p->snapshot != ph.snaplen) {
                            "%s: different linktype, cannot append to file", fname);
                        fclose(f);
                        return (NULL);
                }
                if (p->snapshot != ph.snaplen) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

                            "%s: different snaplen, cannot append to file", fname);
                        fclose(f);
                        return (NULL);
                            "%s: different snaplen, cannot append to file", fname);
                        fclose(f);
                        return (NULL);


@@ -893,7 +893,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
                 * A header isn't present; attempt to write it.
                 */
                if (sf_write_header(p, f, linktype, p->tzoff, p->snapshot) == -1) {
                 * A header isn't present; attempt to write it.
                 */
                if (sf_write_header(p, f, linktype, p->tzoff, p->snapshot) == -1) {

-                       snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",
+                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't write to %s: %s",

                            fname, pcap_strerror(errno));
                        (void)fclose(f);
                        return (NULL);
                            fname, pcap_strerror(errno));
                        (void)fclose(f);
                        return (NULL);


@@ -904,7 +904,7 @@ pcap_dump_open_append(pcap_t *p, const char *fname)
         * Start writing at the end of the file.
         */
        if (fseek(f, 0, SEEK_END) == -1) {
         * Start writing at the end of the file.
         */
        if (fseek(f, 0, SEEK_END) == -1) {

-               snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't seek to end of %s: %s",
+               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Can't seek to end of %s: %s",

                    fname, pcap_strerror(errno));
                (void)fclose(f);
                return (NULL);
                    fname, pcap_strerror(errno));
                (void)fclose(f);
                return (NULL);